C# ODataQueryOptions类代码示例

 public IHttpActionResult Get(ODataQueryOptions<ODataQueryOptionTest_EntityModel> queryOptions)
 {
     // Don't apply Filter and Expand, but apply Select.
     var appliedQueryOptions = AllowedQueryOptions.Skip | AllowedQueryOptions.Filter | AllowedQueryOptions.Expand;
     var res = queryOptions.ApplyTo(_entityModels, appliedQueryOptions);
     return Ok(res.AsQueryable());
 }

        public IQueryable<Team> GetTeams(ODataQueryOptions queryOptions)
        {
            // Validate query options
            var settings = new ODataValidationSettings()
            {
                MaxTop = 400
            };
            queryOptions.Validate(settings);

            // Apply the filter before going through to check if links exist for significant performance improvements
            var teams = (IQueryable<Team>)queryOptions.ApplyTo(Db.core.Teams);

            // RouteLinker creates Uris for actions
            var linker = new RouteLinker(Request);

            foreach (var team in teams)
            {
                if (team.Links == null)
                {
                    team.Links = new SerializableDynamic();
                    team.Links.url = linker.GetUri<TeamsController>(c => c.GetTeam(team.Number)).ToString();
                }
            }

            var nextRequest = Request.RequestUri;

            return Db.core.Teams.AsQueryable();
        }

 public IHttpActionResult Get(int key, ODataQueryOptions<Customer> options)
 {
     IQueryable<Customer> customerByIdQuery = _context.Customers.Where(c => c.Id == key);
     if (options.IfNoneMatch != null)
     {
         IQueryable<Customer> customerQuery = options.IfNoneMatch.ApplyTo(customerByIdQuery) as IQueryable<Customer>;
         if (!customerQuery.Any())
         {
             // The entity has the same ETag as the one in the If-None-Match header of the request,
             // so it hasn't been modified since it was retrieved the first time.
             return StatusCode(HttpStatusCode.NotModified);
         }
         else
         {
             // The entity has a different ETag than the one specified in the If-None-Match header of the request,
             // so we return the entity.
             return Ok(SingleResult<Customer>.Create(customerByIdQuery));
         }
     }
     else
     {
         // The request didn't contain any ETag, so we return the entity.
         return Ok(SingleResult<Customer>.Create(customerByIdQuery));
     }
 }

        // Pass ODataQueryOptions as parameter, and call validation manually
        public IHttpActionResult GetFromManager(ODataQueryOptions<Manager> queryOptions)
        {
            if (queryOptions.SelectExpand != null)
            {
                queryOptions.SelectExpand.LevelsMaxLiteralExpansionDepth = 5;
            }

            var validationSettings = new ODataValidationSettings { MaxExpansionDepth = 5 };

            try
            {
                queryOptions.Validate(validationSettings);
            }
            catch (ODataException e)
            {
                var responseMessage = new HttpResponseMessage(HttpStatusCode.BadRequest);
                responseMessage.Content = new StringContent(
                    string.Format("The query specified in the URI is not valid. {0}", e.Message));
                return ResponseMessage(responseMessage);
            }

            var querySettings = new ODataQuerySettings();
            var result = queryOptions.ApplyTo(_employees.OfType<Manager>().AsQueryable(), querySettings).AsQueryable();
            return Ok(result, result.GetType());
        }

        public IHttpActionResult Get([FromODataUri] string key, ODataQueryOptions<Person> queryOptions)
        {
            IEnumerable<Person> appliedPeople = TripPinSvcDataSource.Instance.People.Where(item => item.UserName == key);

            if (appliedPeople.Count() == 0)
            {
                return NotFound();
            }

            // TODO : Bug https://aspnetwebstack.codeplex.com/workitem/2033, should get from ODataQueryOptions
            if (Request.Headers.IfNoneMatch.Count > 0)
            {
                if (Request.Headers.IfNoneMatch.ElementAt(0).Tag.Equals("*"))
                {
                    return StatusCode(HttpStatusCode.NotModified);
                }
                else
                {
                    appliedPeople = queryOptions.IfNoneMatch.ApplyTo(appliedPeople.AsQueryable()).Cast<Person>();
                }
            }

            if (appliedPeople.Count() == 0)
            {
                return StatusCode(HttpStatusCode.NotModified);
            }
            else
            {
                return Ok(appliedPeople.Single());
            }
        }

        /// <summary>
        /// Validates the specified query options.
        /// </summary>
        /// <param name="queryOptions">The query options.</param>
        /// <param name="validationSettings">The validation settings.</param>
        /// <exception cref="ODataException">Thrown if the validation fails.</exception>
        internal static void Validate(ODataQueryOptions queryOptions, ODataValidationSettings validationSettings)
        {
            if (queryOptions.Filter != null)
            {
                if ((validationSettings.AllowedQueryOptions & AllowedQueryOptions.Filter) != AllowedQueryOptions.Filter)
                {
                    throw new ODataException(Messages.FilterQueryOptionNotSupported);
                }

                ValidateFunctions(queryOptions.Filter.RawValue, validationSettings);
                ValidateStringFunctions(queryOptions.Filter.RawValue, validationSettings);
                ValidateDateFunctions(queryOptions.Filter.RawValue, validationSettings);
                ValidateMathFunctions(queryOptions.Filter.RawValue, validationSettings);
                ValidateLogicalOperators(queryOptions.Filter.RawValue, validationSettings);
                ValidateArithmeticOperators(queryOptions.Filter.RawValue, validationSettings);
            }

            if (queryOptions.RawValues.Expand != null
                && (validationSettings.AllowedQueryOptions & AllowedQueryOptions.Expand) != AllowedQueryOptions.Expand)
            {
                throw new ODataException(Messages.ExpandQueryOptionNotSupported);
            }

            if (queryOptions.RawValues.Format != null
                && (validationSettings.AllowedQueryOptions & AllowedQueryOptions.Format) != AllowedQueryOptions.Format)
            {
                throw new ODataException(Messages.FormatQueryOptionNotSupported);
            }

            if (queryOptions.RawValues.InlineCount != null
                && (validationSettings.AllowedQueryOptions & AllowedQueryOptions.InlineCount) != AllowedQueryOptions.InlineCount)
            {
                throw new ODataException(Messages.InlineCountQueryOptionNotSupported);
            }

            if (queryOptions.RawValues.OrderBy != null
                && (validationSettings.AllowedQueryOptions & AllowedQueryOptions.OrderBy) != AllowedQueryOptions.OrderBy)
            {
                throw new ODataException(Messages.OrderByQueryOptionNotSupported);
            }

            if (queryOptions.RawValues.Select != null
                && (validationSettings.AllowedQueryOptions & AllowedQueryOptions.Select) != AllowedQueryOptions.Select)
            {
                throw new ODataException(Messages.SelectQueryOptionNotSupported);
            }

            if (queryOptions.RawValues.Skip != null
                && (validationSettings.AllowedQueryOptions & AllowedQueryOptions.Skip) != AllowedQueryOptions.Skip)
            {
                throw new ODataException(Messages.SkipQueryOptionNotSupported);
            }

            if (queryOptions.RawValues.Top != null
                && (validationSettings.AllowedQueryOptions & AllowedQueryOptions.Top) != AllowedQueryOptions.Top)
            {
                throw new ODataException(Messages.TopQueryOptionNotSupported);
            }
        }

        public IHttpActionResult GetDiamondImport(ODataQueryOptions<ProductDiamondImport> options)
        {
            var imports = this.database.DiamondImports.AsQueryable();
            var expands = options.GetExpandPropertyNames();
            if (expands.Contains("Products")) imports = imports.Include(s => s.Products);

            return Ok(imports);
        }

        // Override this method to plug in our custom validator.
        public override void ValidateQuery(HttpRequestMessage request, ODataQueryOptions queryOptions)
        {
            IEdmModel model = queryOptions.Context.Model;
            IPrincipal principal = request.GetRequestContext().Principal;

            queryOptions.Validator = new AuthorizedRolesQueryValidator(model, principal);
            base.ValidateQuery(request, queryOptions);
        }

		public virtual object ApplyQueryOptions(object value, HttpRequest request, ActionDescriptor actionDescriptor, AssembliesResolver assembliesResolver)
		{
			var elementClrType = value is IEnumerable
				? TypeHelper.GetImplementedIEnumerableType(value.GetType())
				: value.GetType();

			var model = request.ODataProperties().Model;
			if (model == null)
			{
				throw Error.InvalidOperation(SRResources.QueryGetModelMustNotReturnNull);
			}

			var queryContext = new ODataQueryContext(
				model,
				elementClrType,
				assembliesResolver,
				request.ODataProperties().Path
				);

			var queryOptions = new ODataQueryOptions(queryContext, request, assembliesResolver);

			var enumerable = value as IEnumerable;
			if (enumerable == null)
			{
				// response is single entity.
				return value;
			}

			// response is a collection.
			var query = (value as IQueryable) ?? enumerable.AsQueryable();

			query = queryOptions.ApplyTo(query,
				new ODataQuerySettings
				{
					// TODO: If we are using SQL, set this to false
					// otherwise if it is entities in code then
					// set it to true
					HandleNullPropagation = 
					//HandleNullPropagationOption.True
					HandleNullPropagationOptionHelper.GetDefaultHandleNullPropagationOption(query),
					PageSize = actionDescriptor.PageSize(),
					SearchDerivedTypeWhenAutoExpand = true
				},
				AllowedQueryOptions.None);
			// Determine if this result should be a single entity
			
			if (ODataCountMediaTypeMapping.IsCountRequest(request))
			{
				long? count = request.ODataProperties().TotalCount;

				if (count.HasValue)
				{
					// Return the count value if it is a $count request.
					return count.Value;
				}
			}
			return query;
		}

 public IHttpActionResult GetBranchesCount(ODataQueryOptions<Office> options)
 {
     IQueryable<Office> eligibleBranches = MonstersInc.Branches.AsQueryable();
     if (options.Filter != null)
     {
         eligibleBranches = options.Filter.ApplyTo(eligibleBranches, new ODataQuerySettings()).Cast<Office>();
     }
     return Ok(eligibleBranches.Count());
 }

        public Task<IHttpActionResult> Get([FromODataUri] Guid id, ODataQueryOptions<SaleHeader> options)
        {
            var sales = this.database.SaleHeaders.Where(s => s.Id == id);
            var expands = options.GetExpandPropertyNames();
            if (expands.Contains("SaleLineItems")) sales = sales.Include(s => s.Items);
            if (expands.Contains("CustomerContacts")) sales = sales.Include(s => s.CustomerContacts);

            return GetODataSingleAsync(sales, options);
        }

        // GET: odata/Orders(5)
        public IHttpActionResult GetOrder([FromODataUri] int key, ODataQueryOptions<Order> queryOptions)
        {
            if (key == 1)
            {
                return Ok(_someOrder);
            }

            return NotFound();
        }

 public override void ValidateQuery(HttpRequestMessage request,
     ODataQueryOptions queryOptions)
 {
     if (queryOptions.OrderBy != null)
     {
         queryOptions.OrderBy.Validator = new MyOrderByValidator();
     }
     base.ValidateQuery(request, queryOptions);
 }

 /// <summary>
 /// Validates the specified query options.
 /// </summary>
 /// <param name="queryOptions">The query options.</param>
 /// <exception cref="ODataException">Thrown if the validation fails.</exception>
 internal static void Validate(ODataQueryOptions queryOptions)
 {
     if (queryOptions.Skip != null)
     {
         if (queryOptions.Skip.Value < 0)
         {
             throw new ODataException(Messages.SkipRawValueInvalid);
         }
     }
 }

        public void Ctor_SuccedsIfEntityTypesMatch()
        {
            ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
            builder.EntitySet<Customer>("Customers");

            ODataQueryContext context = new ODataQueryContext(builder.GetEdmModel(), typeof(Customer));

            ODataQueryOptions<Customer> query = new ODataQueryOptions<Customer>(context, new HttpRequestMessage(HttpMethod.Get, "http://server/?$top=10"));
            Assert.Equal("10", query.Top.RawValue);
        }