C# SearchCriteria类代码示例

 public void ShouldSupportPaging()
 {
     var criteria = new SearchCriteria<TestEntity>();
     criteria.PageBy(2, 25);
     Assert.AreEqual(2, criteria.PageNumber);
     Assert.AreEqual(25, criteria.PageSize);
 }

        public IDictionary<string, string> BuildArgs(SearchCriteria searchCriteria)
        {
            DateTime now = _dateTimeProvider.GetNow();
            string timestamp = _dateTimeProvider.Format(now);
            string associateTag = _generator.Generate();

            var dic = new Dictionary<string, string>
            {
                { "Service", "AWSECommerceService" },
                { "AWSAccessKeyId", _awsOptions.AccessKey },
                { "AssociateTag", associateTag },
                { "Operation", searchCriteria.Operation },
                { "SearchIndex", searchCriteria.SearchIndex },
                { "ResponseGroup", String.Join(",", searchCriteria.ResponseGroups ?? Enumerable.Empty<string>()) },
                { "BrowseNode", searchCriteria.BrowseNode?.ToString(CultureInfo.InvariantCulture) ?? String.Empty },
                { "BrowseNodeId", searchCriteria.BrowseNodeId?.ToString(CultureInfo.InvariantCulture) ?? String.Empty },
                { "IdType", searchCriteria.IdType },
                { "ItemId", searchCriteria.ItemId },
                { "ItemPage", searchCriteria.ItemPage?.ToString(CultureInfo.InvariantCulture) },
                { "Condition", searchCriteria.Condition ?? "All" },
                { "Timestamp", timestamp }
            };

            // Ordering parameters in naturual byte order as required by AWS
            return new SortedDictionary<string, string>(dic, StringComparer.Ordinal);
        }

		/// <summary>
		/// Extracts a list of <see cref="HqlCondition"/> objects from the specified <see cref="SearchCriteria"/>
		/// </summary>
		/// <param name="qualifier">The HQL qualifier to prepend to the criteria variables</param>
		/// <param name="criteria">The search criteria object</param>
		/// <param name="remapHqlExprFunc"></param>
		/// <returns>A list of HQL conditions that are equivalent to the search criteria</returns>
		public static HqlCondition[] FromSearchCriteria(string qualifier, SearchCriteria criteria, Converter<string, string> remapHqlExprFunc)
		{
			var hqlConditions = new List<HqlCondition>();
			if (criteria is SearchConditionBase)
			{
				var sc = (SearchConditionBase)criteria;
				if (sc.Test != SearchConditionTest.None)
				{
					hqlConditions.Add(GetCondition(remapHqlExprFunc(qualifier), sc.Test, sc.Values));
				}
			}
			else
			{
				// recur on subCriteria
				foreach (var subCriteria in criteria.EnumerateSubCriteria())
				{
					// use a different syntax for "extended properties" than regular properties
					var subQualifier = criteria is ExtendedPropertiesSearchCriteria ?
						string.Format("{0}['{1}']", qualifier, subCriteria.GetKey()) :
						string.Format("{0}.{1}", qualifier, subCriteria.GetKey());

					hqlConditions.AddRange(FromSearchCriteria(subQualifier, subCriteria, remapHqlExprFunc));
				}
			}

			return hqlConditions.ToArray();
		}

        public void Execute_Should_Return_Product_Having_ItemAttributes_When_ResponseGroups_Contains_ItemAttributes()
        {
            // Arrange
            const string brand = "brand";
            const string title = "title";
            const string productGroup = "productGroup";
            var detailsPageUrl = new Uri("http://www.amazon.com");
            var customerReviewsUrl = new Uri("http://www.amazon.com");

            var element = XElementFactory.Create("", title, productGroup, brand, detailsPageUrl, customerReviewsUrl);

            var searchCriteria = new SearchCriteria
            {
                ResponseGroups = new[] { "ItemAttributes" }
            };

            var filter = new ItemAttributesProductPipelineFilter();

            // Act
            var product = filter.Execute(new Product(), element, searchCriteria);

            // Assert
            product.Brand.Should().Be(brand);
            product.Title.Should().Be(title);
            product.ProductGroup.Should().Be(productGroup);
            product.DetailsPageUrl.Should().Be(detailsPageUrl);
            product.CustomerReviewsUrl.Should().Be(customerReviewsUrl);
        }

        /// <summary>
        /// Applies a SearchCriteria to the index.
        /// </summary>
        /// <param name="crit">The SearchCriteria to apply.</param>
        /// <returns>A ResultsTable that contains the result of applying the criteria.</returns>
        public ResultsTable GenerateResultsTable(SearchCriteria crit)
        {
            Debug.Assert(crit != null);

            CodeElementWrapperArrayIndexTable idxTable;

            // If using all criteria, perform a copy.
            if (crit.ElementFilter == CodeElementType.All)
            {
                idxTable = (CodeElementWrapperArrayIndexTable) indexTable.Clone();
            }
            else
            {
                idxTable = new CodeElementWrapperArrayIndexTable(codeElementArray);

                for (int i = 0; i < codeElementArray.Count; i++)
                {
                    if (codeElementArray[i].ElementType == crit.ElementFilter)
                    {
                        idxTable.Add(i);
                    }
                }

                idxTable.Sort(new SortCriteria(SortCriteria.SortType.ALPHA));
            }

            var ret = new ResultsTable(idxTable);
            return (ret);
        }

        public void CriteriaSearch()
        {
            var criteria = new SearchCriteria();

            using (var session = TubsDataService.GetStatelessSession())
            {
                var results = TubsDataService.Search(session, criteria);
                Assert.NotNull(results);
                Assert.AreEqual(0, results.Count());

                criteria.Observer = "DJB"; // Dave Burgess, not a real observer.
                results = TubsDataService.Search(session, criteria);
                Assert.NotNull(results);
                Assert.Greater(results.Count(), 4); // Currently 6, but that changes

                criteria.ProgramCode = "PGOB";
                results = TubsDataService.Search(session, criteria);
                Assert.GreaterOrEqual(results.Count(), 1);

                criteria.ProgramCode = String.Empty;
                criteria.Vessel = "TUNA";
                results = TubsDataService.Search(session, criteria);
                Assert.Greater(results.Count(), 5);

                criteria.Vessel = String.Empty;
                criteria.AnyDate = new DateTime(2011, 9, 10);
                results = TubsDataService.Search(session, criteria);
                Assert.Greater(results.Count(), 1);
            }
        }

 /// <summary>
 /// Adds a new <see cref="Core.Model.SearchCriteria"/> to the collection of Searches.
 /// </summary>
 /// <param name="criteria">The Search Criteria to be added</param>
 /// <returns>The UniqueId of the search just added</returns>
 public string AddSearch(SearchCriteria criteria)
 {
     int lastId = GetLastId();
     criteria.UniqueId = ++lastId;
     _unitOfWork.Searches.Add(criteria);
     return criteria.UniqueId.ToString();
 }

 public void ShouldAllowAddingOfCriteria()
 {
     var criteria = new SearchCriteria<TestEntity>();
     criteria.Add(entity => entity.Id.HasValue);
     var list = new List<Expression<Func<TestEntity, bool>>>(criteria.All);
     Assert.IsTrue(list.Count == 1);
     Assert.AreEqual("entity.Id.HasValue", list[0].Body.ToString());
 }

 protected IEnumerable<CourtCaseHeading> GetAllCourtCases(SearchCriteria criteria)
 {
     List<CourtCaseHeading> output = 
         this.CallServiceGet<List<FACCTS.Server.Model.Calculations.CourtCaseHeading>>(string.Format("{0}?{1}", Routes.GetCourtCases.CourtCaseController, criteria.ToString()))
         .Select(x => new CourtCaseHeading(x))
         .ToList();
     return output;
 }

 public ISearchQuery SetCriteria(SearchCriteria criteria)
 {
   if (criteria == null)
   {
     _criteria = SearchCriteria.Empty;
   }
   _criteria = criteria;
   return this;
 }

 /// <summary>
 /// Static <c>Map</c> method maps a <see cref="Core.Model.SearchCriteria"/> class to a 
 /// <see cref="THLibrary.DataModel.SearchViewModel"/> class.
 /// </summary>
 /// <param name="criteria">The SearchCriteria instance.</param>
 /// <returns>The SearchViewModel instance.</returns>
 public static SearchViewModel Map(SearchCriteria criteria)
 {
     SearchViewModel searchVM = new SearchViewModel()
     {
         UniqueId = "",
         Type = Enum.GetName(typeof(SearchTypeEnum), criteria.Type),
         SearchString = criteria.SearchString,
         SearchDate = criteria.SearchDate.ToString()
     };
     return searchVM;
 }

        public JsonResult GetBorrows(SearchCriteria[] searchCriteria, SortOrder[] sort, int page, int pageSize)
        {
            var dao = new BorrowService();

            int count;
            List<Borrow> list = dao.GetBorrows(searchCriteria, sort, page, pageSize, out count);

            var borrows = AutoMapper.Mapper.Map<List<Borrow>, List<BorrowLiteModel>>(list);

            return Json(new { Borrows = borrows, Count = count });
        }

            public static SearchCriteria FromString(string mixed)
            {
                if (mixed.IndexOf(Core.Keyword_ahk, StringComparison.OrdinalIgnoreCase) == -1)
                    return new SearchCriteria { Title = mixed };

                var criteria = new SearchCriteria();
                var i = 0;
                var t = false;

                while ((i = mixed.IndexOf(Core.Keyword_ahk, i, StringComparison.OrdinalIgnoreCase)) != -1)
                {
                    if (!t)
                    {
                        var pre = i == 0 ? string.Empty : mixed.Substring(0, i).Trim(Core.Keyword_Spaces);

                        if (pre.Length != 0)
                            criteria.Title = pre;

                        t = true;
                    }

                    var z = mixed.IndexOfAny(Core.Keyword_Spaces, i);

                    if (z == -1)
                        break;

                    var word = mixed.Substring(i, z - i);

                    var e = mixed.IndexOf(Core.Keyword_ahk, ++i, StringComparison.OrdinalIgnoreCase);
                    var arg = (e == -1 ? mixed.Substring(z) : mixed.Substring(z, e - z)).Trim();
                    long n;

                    switch (word.ToLowerInvariant())
                    {
                        case Core.Keyword_ahk_class: criteria.ClassName = arg; break;
                        case Core.Keyword_ahk_group: criteria.Group = arg; break;

                        case Core.Keyword_ahk_id:
                            if (long.TryParse(arg, out n))
                                criteria.ID = new IntPtr(n);
                            break;

                        case Core.Keyword_ahk_pid:
                            if (long.TryParse(arg, out n))
                                criteria.PID = new IntPtr(n);
                            break;
                    }

                    i++;
                }

                return criteria;
            }

        public SearchControl(ITATSystem itatSystem, bool showTerm1, bool showTerm2, bool showTerm3, bool showTerm4, bool showTerm5, bool showTerm6, bool showTerm7, SearchCriteria searchCriteria)
        {
            this._itatSystem = itatSystem;
            this._displayTerm1 = showTerm1;
            this._displayTerm2 = showTerm2;
            this._displayTerm3 = showTerm3;
            this._displayTerm4 = showTerm4;
            this._displayTerm5 = showTerm5;
            this._displayTerm6 = showTerm6;
            this._displayTerm7 = showTerm7;

            this._searchCriteria=searchCriteria;
        }

 /// <summary>
 /// get a SearchCriteriaFormViewModel containing the criteria and the results of a search
 /// if results in cache
 ///     get it
 /// else
 ///     build searchcriteria from url
 ///     with this, search matchings localisations in repository
 ///     fill the session store with computed results
 /// and returns the results
 /// </summary>
 /// <param name="session">session to look up for results</param>
 /// <param name="parameters">parameters from which to build result of not in session</param>
 /// <returns>a object containing the criteria and the results of a search</returns>
 public SearchCriteriaFormViewModel FillSearchResults(SearchCriteria criteria)
 {
     var place = string.IsNullOrEmpty(criteria.Place) ? "" : criteria.Place.ToLower();
     if (MiscHelpers.SeoConstants.Places.ContainsKey(place))
     {
         var coor = MiscHelpers.SeoConstants.Places[place];
         criteria.LocalisationData.Latitude = coor.Latitude;
         criteria.LocalisationData.Longitude = coor.Longitude;
     }
     var criteriaViewModel = new SearchCriteriaFormViewModel(criteria, true);
     FillResults(criteriaViewModel);
     return criteriaViewModel;
 }