C# Expression.ElementType方法代码示例

 private static Expression SelectResourceByKey(Expression queryExpression, ResourceType resourceType, KeyInstance key)
 {
     for (int i = 0; i < resourceType.KeyProperties.Count; i++)
     {
         Expression expression2;
         ResourceProperty property = resourceType.KeyProperties[i];
         object obj2 = key.AreValuesNamed ? key.NamedValues[property.Name] : key.PositionalValues[i];
         ParameterExpression expression = Expression.Parameter(queryExpression.ElementType(), "element");
         if (property.CanReflectOnInstanceTypeProperty)
         {
             expression2 = Expression.Property(expression, property.Name);
         }
         else
         {
             expression2 = Expression.Convert(Expression.Call(null, DataServiceProviderMethods.GetValueMethodInfo, expression, Expression.Constant(property)), property.Type);
         }
         LambdaExpression predicate = Expression.Lambda(Expression.Equal(expression2, Expression.Constant(obj2)), new ParameterExpression[] { expression });
         queryExpression = queryExpression.QueryableWhere(predicate);
     }
     return queryExpression;
 }

 private static Expression SelectMultiple(Expression queryExpression, ResourceProperty property)
 {
     Type iEnumerableElement = BaseServiceProvider.GetIEnumerableElement(property.Type);
     ParameterExpression expression = Expression.Parameter(queryExpression.ElementType(), "element");
     LambdaExpression selector = Expression.Lambda(Expression.ConvertChecked(Expression.Property(expression, property.Name), typeof(IEnumerable<>).MakeGenericType(new Type[] { iEnumerableElement })), new ParameterExpression[] { expression });
     return queryExpression.QueryableSelectMany(selector);
 }

 private static Expression SelectOpenProperty(Expression queryExpression, string propertyName)
 {
     ParameterExpression expression = Expression.Parameter(queryExpression.ElementType(), "element");
     LambdaExpression selector = Expression.Lambda(Expression.Call(null, OpenTypeMethods.GetValueOpenPropertyMethodInfo, expression, Expression.Constant(propertyName)), new ParameterExpression[] { expression });
     return queryExpression.QueryableSelect(selector);
 }

 private static Expression SelectLateBoundProperty(Expression queryExpression, ResourceProperty property)
 {
     ParameterExpression expression = Expression.Parameter(queryExpression.ElementType(), "element");
     LambdaExpression selector = Expression.Lambda(Expression.Convert(Expression.Call(null, DataServiceProviderMethods.GetValueMethodInfo, expression, Expression.Constant(property)), property.Type), new ParameterExpression[] { expression });
     return queryExpression.QueryableSelect(selector);
 }

 private static Expression SelectLateBoundPropertyMultiple(Expression queryExpression, ResourceProperty property)
 {
     Type iEnumerableElement = BaseServiceProvider.GetIEnumerableElement(property.Type);
     ParameterExpression expression = Expression.Parameter(queryExpression.ElementType(), "element");
     MethodInfo method = DataServiceProviderMethods.GetSequenceValueMethodInfo.MakeGenericMethod(new Type[] { iEnumerableElement });
     LambdaExpression selector = Expression.Lambda(Expression.Call(null, method, expression, Expression.Constant(property)), new ParameterExpression[] { expression });
     return queryExpression.QueryableSelectMany(selector);
 }

 private static Expression SelectDerivedResourceType(Expression queryExpression, ResourceType resourceType)
 {
     if (resourceType.CanReflectOnInstanceType)
     {
         return queryExpression.QueryableOfType(resourceType.InstanceType);
     }
     Type type = queryExpression.ElementType();
     ConstantExpression expression = Expression.Constant(resourceType, typeof(ResourceType));
     return Expression.Call(null, DataServiceExecutionProviderMethods.OfTypeMethodInfo.MakeGenericMethod(new Type[] { type, resourceType.InstanceType }), queryExpression, expression);
 }

 private static Expression SelectElement(Expression queryExpression, ResourceProperty property)
 {
     ParameterExpression expression = Expression.Parameter(queryExpression.ElementType(), "element");
     Expression expression2 = Expression.Property(expression, property.Name);
     if ((property.TypeKind == ResourceTypeKind.Collection) && (expression2.Type != property.Type))
     {
         expression2 = Expression.Convert(expression2, property.Type);
     }
     LambdaExpression selector = Expression.Lambda(expression2, new ParameterExpression[] { expression });
     return queryExpression.QueryableSelect(selector);
 }

        /// <summary>Selects a single resource by key values.</summary>
        /// <param name="queryExpression">Base query for resources</param>
        /// <param name="resourceType">resource type whose keys are specified</param>
        /// <param name="key">Key values for the given resource type.</param>
        /// <returns>A new query that selects the single resource that matches the specified key values.</returns>
        private static Expression SelectResourceByKey(Expression queryExpression, ResourceType resourceType, KeySegment key)
        {
            Debug.Assert(queryExpression != null, "queryExpression != null");
            Debug.Assert(key != null, "key != null");
            
            List<KeyValuePair<string, object>> keyValues = key.Keys.ToList();
            Debug.Assert(keyValues.Count != 0, "keyValues.Count != 0");
            Debug.Assert(resourceType.KeyProperties.Count == keyValues.Count, "resourceType.KeyProperties.Count == keyValues.Count");

            for (int i = 0; i < resourceType.KeyProperties.Count; i++)
            {
                ResourceProperty keyProperty = resourceType.KeyProperties[i];
                Debug.Assert(keyProperty.IsOfKind(ResourcePropertyKind.Key), "keyProperty.IsOfKind(ResourcePropertyKind.Key)");

                object keyValue;
                if (keyValues.Count == 0)
                {
                    keyValue = keyValues[0].Value;
                }
                else
                {
                    keyValue = keyValues.Single(v => v.Key == keyProperty.Name).Value;    
                }
                
                var binaryValue = keyValue as byte[];
                if (binaryValue != null && keyProperty.Type == typeof(System.Data.Linq.Binary))
                {
                    keyValue = new System.Data.Linq.Binary(binaryValue);
                }

                var stringValue = keyValue as string;
                if (stringValue != null && keyProperty.Type == typeof(XElement))
                {
                    keyValue = XElement.Parse(stringValue);
                }

                if (keyProperty.Type == typeof(DateTime))
                {
                    Debug.Assert(keyValue != null && keyValue is DateTimeOffset, "For DateTime properties, the value must be read as DateTimeOffset");
                    keyValue = WebUtil.ConvertDateTimeOffsetToDateTime((DateTimeOffset)keyValue);
                }

                ParameterExpression parameter = Expression.Parameter(queryExpression.ElementType(), "element");
                Expression e;
                if (keyProperty.CanReflectOnInstanceTypeProperty)
                {
                    e = Expression.Property(parameter, keyProperty.Name);
                }
                else
                {
                    e = Expression.Call(null /*instance*/, DataServiceProviderMethods.GetValueMethodInfo, parameter, Expression.Constant(keyProperty));
                    e = Expression.Convert(e, keyProperty.Type);
                }

                BinaryExpression body = Expression.Equal(e, Expression.Constant(keyValue));
                LambdaExpression predicate = Expression.Lambda(body, parameter);
                queryExpression = queryExpression.QueryableWhere(predicate);
            }

            return queryExpression;
        }

        /// <summary>Filters a query like a SQL WHERE clause does.</summary>
        /// <param name="service">Service with data and configuration.</param>
        /// <param name="requestDescription">RequestDescription instance containing information about the current request being parsed.</param>
        /// <param name="source">Original source for query expression.</param>
        /// <returns>The composed query expression.</returns>
        internal static Expression Where(IDataService service, RequestDescription requestDescription, Expression source)
        {
            Debug.Assert(service != null, "service != null");
            Debug.Assert(source != null, "source != null");
            Debug.Assert(requestDescription != null, "requestDescription != null");

            FilterClause filterClause = new RequestExpressionParser(service, requestDescription).ParseFilter();

            if (filterClause == null)
            {
                return source;
            }

            bool filterQueryApplicable = requestDescription.TargetKind == RequestTargetKind.Resource
                                         || requestDescription.TargetKind == RequestTargetKind.OpenProperty
                                         || requestDescription.TargetKind == RequestTargetKind.ComplexObject
                                         || requestDescription.CountOption == RequestQueryCountOption.CountSegment;

            if (!filterQueryApplicable)
            {
                throw DataServiceException.CreateBadRequestError(Strings.RequestQueryProcessor_QueryFilterOptionNotApplicable);
            }

            Type queryElementType = source.ElementType();
            Debug.Assert(queryElementType != null, "queryElementType != null");

            ParameterExpression parameterForIt = Expression.Parameter(queryElementType, "it");
            Debug.Assert(
                (requestDescription.TargetResourceSet == null && (requestDescription.TargetResourceType == null || requestDescription.TargetResourceType.ResourceTypeKind != ResourceTypeKind.EntityType)) ||
                (requestDescription.TargetResourceType != null && requestDescription.TargetResourceType.ResourceTypeKind == ResourceTypeKind.EntityType),
                "setForIt cannot be null if typeForIt is an entity type.");
            Debug.Assert(
                requestDescription.TargetResourceType == null && parameterForIt.Type == typeof(object) ||
                requestDescription.TargetResourceType != null && requestDescription.TargetResourceType.InstanceType == parameterForIt.Type,
                "non-open type expressions should have a typeForIt");

            var translator = NodeToExpressionTranslator.Create(service, requestDescription, parameterForIt);
            LambdaExpression lambda = translator.TranslateFilterClause(filterClause);
            return source.QueryableWhere(lambda);
        }

        private static Expression SelectLateBoundPropertyMultiple(Expression queryExpression, ResourceProperty property)
        {
            Debug.Assert(queryExpression != null, "queryExpression != null");
            Debug.Assert(property != null && property.Kind == ResourcePropertyKind.ResourceSetReference && !property.CanReflectOnInstanceTypeProperty, "property != null && property.Kind == ResourcePropertyKind.ResourceSetReference && !property.CanReflectOnInstanceTypeProperty");

            Type enumerableElement = BaseServiceProvider.GetIEnumerableElement(property.Type);
            ParameterExpression parameter = Expression.Parameter(queryExpression.ElementType(), "element");
            MethodInfo getter = DataServiceProviderMethods.GetSequenceValueMethodInfo.MakeGenericMethod(enumerableElement);
            Expression body = Expression.Call(null /*instance*/, getter, parameter, Expression.Constant(property));
            LambdaExpression selector = Expression.Lambda(body, parameter);
            return queryExpression.QueryableSelectMany(selector);
        }

        private static Expression SelectLateBoundProperty(Expression queryExpression, ResourceProperty property)
        {
            Debug.Assert(queryExpression != null, "queryExpression != null");
            Debug.Assert(property != null && !property.CanReflectOnInstanceTypeProperty, "property != null && !property.CanReflectOnInstanceTypeProperty");

            ParameterExpression parameter = Expression.Parameter(queryExpression.ElementType(), "element");
            Expression body = Expression.Call(null /*instance*/, DataServiceProviderMethods.GetValueMethodInfo, parameter, Expression.Constant(property));
            body = Expression.Convert(body, property.Type);
            LambdaExpression selector = Expression.Lambda(body, parameter);
            return queryExpression.QueryableSelect(selector);
        }

        private static Expression SelectOpenProperty(Expression queryExpression, string propertyName)
        {
            Debug.Assert(queryExpression != null, "queryExpression != null");
            Debug.Assert(propertyName != null, "propertyName != null");

            ParameterExpression parameter = Expression.Parameter(queryExpression.ElementType(), "element");
            Expression body = Expression.Call(null /* instance */, OpenTypeMethods.GetValueOpenPropertyMethodInfo, parameter, Expression.Constant(propertyName));
            LambdaExpression selector = Expression.Lambda(body, parameter);
            return queryExpression.QueryableSelect(selector);
        }

        private static Expression SelectMultiple(Expression queryExpression, ResourceProperty property)
        {
            Debug.Assert(queryExpression != null, "queryExpression != null");
            Debug.Assert(property.Kind == ResourcePropertyKind.ResourceSetReference, "property == ResourcePropertyKind.ResourceSetReference");

            Type enumerableElement = BaseServiceProvider.GetIEnumerableElement(property.Type);
            Debug.Assert(enumerableElement != null, "Providers should never expose a property as a resource-set if it doesn't implement IEnumerable`1.");

            ParameterExpression parameter = Expression.Parameter(queryExpression.ElementType(), "element");
            UnaryExpression body =
                Expression.ConvertChecked(
                    Expression.Property(parameter, property.Name),
                    typeof(IEnumerable<>).MakeGenericType(enumerableElement));
            LambdaExpression selector = Expression.Lambda(body, parameter);
            return queryExpression.QueryableSelectMany(selector);
        }

        private static Expression SelectElement(Expression queryExpression, ResourceProperty property)
        {
            Debug.Assert(queryExpression != null, "queryExpression != null");
            Debug.Assert(property.Kind != ResourcePropertyKind.ResourceSetReference, "property != ResourcePropertyKind.ResourceSetReference");

            ParameterExpression parameter = Expression.Parameter(queryExpression.ElementType(), "element");
            Expression body = Expression.Property(parameter, property.Name);

            // If the property is a collection its instance type is always IEnumerable<T>, but the actual type of the property
            //   might be type a type implementing the IEnumerable<T> (Like List<T>). We need to add an explicit cast here
            //   so that our expression types match and we will be able to call the lambda later.
            if (property.TypeKind == ResourceTypeKind.Collection && body.Type != property.Type)
            {
                body = Expression.Convert(body, property.Type);
            }

            LambdaExpression selector = Expression.Lambda(body, parameter);
            return queryExpression.QueryableSelect(selector);
        }