C# IQueryable.Search方法代码示例

        /// <summary>
        /// Filter the list of Buggs by a search query.
        /// </summary>
        /// <param name="Results">The unfiltered set of Buggs.</param>
        /// <param name="Query">The query to use as a filter.</param>
        /// <returns>A filtered set of Buggs.</returns>
        public IQueryable<Bugg> Search( IQueryable<Bugg> Results, string Query )
        {
            using( FAutoScopedLogTimer LogTimer = new FAutoScopedLogTimer( this.GetType().ToString() + "(Query=" + Query + ")" ) )
            {
                // Also may want to revisit how we search since this could get inefficient for a big search set.
                IQueryable<Bugg> Buggs;
                try
                {
                    string QueryString = HttpUtility.HtmlDecode( Query.ToString() );
                    if( QueryString == null )
                    {
                        QueryString = "";
                    }

                    // Take out terms starting with a -
                    string[] Terms = QueryString.Split( "-, ;+".ToCharArray(), StringSplitOptions.RemoveEmptyEntries );
                    string TermsToUse = "";
                    foreach( string Term in Terms )
                    {
                        string CallId = GetFunctionCallId( Term ).ToString();
                        if( !TermsToUse.Contains( CallId ) )
                        {
                            TermsToUse = TermsToUse + "+" + CallId;
                        }
                    }

                    Buggs = (IQueryable<Bugg>)Results.Search( new string[] { "Pattern" }, TermsToUse.Split( "+".ToCharArray() ) );
                }
                catch( Exception Ex )
                {
                    Debug.WriteLine( "Exception in Search: " + Ex.ToString() );
                    Buggs = Results;
                }
                return Buggs;
            }
        }

        public static async Task<IQueryable<Package>> SearchCore(
            ISearchService searchService,
            HttpRequestBase request,
            IQueryable<Package> packages, 
            string searchTerm, 
            string targetFramework, 
            bool includePrerelease,
            CuratedFeed curatedFeed)
        {
            SearchFilter searchFilter;
            // We can only use Lucene if the client queries for the latest versions (IsLatest \ IsLatestStable) versions of a package
            // and specific sort orders that we have in the index.
            if (TryReadSearchFilter(request.RawUrl, out searchFilter))
            {
                searchFilter.SearchTerm = searchTerm;
                searchFilter.IncludePrerelease = includePrerelease;
                searchFilter.CuratedFeed = curatedFeed;

                Trace.WriteLine("TODO: use target framework parameter - see #856" + targetFramework);

                var results = await GetResultsFromSearchService(searchService, searchFilter);

                return results;
            }

            if (!includePrerelease)
            {
                packages = packages.Where(p => !p.IsPrerelease);
            }

            return packages.Search(searchTerm);
        }

        public static async Task<IQueryable<Package>> SearchCore(
            ISearchService searchService,
            HttpRequestBase request,
            IQueryable<Package> packages, 
            string searchTerm, 
            string targetFramework, 
            bool includePrerelease,
            CuratedFeed curatedFeed)
        {
            SearchFilter searchFilter;
            // We can only use Lucene if:
            //  a) We are looking for the latest version of a package OR the Index contains all versions of each package
            //  b) The sort order is something Lucene can handle
            if (TryReadSearchFilter(searchService.ContainsAllVersions, request.RawUrl, out searchFilter))
            {
                searchFilter.SearchTerm = searchTerm;
                searchFilter.IncludePrerelease = includePrerelease;
                searchFilter.CuratedFeed = curatedFeed;
                searchFilter.SupportedFramework = targetFramework;

                var results = await GetResultsFromSearchService(searchService, searchFilter);

                return results;
            }

            if (!includePrerelease)
            {
                packages = packages.Where(p => !p.IsPrerelease);
            }

            return packages.Search(searchTerm);
        }

        IQueryable<Record> RecordQueryImpl(RecordQueryInputModel input, IQueryable<RecordIndex.Result> query)
        {
            if (input.Q.IsNotBlank())
            {
                query = query
                    .Search(r => r.Title, input.Q, boost: 10)
                    .Search(r => r.TitleN, input.Q)
                    .Search(r => r.Abstract, input.Q)
                    .Search(r => r.AbstractN, input.Q)
                    .Search(r => r.KeywordsN, input.Q);
            }

            if (input.K != null && input.K.Any())
            {
                foreach (var keyword in ParameterHelper.ParseMetadataKeywords(input.K))
                {
                    string k = keyword.Vocab + "/" + keyword.Value;
                    query = query.Where(r => r.Keywords.Contains(k));
                }
            }

            if (input.D != null)
            {
                query = query.Where(r => r.MetadataDate >= input.D);
            }

            var recordQuery = query.As<Record>(); // ravendb method to project from the index result type to the actual document type

            // allow N to be negative
            if (input.N >= 0)
            {
                recordQuery = recordQuery.Skip(input.P * input.N).Take(input.N);
            }

            return recordQuery;
        }