C# System.Linq.AsQueryable方法代码示例

        public void Handle_should_update_correct_size()
        {
            var widget = new Product { Name = "widget"};
            var gadget = new Product { Name = "gadget"};

            var sizes = new[]
            {
                new Size {Product = widget, Name = "Small", IsActive = false, IsInStock = false},
                new Size {Product = widget, Name = "Medium", IsActive = true, IsInStock = false},
                new Size {Product = widget, Name = "Small", IsActive = true, IsInStock = false}, // should update this one
                new Size {Product = gadget, Name = "Small", IsActive = true, IsInStock = false},
            };

            sizeRepository.GetAllDelegate = () => sizes.AsQueryable();

            var @event = new StockItemInStockChanged("Small", "widget", true);

            handler.Handle(@event);

            sizes[2].IsInStock.ShouldBeTrue();

            sizes[0].IsInStock.ShouldBeFalse();
            sizes[1].IsInStock.ShouldBeFalse();
            sizes[3].IsInStock.ShouldBeFalse();
        }

        public void FindPackagesOverloadLooksForSearchTermsInSpecificFields()
        {
            // Arrange
            var packages = new[] {
                PackageUtility.CreatePackage("Foo.Qux", description: "Some desc"),
                PackageUtility.CreatePackage("X-Package", tags: " lib qux "),
                PackageUtility.CreatePackage("Filtered"),
                PackageUtility.CreatePackage("B", description: "This is a package for qux and not one for baz"),
            };

            // Act
            var result1 = packages.AsQueryable().Find(new[] { "Description", "Tags" }, "Qux");
            var result2 = packages.AsQueryable().Find(new[] { "Id" }, "Filtered");

            // Assert
            Assert.Equal(new[] { packages[1], packages[3] }, result1.ToArray());
            Assert.Equal(new[] { packages[2], }, result2.ToArray());
        }

 public void SetUpPagedList(int pageIndex, int pageSize, int? totalCount)
 {
     var collection = new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
     if (totalCount < 0)
     {
         pagedList = new PagedList<int>(collection.AsQueryable(), pageIndex, pageSize);
     }
     else
     {
         pagedList = new PagedList<int>(collection.AsQueryable(), pageIndex, pageSize, totalCount);
     }
 }

        public void GetByName_VirtualMachineDoesNotExist_ReturnsNull()
        {
            // Arrange
            var machineList = new[]
            {
                new VirtualMachine {Name = "Machine1"},
                new VirtualMachine {Name = "Machine2"},
                new VirtualMachine {Name = "Machine3"}
            };

            var repository = MockRepository.GenerateMock<IVirtualMachineRepository>();
            repository.Expect(x => x.Read())
                .Repeat.Once()
                .Return(machineList.AsQueryable());

            var messenger = MockRepository.GenerateStub<IMessenger>();

            var controller = new VirtualMachinesController(repository, messenger);

            // Act
            var result = controller.Get("FakeMachine");

            // Assert
            Assert.That(result, Is.Null);
        }

        public void GetByName_VirtualMachineExists_RepositoryIsCalled()
        {
            // Arrange
            var machineList = new[]
            {
                new VirtualMachine {Name = "Machine1"},
                new VirtualMachine {Name = "Machine2"},
                new VirtualMachine {Name = "Machine3"}
            };

            var repository = MockRepository.GenerateMock<IVirtualMachineRepository>();
            repository.Expect(x => x.Read())
                .Repeat.Once()
                .Return(machineList.AsQueryable());

            var messenger = MockRepository.GenerateStub<IMessenger>();

            var controller = new VirtualMachinesController(repository, messenger);

            // Act
            controller.Get("Machine2");

            // Assert
            repository.VerifyAllExpectations();
        }

        public void CanExecute()
        {
            //arrange
            var gameRecords = new[] {
                new GameRecord
                {
                    Moves = new[] { new GameMoveRecord{ Value = 0 } },
                },
                new GameRecord
                {
                    Moves = new[] { new GameMoveRecord() },
                },
            };

            var repoMock = new Mock<IRepository>();
            repoMock.Setup(x => x.Query<GameRecord>()).Returns(gameRecords.AsQueryable());

            var query = new FindGames();
            var handler = new FindGamesHandler(repoMock.Object);

            //act
            var result = handler.Execute(query);

            //assert
            Assert.AreEqual(2, result.Count());
            Assert.AreEqual(100, result.First().PercentageComplete);
            Assert.AreEqual(0, result.Last().PercentageComplete);
        }

 static void Main()
 {
     var languages = new[] { "C#", "J#", "VB", "Delphi", "F#", "COBOL", "Python" };
     var queryable = languages.AsQueryable().Where(l => l.EndsWith("#") && l != "j#")
         .Take(3).Select(l => new { Name = l, IsSelected = true });
     new VisualizerDevelopmentHost(queryable.Expression, typeof(ExpressionTreeVisualizer), typeof(ExpressionTreeObjectSource)).ShowVisualizer();
 }

        public void It_gets_an_expression_to_map_A_to_B()
        {
            mapper.Map<A, B>();
            var expr = mapper.GetMapExpression<A, B>();

            var objects = new[]{new A{String="hello world", Int=42}, new A{String="Magic", Int=8}};
            var mapped = objects.AsQueryable().Select(expr);

            Assert.False (mapped.Any (x => x.String == null));
        }

        public override void When()
        {
            this.matchingUserConfiguration = new UserConfiguration { PartitionKey = TestValues.CARD_PARTITION_KEY, RowKey = TestValues.CONFIGURATION_ROW_KEY };
            var nonMatchingUserConfiguration1 = new UserConfiguration { PartitionKey = "Non-matchingPartitionKey", RowKey = TestValues.CONFIGURATION_ROW_KEY };
            var nonMatchingUserConfiguration2 = new UserConfiguration { PartitionKey = TestValues.CARD_PARTITION_KEY, RowKey = "Non-matchingRowKey" };
            var userConfigurations = new[] { this.matchingUserConfiguration, nonMatchingUserConfiguration1, nonMatchingUserConfiguration2 };
            this.TableStorageContext.Setup(x => x.CreateQuery<UserConfiguration>()).Returns(userConfigurations.AsQueryable());

            this.userConfiguration = this.UserConfigurationRepository.GetByNameIdentifier();
        }

		public void WhenCreatingSelectExpressionFromXmlMemberOnPropertyThenGetsPropertyValue()
		{
			var nameResolver = new MemberNameResolver();
			var factory = new SelectExpressionFactory<FakeItem>(nameResolver, new RuntimeTypeProvider(nameResolver));
			var items = new[] { new FakeItem { IntValue = 2 } };

			var expression = factory.Create("Number");

			dynamic result = items.AsQueryable().Select(expression).First();

			Assert.AreEqual(2, result.Number);
		}

		public void WhenCreatingSelectExpressionFromDataMemberOnFieldThenGetsFieldValue()
		{
			var nameResolver = new MemberNameResolver();
			var factory = new SelectExpressionFactory<FakeItem>(nameResolver, new RuntimeTypeProvider(nameResolver));
			var items = new[] { new FakeItem { StringValue = "test" } };

			var expression = factory.Create("Text");

			dynamic result = items.AsQueryable().Select(expression).First();

			Assert.AreEqual("test", result.Text);
		}

        public void TestFindLatest()
        {
            var context = new Mock<Context>();
            var rates = new[] { new Rate { CurrencyCode = "EUR" }, new Rate { CurrencyCode = "USD" } };
            var contextRates = DbSetMockBuilder.Build(rates.AsQueryable());

            context.Setup(c => c.Rates).Returns(contextRates.Object);

            var currencyRatesService = new CurrencyRatesService(context.Object);
            var latestRates = currencyRatesService.FindLatest();

            Assert.That(latestRates, Is.EqualTo(rates));
        }

        public void It_gets_an_expression_to_map_aggregate_to_aggregate()
        {
            mapper.Map<AggregateA, AggregateB> ();
            var expr = mapper.GetMapExpression<AggregateA, AggregateB> ();

            var objects = new[] {
                new AggregateA {Prop=new A{String="hello world", Int=42}},
                new AggregateA{Prop=new A{String="Magic", Int=8}}
            };
            var mapped = objects.AsQueryable ().Select (expr);

            Assert.False (mapped.Any (x => x.Prop == null || x.Prop.String == null));
        }

        protected override void Because_of()
        {
            var sourceList = new[]
            {
                new Source
                {
                    Child1 = new ChildSource(),
                    Child2 = new ChildSource(),
                    Child3 = new ChildSource()
                }
            };

            _dests = sourceList.AsQueryable().ProjectTo<Dest>(d => d.Child2).ToArray();
        }

        public void TestFind()
        {
            var context = new Mock<Context>();
            var rates = new[] { new Rate { Id = 123, CurrencyCode = "EUR" } };
            var contextRates = DbSetMockBuilder.Build(rates.AsQueryable());

            contextRates.Setup(cr => cr.Include("File")).Returns(contextRates.Object);
            context.Setup(c => c.Rates).Returns(contextRates.Object);

            var currencyRatesService = new CurrencyRatesService(context.Object);
            var rate = currencyRatesService.Find(123);

            Assert.That(rate, Is.EqualTo(rates.First()));
        }