C# OrderByQueryOption类代码示例

        public static string BindOrderByQueryOption(OrderByQueryOption orderByQuery)
        {
            StringBuilder sb = new StringBuilder();

            if (orderByQuery != null)
            {
                sb.Append("order by ");
                foreach (var orderByNode in orderByQuery.OrderByNodes)
                {
                    var orderByPropertyNode = orderByNode as OrderByPropertyNode;

                    if (orderByPropertyNode != null)
                    {
                        sb.Append(orderByPropertyNode.Property.Name);
                        sb.Append(orderByPropertyNode.Direction == OrderByDirection.Ascending ? " asc," : " desc,");
                    }
                    else
                    {
                        throw new ODataException("Only ordering by properties is supported");
                    }
                }
            }

            if (sb[sb.Length - 1] == ',')
            {
                sb.Remove(sb.Length - 1, 1);
            }

            return sb.ToString();
        }

        public virtual void Validate(OrderByQueryOption orderByOption, ODataValidationSettings validationSettings)
        {
            if (orderByOption == null)
            {
                throw Error.ArgumentNull("orderByOption");
            }

            if (validationSettings == null)
            {
                throw Error.ArgumentNull("validationSettings");
            }

            if (validationSettings.AllowedOrderByProperties.Count > 0)
            {
                ICollection<OrderByPropertyNode> propertyNodes = orderByOption.PropertyNodes;

                foreach (OrderByPropertyNode property in propertyNodes)
                {
                    if (!validationSettings.AllowedOrderByProperties.Contains(property.Property.Name))
                    {
                        throw new ODataException(Error.Format(SRResources.NotAllowedOrderByProperty, property.Property.Name, "AllowedOrderByProperties"));
                    }
                }
            }
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="ODataQueryOptions"/> class based on the incoming request and some metadata information from 
        /// the <see cref="ODataQueryContext"/>.
        /// </summary>
        /// <param name="context">The <see cref="ODataQueryContext"/> which contains the <see cref="IEdmModel"/> and some type information</param>
        /// <param name="request">The incoming request message</param>
        public ODataQueryOptions(ODataQueryContext context, HttpRequestMessage request)
        {
            if (context == null)
            {
                throw Error.ArgumentNull("context");
            }

            if (request == null)
            {
                throw Error.ArgumentNull("request");
            }

            // remember the context
            Context = context;

            // Parse the query from request Uri
            RawValues = new ODataRawQueryOptions();
            IEnumerable<KeyValuePair<string, string>> queryParameters = request.GetQueryNameValuePairs();
            foreach (KeyValuePair<string, string> kvp in queryParameters)
            {
                switch (kvp.Key)
                {
                    case "$filter":
                        RawValues.Filter = kvp.Value;
                        ThrowIfEmpty(kvp.Value, "$filter");
                        Filter = new FilterQueryOption(kvp.Value, context);
                        break;
                    case "$orderby":
                        RawValues.OrderBy = kvp.Value;
                        ThrowIfEmpty(kvp.Value, "$orderby");
                        OrderBy = new OrderByQueryOption(kvp.Value, context);
                        break;
                    case "$top":
                        RawValues.Top = kvp.Value;
                        ThrowIfEmpty(kvp.Value, "$top");
                        Top = new TopQueryOption(kvp.Value, context);
                        break;
                    case "$skip":
                        RawValues.Skip = kvp.Value;
                        ThrowIfEmpty(kvp.Value, "$skip");
                        Skip = new SkipQueryOption(kvp.Value, context);
                        break;
                    case "$select":
                        RawValues.Select = kvp.Value;
                        break;
                    case "$inlinecount":
                        RawValues.InlineCount = kvp.Value;
                        break;
                    case "$expand":
                        RawValues.Expand = kvp.Value;
                        break;
                    case "$skiptoken":
                        RawValues.SkipToken = kvp.Value;
                        break;
                    default:
                        // we don't throw if we can't recognize the query
                        break;
                }
            }
        }

        public void ValidateAllowsOrderByIt()
        {
            // Arrange
            OrderByQueryOption option = new OrderByQueryOption("$it", new ODataQueryContext(EdmCoreModel.Instance, typeof(int)));
            ODataValidationSettings settings = new ODataValidationSettings();

            // Act & Assert
            Assert.DoesNotThrow(() => _validator.Validate(option, settings));
        }

        public void ValidateAllowsOrderByIt_IfExplicitlySpecified()
        {
            // Arrange
            OrderByQueryOption option = new OrderByQueryOption("$it", new ODataQueryContext(EdmCoreModel.Instance, typeof(int)), queryTranslator: null);
            ODataValidationSettings settings = new ODataValidationSettings { AllowedOrderByProperties = { "$it" } };

            // Act & Assert
            Assert.DoesNotThrow(() => _validator.Validate(option, settings));
        }

        public void ApplyInValidOrderbyQueryThrows(string orderbyValue)
        {
            var model = new ODataModelBuilder().Add_Customer_EntityType().Add_Customers_EntitySet().GetEdmModel();
            var context = new ODataQueryContext(model, typeof(Customer));
            var orderby = new OrderByQueryOption(orderbyValue, context);

            Assert.Throws<ODataException>(() =>
                orderby.ApplyTo(ODataQueryOptionTest.Customers));
        }

        public void CanConstructValidFilterQuery(string orderbyValue)
        {
            var model = new ODataModelBuilder().Add_Customer_EntityType().Add_Customers_EntitySet().GetEdmModel();
            var context = new ODataQueryContext(model, typeof(Customer));
            var orderby = new OrderByQueryOption(orderbyValue, context);

            Assert.Same(context, orderby.Context);
            Assert.Equal(orderbyValue, orderby.RawValue);
        }

        public void ValidateAllowsOrderByIt()
        {
            // Arrange
            OrderByQueryOption option = new OrderByQueryOption("$it", _context);
            ODataValidationSettings settings = new ODataValidationSettings();

            // Act & Assert
            Assert.DoesNotThrow(() => _validator.Validate(option, settings));
        }

        public void ValidateWillAllowId()
        {
            // Arrange
            OrderByQueryOption option = new OrderByQueryOption("Id", _context);
            ODataValidationSettings settings = new ODataValidationSettings();
            settings.AllowedOrderByProperties.Add("Id");

            // Act & Assert
            Assert.DoesNotThrow(() => _validator.Validate(option, settings));
        }

 // Disallow the 'desc' parameter for $orderby option.
 public override void Validate(OrderByQueryOption orderByOption,
                                 ODataValidationSettings validationSettings)
 {
     if (orderByOption.OrderByNodes.Any(
             node => node.Direction == OrderByDirection.Descending))
     {
         throw new ODataException("The 'desc' option is not supported.");
     }
     base.Validate(orderByOption, validationSettings);
 }

        public void ValidateWillNotAllowName()
        {
            // Arrange
            OrderByQueryOption option = new OrderByQueryOption("Name", _context);
            ODataValidationSettings settings = new ODataValidationSettings();
            settings.AllowedOrderByProperties.Add("Id");

            // Act & Assert
            Assert.Throws<ODataException>(() => _validator.Validate(option, settings),
                "Order by 'Name' is not allowed. To allow it, set the 'AllowedOrderByProperties' property on QueryableAttribute or QueryValidationSettings.");
        }

        public void ValidateDisallowsOrderByIt_IfTurnedOff()
        {
            // Arrange
            _context = new ODataQueryContext(EdmCoreModel.Instance, typeof(int));
            OrderByQueryOption option = new OrderByQueryOption("$it", _context, queryTranslator: null);
            ODataValidationSettings settings = new ODataValidationSettings();
            settings.AllowedOrderByProperties.Add("dummy");

            // Act & Assert
            Assert.Throws<ODataException>(
                () => _validator.Validate(option, settings),
                "Order by '$it' is not allowed. To allow it, set the 'AllowedOrderByProperties' property on EnableQueryAttribute or QueryValidationSettings.");
        }

        public static HttpRequestMessage BuildCustomRequest(this ODataQueryOptions originalOptions,
            out TopQueryOption top,
            out SkipQueryOption skip, out OrderByQueryOption orderBy)
        {
            top = null;
            skip = null;
            orderBy = null;

            // cuttin out $top and $skip from the request
            HttpRequestMessage customRequest = originalOptions.Request;

            if (customRequest.Properties.ContainsKey(HttpPropertyKeys.RequestQueryNameValuePairsKey))
            {
                Uri uri = originalOptions.Request.RequestUri;
                var pairs =
                    customRequest.Properties[HttpPropertyKeys.RequestQueryNameValuePairsKey] as
                        IEnumerable<KeyValuePair<string, string>>;

                if (pairs != null)
                {
                    IEnumerable<KeyValuePair<string, string>> jQueryNameValuePairs =
                        new FormDataCollection(uri).GetJQueryNameValuePairs();
                    var updatedPairs = new List<KeyValuePair<string, string>>();

                    foreach (var pair in jQueryNameValuePairs)
                    {
                        if (pair.Key.Equals("$top"))
                        {
                            top = originalOptions.Top;
                        }
                        else if (pair.Key.Equals("$skip"))
                        {
                            skip = originalOptions.Skip;
                        }
                        else if (pair.Key.Equals("$orderby"))
                        {
                            orderBy = originalOptions.OrderBy;
                        }
                        else
                        {
                            updatedPairs.Add(pair);
                        }
                    }

                    customRequest.Properties.Remove(HttpPropertyKeys.RequestQueryNameValuePairsKey);
                    customRequest.Properties.Add(HttpPropertyKeys.RequestQueryNameValuePairsKey, updatedPairs);
                }
            }

            return customRequest;
        }

        public void ValidateWillNotAllowMultipleProperties()
        {
            // Arrange
            OrderByQueryOption option = new OrderByQueryOption("Name desc, Id asc", _context);
            ODataValidationSettings settings = new ODataValidationSettings();
            Assert.DoesNotThrow(() => _validator.Validate(option, settings));

            settings.AllowedOrderByProperties.Add("Address");
            settings.AllowedOrderByProperties.Add("Name");

            // Act & Assert
            Assert.Throws<ODataException>(() => _validator.Validate(option, settings),
                "Order by 'Id' is not allowed. To allow it, set the 'AllowedOrderByProperties' property on QueryableAttribute or QueryValidationSettings.");
        }

        public void GetQueryNodeParsesQuery()
        {
            var model = new ODataModelBuilder().Add_Customer_EntityType().Add_Customers_EntitySet().GetEdmModel();
            var context = new ODataQueryContext(model, typeof(Customer), "Customers");
            var orderby = new OrderByQueryOption("Name,Website", context);
            var node = orderby.QueryNode;

            Assert.Equal(QueryNodeKind.PropertyAccess, node.Expression.Kind);
            var websiteNode = node.Expression as PropertyAccessQueryNode;
            Assert.Equal("Website", websiteNode.Property.Name);

            var nameNode = ((OrderByQueryNode)node.Collection).Expression;
            Assert.Equal(QueryNodeKind.PropertyAccess, nameNode.Kind);
            Assert.Equal("Name", ((PropertyAccessQueryNode)nameNode).Property.Name);
        }