C# IEnumerable.AsQueryable方法代码示例

        public PredictionViewModel(Season currentSeason, Player currentLoggedInPlayer, IEnumerable<Comment> Comments)
        {
            LoggedInPlayer = currentLoggedInPlayer;

            Week week = currentSeason.GetCurrentWeekSeason();
            CurrentWeekText =  string.Format("This Week runs from {0} too {1}, This weeks cutoff for predictions is at {2} on the {3}",
                                week.WeekStarts.ordinalDateShortDay(),
                                week.WeekEnds.ordinalDateShortDay(),
                                week.WeekCutOff.ToString("hh:mm tt"),
                                week.WeekCutOff.ordinalDateShortDay());

            ThisWeeksMatches = week.AllMatches().OrderBy(m =>m.MatchDate.Value);

            MatchOfTheWeek = week.MatchOfTheWeek;

            var PPs = new Dictionary<Player, IEnumerable<PlayerPrediction>>();
            var PlayersWithCompletedPredictions = currentSeason.League.Players.Where(p => p.HasCompletedPredictions(week));
            foreach (var p in PlayersWithCompletedPredictions.OrderByDescending(x=>x.CurrentTotalPoints(currentSeason)))
            {
                PPs.Add(p, p.GetPredictionsForThisWeek().OrderBy(m => m.Match.MatchDate.Value));
            }

            PlayerPredictions = PPs;

            //comments
            CommentModel = new CommentingViewModel(7, week.Id, Comments.AsQueryable(), LoggedInPlayer);
        }

        /// <summary>
        /// Finds the biggest common type of items in the list.
        /// </summary>
        /// <param name="items">The list.</param>
        /// <returns>
        /// The biggest common type.
        /// </returns>
        public static Type FindBiggestCommonType(IEnumerable items)
        {
            if (items == null)
            {
                return null;
            }

            Type type = null;
            foreach (var item in items)
            {
                if (item == null)
                {
                    continue;
                }

                Type itemType = item.GetType();
                if (type == null)
                {
                    type = itemType;
                    continue;
                }

                while (type != null && type.BaseType != null && !type.IsAssignableFrom(itemType))
                {
                    type = type.BaseType;
                }
            }

            if (type == null && items is IList)
            {
                type = items.AsQueryable().ElementType;
            }

            return type;
        }

        public AnnualExpenseSummary(Client client, IEnumerable<Employee> employees)
        {
            ClientCompany = client;
            Employees = employees.AsQueryable();

            CalculatStatistics();
        }

        public void TestJoinOnly(IEnumerable<Foo> foos, IEnumerable<Foo> bars)
        {
            var actual = Factory.MemoryGroupJoin(foos.AsQueryable(), bars.AsQueryable(), f => f.Id, b => b.Id, (f, b) => new { Id = f.Id, BarCount = b.Count() });
            var expected = foos.GroupJoin(bars, f => f.Id, i => i.Id, (f, b) => new { Id = f.Id, BarCount = b.Count() });

            Assert.That(actual.ToArray(), Is.EquivalentTo(expected));
        }

		public IEnumerable<ShipData> GetResult( IEnumerable<ShipData> list ) {

			if ( predicate == null )
				throw new InvalidOperationException( "式がコンパイルされていません。" );

			return list.AsQueryable().Where( predicate ).AsEnumerable();
		}

                public override void SetUp()
                {
                    base.SetUp();
                    _patients = Fixture.CreateMany<Domain.Patient>();

                    _patientRepositoryMock.Setup(r => r.GetPatients()).Returns(_patients.AsQueryable());
                }

 private Mock<IUnitOfWork> SetupUnitOfWork(IEnumerable<Form> data)
 {
     var unitOfWork = new Mock<IUnitOfWork>();
     string[] includeNames = { "Topics", "Topics.Questions", "Topics.Questions.Answers" };
     unitOfWork.Setup(u => u.Query<Form>(includeNames)).Returns(data.AsQueryable());
     return unitOfWork;
 }

        protected override void EstablishContext()
        {
            //Prepare supplied data collections
            suppliedListMetadata = GetSuppliedListMetadata();
            suppliedStudentRow = GetSuppliedStudentRow();
            suppliedPriorYearStudentRow = GetSuppliedPriorYearStudentList();
            suppliedMetricVariants = GetSuppliedMetricVariants();

            //Set up the mocks
            listMetadataProvider = mocks.StrictMock<IListMetadataProvider>();
            studentListUtilitiesProvider = mocks.StrictMock<IStudentListUtilitiesProvider>();
            trendRenderingDispositionProvider = mocks.StrictMock<ITrendRenderingDispositionProvider>();
            metricStateProvider = mocks.StrictMock<IMetricStateProvider>();
            metricVariantRepository = mocks.StrictMock<IRepository<MetricVariant>>();

            windsorContainer = new WindsorContainer();
            windsorContainer.Kernel.Resolver.AddSubResolver(new ArrayResolver(windsorContainer.Kernel));
            RegisterProviders(windsorContainer);
            IoC.Initialize(windsorContainer);

            additionalPriorYearMetricProvider = IoC.Resolve<IAdditionalPriorYearMetricProvider>();

            Expect.Call(metricVariantRepository.GetAll())
                .Return(suppliedMetricVariants.AsQueryable()).Repeat.AtLeastOnce();
        }

        public void SetUp()
        {
            _documents = new List<Document> {new Document()};
            var repository = MockRepository.GenerateMock<IRepository>();
            _homeController = new HomeController(repository);

            repository.Stub(x => x.All<Document>()).Return(_documents.AsQueryable());
        }

        public static IPackageRepositoryFactory Create(IEnumerable<IPackage> packages)
        {
            var packageRepositoryFactory = Substitute.For<IPackageRepositoryFactory>();

            packageRepositoryFactory
                .CreateRepository("repository")
                .GetPackages()
                .Returns(packages.AsQueryable());
            return packageRepositoryFactory;
        }

 public void Delete(IEnumerable<long> itemKeys)
 {
     _items.Query()
         .Join(itemKeys.AsQueryable(),
               item => item.ItemPKey, key => key,
               (item, key) => item)
         .ToList()
         .ForEach(itm => _items.Delete(itm));
     _save.Save();
 }

 public TownRepositoryWithOptimizeRegionTestHelper(
     IEnumerable<Town> towns, IEnumerable<OptimizeRegion> regions)
 {
     this.towns = towns;
     this.regions = regions;
     townRepository.Setup(x => x.GetAll()).Returns(towns.AsQueryable());
     townRepository.Setup(x => x.GetAllList()).Returns(townRepository.Object.GetAll().ToList());
     townRepository.Setup(x => x.Count()).Returns(townRepository.Object.GetAll().Count());
     controller = new RegionController(townRepository.Object, null, null, regionRepository.Object);
 }

        private IEnumerable<Node> CheckMetadataStringOperator(MappingToolDatabaseDataContext dbContext, IEnumerable<Node> nodes, GraphQueryMetadata metadataTest)
        {
            List<Node> filteredNodes = null;

            if (metadataTest.Operator.Equals("Contains", StringComparison.InvariantCultureIgnoreCase))
            {
                IQueryable<Node> queryableNodes = nodes.AsQueryable();
                var filteredMetadata = from dbMetadata in dbContext.udf_SearchMetadataContains(metadataTest.Name, metadataTest.Value) select dbMetadata;
                int counter = filteredMetadata.Count();
                filteredNodes = nodes.Join(filteredMetadata, x => x.NodeUid, y => y.NodeUid, (a, b) => a).ToList();
            }
            else if (metadataTest.Operator.Equals("FreeText", StringComparison.InvariantCultureIgnoreCase))
            {
                IQueryable<Node> queryableNodes = nodes.AsQueryable();
                var filteredMetadata = from dbMetadata in dbContext.udf_SearchMetadataFreeText(metadataTest.Name, metadataTest.Value) select dbMetadata;
                int counter = filteredMetadata.Count();
                filteredNodes = nodes.Join(filteredMetadata, x => x.NodeUid, y => y.NodeUid, (a, b) => a).ToList();
            }
            else
            {
                filteredNodes = new List<Node>();

                foreach (Node node in nodes)
                {
                    if (metadataTest.Operator.Equals("Equals", StringComparison.InvariantCultureIgnoreCase))
                    {
                        if (node.Metadatas.Where(metadata => metadata.MetadataName == metadataTest.Name && metadata.MetadataValue.Contains(metadataTest.Value)).Count() > 0)
                        {
                            filteredNodes.Add(node);
                        }
                    }
                    else if (metadataTest.Operator.Equals("NotEquals", StringComparison.InvariantCultureIgnoreCase))
                    {
                        if (node.Metadatas.Where(metadata => metadata.MetadataName == metadataTest.Name && metadata.MetadataValue != metadataTest.Value).Count() > 0)
                        {
                            filteredNodes.Add(node);
                        }
                    }
                }
            }

            return filteredNodes;
        }

        private void OnNewsItemsAvailable(IEnumerable<NewsItem> newsItems, object userState)
        {
            IEnumerable<NewsItem> orderedItems = newsItems.AsQueryable().OrderByDescending(i => i.PublishDate);

            ViewActionResult result = View("List");
            result.ViewData["Items"] = orderedItems.ToArray();

            Task<ActionResult> task = (Task<ActionResult>)userState;
            task.Complete(result);
        }

        public void FindResources(string searchTerm)
        {
            string searchTermLower = searchTerm.ToLowerInvariant();

            data = DataManager.Resources.Where(item => (item.Title.ToLowerInvariant().Contains(searchTermLower) || item.Tags.ToLowerInvariant().Contains(searchTermLower)));

            results.ItemsSource = data;
            this.DataContext = data;

            OnSearchCompleted(new SearchEventArgs(data.AsQueryable()));
        }