// member assignment private Result RewriteMemberAssignment(BinaryExpression node, Stack stack) { MemberExpression lvalue = (MemberExpression)node.Left; ChildRewriter cr = new ChildRewriter(this, stack, 2); // If there's an instance, it executes on the stack in current state // and rest is executed on non-empty stack. // Otherwise the stack is left unchanged. cr.Add(lvalue.Expression); cr.Add(node.Right); if (cr.Action == RewriteAction.SpillStack) { #if LINQ RequireNotRefInstance(lvalue.Expression); #else MarkRefInstance(cr, lvalue.Expression); #endif } if (cr.Rewrite) { return(cr.Finish( CreateAssignBinaryExpression( MemberExpressionStubs.Make(cr[0], lvalue.Member), cr[1] ) )); } return(new Result(RewriteAction.None, node)); }
internal static System.Linq.Expressions.Expression TransformPredicateExpression(this IQueryVisitor visitor, System.Linq.Expressions.Expression expression) { System.Linq.Expressions.Expression result = expression; if (expression is System.Linq.Expressions.MethodCallExpression) { System.Linq.Expressions.MethodCallExpression methodCallExpression = (System.Linq.Expressions.MethodCallExpression)expression; if ((methodCallExpression.Method == typeof(EntityExtensions).GetMethod("Predicate")) && (methodCallExpression.Arguments.Count > 1) && (methodCallExpression.Arguments[1] != null) && (methodCallExpression.Arguments[1] is System.Linq.Expressions.ConstantExpression)) { object item; if (!TransformedExpressionsCache.TryGetValue(expression, out item)) { object objectValue = ((System.Linq.Expressions.ConstantExpression)methodCallExpression.Arguments[1]).Value; Uri predicate = (Uri)objectValue; Type type; string name; visitor.GetMappingDetails(predicate, methodCallExpression.Arguments[0].Type, out type, out name); System.Linq.Expressions.MemberExpression memberExpression = System.Linq.Expressions.Expression.MakeMemberAccess(methodCallExpression.Arguments[0], type.GetProperty(name)); TransformedExpressionsCache[expression] = result = memberExpression; } else { result = (System.Linq.Expressions.MemberExpression)item; } } } return(result); }
/// <summary>Visits a member expression.</summary> /// <param name="expression">Expression to be visited.</param> /// <returns>Expression visited</returns> protected override System.Linq.Expressions.Expression VisitMember(System.Linq.Expressions.MemberExpression expression) { if ((expression.Member.Name == "Id") && (typeof(IEntity).IsAssignableFrom(expression.Member.DeclaringType))) { Remotion.Linq.Clauses.FromClauseBase target = GetMemberTarget(expression); if (target != null) { return(VisitEntityId(new EntityIdentifierExpression(expression, target))); } ExceptionHelper.ThrowInvalidCastException(typeof(IEntity), expression.Member.DeclaringType); } else if (expression.Member is PropertyInfo) { IPropertyMapping propertyMapping = _entityContext.Mappings.FindPropertyMapping((PropertyInfo)expression.Member); if (propertyMapping != null) { Remotion.Linq.Clauses.FromClauseBase target = GetMemberTarget(expression); if (target != null) { return(VisitEntityProperty(new EntityPropertyExpression(expression, propertyMapping, target, (_itemNameOverride ?? expression.Member.Name)))); } ExceptionHelper.ThrowInvalidCastException(typeof(IEntity), expression.Member.DeclaringType); } else { return(VisitProperty(expression)); } } return(base.VisitMember(expression)); }
private Result RewriteMemberExpression(Expression expr, Stack stack) { MemberExpression node = (MemberExpression)expr; ChildRewriter cr = new ChildRewriter(this, stack, 1); cr.Add(node.Expression); if (cr.Rewrite) { if (cr.Action == RewriteAction.SpillStack && node.Member is PropertyInfo) { // Only need to validate propreties because reading a field // is always side-effect free. #if LINQ RequireNotRefInstance(node.Expression); #else MarkRefInstance(cr, node.Expression); #endif } expr = MemberExpressionStubs.Make(cr[0], node.Member); } return(cr.Finish(expr)); }
// https://stackoverflow.com/questions/321650/how-do-i-set-a-field-value-in-an-c-sharp-expression-tree public static void SetProperty111 <TTarget, TValue>(TTarget target, string fieldName, TValue newValue) { // Class in which to set value System.Linq.Expressions.ParameterExpression targetExp = System.Linq.Expressions.Expression.Parameter(typeof(TTarget), "target"); // Object's type: System.Linq.Expressions.ParameterExpression valueExp = System.Linq.Expressions.Expression.Parameter(typeof(TValue), "value"); // Expression.Property can be used here as well System.Linq.Expressions.MemberExpression memberExp = // System.Linq.Expressions.Expression.Field(targetExp, fieldName); // System.Linq.Expressions.Expression.Property(targetExp, fieldName); System.Linq.Expressions.Expression.PropertyOrField(targetExp, fieldName); System.Linq.Expressions.UnaryExpression conversionExp = System.Linq.Expressions.Expression.Convert(valueExp, memberExp.Type); System.Linq.Expressions.BinaryExpression assignExp = //System.Linq.Expressions.Expression.Assign(memberExp, valueExp); // Without conversion System.Linq.Expressions.Expression.Assign(memberExp, conversionExp); System.Action <TTarget, TValue> setter = System.Linq.Expressions.Expression .Lambda <System.Action <TTarget, TValue> >(assignExp, targetExp, valueExp).Compile(); setter(target, newValue); }
protected override System.Linq.Expressions.Expression VisitMemberAccess(System.Linq.Expressions.MemberExpression m) { if (m.Expression is System.Linq.Expressions.ParameterExpression) { MemberInfo memberInfo = m.Member; string text = string.Empty; if (this.ExcuteType == DMSExcuteType.SELECT) { Type valueType = memberInfo.ReflectedType; DMSTableKeys key = this.TableKeys.Where(q => q.AssemblyQualifiedName == valueType.AssemblyQualifiedName).LastOrDefault(); if (key != null) { text = key.TableSpecialName; if (this.SplitExpression.TableMapping.TokenFlag == true) { text = this.Provider.BuildColumnName(text); } this._strSql.Append(text); this._strSql.Append(this.Provider.TableToken); } text = GetMemberInfoName(memberInfo.Name); if (this.SplitExpression.TableMapping.TokenFlag == true) { text = this.Provider.BuildColumnName(text); } _strSql.Append(text); } } return(base.VisitMemberAccess(m)); }
static ProviderExtensions() { System.Linq.Expressions.ParameterExpression p = System.Linq.Expressions.Expression.Parameter(typeof(System.Data.Common.DbConnection)); System.Linq.Expressions.MemberExpression prop = System.Linq.Expressions.Expression.Property(p, "DbProviderFactory"); System.Linq.Expressions.UnaryExpression con = System.Linq.Expressions.Expression.Convert(prop, typeof(System.Data.Common.DbProviderFactory)); System.Linq.Expressions.LambdaExpression exp = System.Linq.Expressions.Expression.Lambda(con, p); s_func = (Func <System.Data.Common.DbConnection, System.Data.Common.DbProviderFactory>)exp.Compile(); } // End Static Constructor
private static string GetPropertyName <T> (System.Linq.Expressions.Expression <Func <T> > exp) { Ensure(exp.NodeType == System.Linq.Expressions.ExpressionType.Lambda, "Expression must be a lamda"); System.Linq.Expressions.MemberExpression memberExp = exp.Body as System.Linq.Expressions.MemberExpression; Ensure(memberExp != null, "Body of lamba must be a property access."); return(memberExp.Member.Name); }
/// <summary> /// Converts a LINQ member expression into the Infer.NET equivalent. /// </summary> /// <param name="memberExpression"></param> /// <returns></returns> private IExpression ConvertMember(System.Linq.Expressions.MemberExpression memberExpression) { if (memberExpression.Member is PropertyInfo) { var pi = (PropertyInfo)memberExpression.Member; return(Builder.PropRefExpr(Convert(memberExpression.Expression), pi.DeclaringType, pi.Name)); } throw new NotImplementedException("Could not convert member expression of type " + memberExpression.GetType().Name + ": " + memberExpression); }
static void ParseParentProperty(System.Linq.Expressions.MemberExpression expression, ref string propertyName) { if (expression.IsNull()) { return; } // Parent.PropertyName propertyName = expression.Member.Name + "." + propertyName; ParseParentProperty(expression.Expression as System.Linq.Expressions.MemberExpression, ref propertyName); }
public static System.Func <T, TValue> GetGetter <T, TValue>(string fieldName) { System.Linq.Expressions.ParameterExpression p = System.Linq.Expressions.Expression.Parameter(typeof(T)); System.Linq.Expressions.MemberExpression prop = System.Linq.Expressions.Expression.PropertyOrField(p, fieldName); System.Linq.Expressions.UnaryExpression con = System.Linq.Expressions.Expression.Convert(prop, typeof(TValue)); System.Linq.Expressions.LambdaExpression exp = System.Linq.Expressions.Expression.Lambda(con, p); System.Func <T, TValue> getter = (System.Func <T, TValue>)exp.Compile(); return(getter); }
protected override System.Linq.Expressions.Expression VisitMemberAccess(System.Linq.Expressions.MemberExpression m) { var field = m.Member.Name; var fieldNamespace = GetNamespace(m.Member.DeclaringType); ResourceName = field == "Value" ? fieldNamespace : fieldNamespace + "." + field; DefaultValue = Expression.Compile()(); return(base.VisitMemberAccess(m)); }
public static string GetName <T> (this System.Linq.Expressions.Expression <Func <T> > exp) { System.Linq.Expressions.MemberExpression memberExp = exp.Body as System.Linq.Expressions.MemberExpression; if (memberExp == null) { throw new Exception("Body of lamba must be a member access."); } return(memberExp.Member.Name); }
/// <summary> /// 表达式路由 /// </summary> /// <param name="exp"></param> /// <returns></returns> string ExpressionRouter(System.Linq.Expressions.Expression exp) { //获取实体列的特性 List <EntityPropColumnAttributes> columnAttrList = AttributeHelper.GetEntityColumnAtrributes <TEntity>(); string sb = string.Empty; if (exp is System.Linq.Expressions.BinaryExpression)//二元运算符 { System.Linq.Expressions.BinaryExpression be = ((System.Linq.Expressions.BinaryExpression)exp); return(BinarExpressionProvider(be.Left, be.Right, be.NodeType)); } else if (exp is System.Linq.Expressions.MemberExpression)//成员 { System.Linq.Expressions.MemberExpression me = ((System.Linq.Expressions.MemberExpression)exp); return(me.Member.Name); } else if (exp is System.Linq.Expressions.NewArrayExpression)//数组 { System.Linq.Expressions.NewArrayExpression ae = ((System.Linq.Expressions.NewArrayExpression)exp); StringBuilder tmpstr = new StringBuilder(); foreach (System.Linq.Expressions.Expression ex in ae.Expressions) { tmpstr.Append(ExpressionRouter(ex)); tmpstr.Append(","); } return(tmpstr.ToString(0, tmpstr.Length - 1)); } else if (exp is System.Linq.Expressions.MethodCallExpression)//方法 { return(MethodExpression(exp)); } else if (exp is System.Linq.Expressions.ConstantExpression) { System.Linq.Expressions.ConstantExpression ce = ((System.Linq.Expressions.ConstantExpression)exp); if (ce.Value == null) { return("null"); } else if (ce.Value is ValueType) { return(ce.Value.ToString()); } else if (ce.Value is string || ce.Value is DateTime || ce.Value is char) { return(string.Format("{0}", ce.Value.ToString())); } } else if (exp is System.Linq.Expressions.UnaryExpression) { System.Linq.Expressions.UnaryExpression ue = ((System.Linq.Expressions.UnaryExpression)exp); return(ExpressionRouter(ue.Operand)); } return(null); }
/// <summary>Visits an Uri property expression called on <see cref="EntityId" />.</summary> /// <param name="expression">Expression to be visited.</param> /// <returns>Expression visited</returns> protected virtual System.Linq.Expressions.Expression VisitEntityIdUri(System.Linq.Expressions.MemberExpression expression) { bool isInSelectScenario = (_currentComponent.Count == 0); StrongEntityAccessor entityAccessor = (isInSelectScenario ? this.GetEntityAccessor(GetMemberTarget(expression)) : this.GetEntityAccessor(GetSourceExpression(expression))); _query.AddEntityAccessor(entityAccessor); if (isInSelectScenario) { _lastComponent = entityAccessor; } else { foreach (var entityConstrain in entityAccessor.Elements.OfType <EntityConstrain>()) { if (entityConstrain.Value is Identifier) { Identifier identifier = (Identifier)entityConstrain.Value; string constrainIdentifier = _query.RetrieveIdentifier(identifier.Name); string propertyIdentifier = null; Type propertyType = null; if (expression.Expression is System.Linq.Expressions.MemberExpression) { PropertyInfo propertyInfo = (PropertyInfo)((System.Linq.Expressions.MemberExpression)expression.Expression).Member; propertyIdentifier = _query.CreateIdentifier(propertyInfo.Name); propertyType = propertyInfo.PropertyType; } else if (expression.Expression is Remotion.Linq.Clauses.Expressions.QuerySourceReferenceExpression) { Remotion.Linq.Clauses.Expressions.QuerySourceReferenceExpression querySource = (Remotion.Linq.Clauses.Expressions.QuerySourceReferenceExpression)expression.Expression; propertyIdentifier = querySource.ReferencedQuerySource.ItemName; propertyType = querySource.ReferencedQuerySource.ItemType; } if ((constrainIdentifier == propertyIdentifier) && (identifier.NativeType == propertyType)) { _lastComponent = identifier; break; } } } if (_lastComponent == null) { _lastComponent = entityAccessor.About; } HandleComponent(_lastComponent); } return(expression); }
/// <summary> /// Retrieve standard member access such as DateTime.Now, DateTime.Today, etc /// </summary> /// <param name="m"></param> /// <param name="KnownMember"></param> /// <returns></returns> private WalkedToken GetKnownMemberAccess(System.Linq.Expressions.MemberExpression m, WalkedToken KnownMember) { if (m.Member.Name == "Today" && m.Member.ReflectedType == typeof(DateTime)) { KnownMember = walkerFactory.FromConstant(DateTime.Today); } else if (m.Member.Name == "Today" && m.Member.ReflectedType == typeof(DateTime)) { KnownMember = walkerFactory.FromConstant(DateTime.Now); } //else if (m.Member.Name == "Month") && m.Member.ReflectedType == typeof(DateTime)) // KnownMember = return(KnownMember); }
private static string GetArgumentName <T>(System.Linq.Expressions.Expression <System.Func <T> > argument) { string argumentName = null; System.Linq.Expressions.MemberExpression body = (System.Linq.Expressions.MemberExpression)argument.Body; if (body.Member != null) { argumentName = body.Member.Name; } if (argumentName == null) { // could not retrieve argument name } return(argumentName); }
/// <summary>Visits a main from clause.</summary> /// <param name="fromClause">Main from clause to be visited.</param> /// <param name="queryModel">Query model containing given from clause.</param> public override void VisitMainFromClause(MainFromClause fromClause, Remotion.Linq.QueryModel queryModel) { VisitQuerableFromClause(fromClause, queryModel, -1); if (fromClause.FromExpression is System.Linq.Expressions.MemberExpression) { System.Linq.Expressions.MemberExpression memberExpression = (System.Linq.Expressions.MemberExpression)fromClause.FromExpression; if (memberExpression.Member is PropertyInfo) { _visitor.Visit(memberExpression.Expression); _visitor.Visit(memberExpression); } } base.VisitMainFromClause(fromClause, queryModel); }
public static string PropertyName <T, TR> (this System.Linq.Expressions.Expression <Func <T, TR> > exp) { if (exp.NodeType != System.Linq.Expressions.ExpressionType.Lambda) { throw new Exception("Expression must be a lambda"); } System.Linq.Expressions.MemberExpression memberExp = exp.Body as System.Linq.Expressions.MemberExpression; if (memberExp == null) { throw new Exception("Body of lamba must be a property access."); } return(memberExp.Member.Name); }
//public static System.Action<T, object> GetSetter<T>(string fieldName) public static Setter_t <T> GetSetter <T>(string fieldName) { // Class in which to set value System.Linq.Expressions.ParameterExpression targetExp = System.Linq.Expressions.Expression.Parameter(typeof(T), "target"); // Object's type: System.Linq.Expressions.ParameterExpression valueExp = System.Linq.Expressions.Expression.Parameter(typeof(object), "value"); // Expression.Property can be used here as well System.Linq.Expressions.MemberExpression memberExp = null; try { // memberExp = System.Linq.Expressions.Expression.Field(targetExp, fieldName); // memberExp = System.Linq.Expressions.Expression.Property(targetExp, fieldName); memberExp = System.Linq.Expressions.Expression.PropertyOrField(targetExp, fieldName); } catch (System.Exception ex) { return(null); } // http://www.dotnet-tricks.com/Tutorial/linq/RJX7120714-Understanding-Expression-and-Expression-Trees.html System.Linq.Expressions.ConstantExpression targetType = System.Linq.Expressions.Expression.Constant(memberExp.Type); // http://stackoverflow.com/questions/913325/how-do-i-make-a-linq-expression-to-call-a-method System.Linq.Expressions.MethodCallExpression mce = System.Linq.Expressions.Expression.Call(m_FlexibleChangeType, valueExp, targetType); //System.Linq.Expressions.UnaryExpression conversionExp = System.Linq.Expressions.Expression.Convert(valueExp, memberExp.Type); System.Linq.Expressions.UnaryExpression conversionExp = System.Linq.Expressions.Expression.Convert(mce, memberExp.Type); System.Linq.Expressions.BinaryExpression assignExp = // System.Linq.Expressions.Expression.Assign(memberExp, valueExp); // Without conversion System.Linq.Expressions.Expression.Assign(memberExp, conversionExp); // System.Action<TTarget, TValue> setter = System.Linq.Expressions.Expression // System.Action<T, object> setter = System.Linq.Expressions.Expression // .Lambda<System.Action<T, object>>(assignExp, targetExp, valueExp).Compile(); Setter_t <T> setter = System.Linq.Expressions.Expression .Lambda <Setter_t <T> >(assignExp, targetExp, valueExp).Compile(); return(setter); } // End Function GetGetter
public static void CreateFieldExpression() { Animal horse = new Animal(); // Create a MemberExpression that represents getting // the value of the 'species' field of class 'Animal'. System.Linq.Expressions.MemberExpression memberExpression = System.Linq.Expressions.Expression.Field( System.Linq.Expressions.Expression.Constant(horse), "species"); Console.WriteLine(memberExpression.ToString()); // This code produces the following output: // // value(CodeSnippets.FieldExample+Animal).species }
/// <summary> /// This member expression is an expression on a real domain object or is /// some other thing that are not related to nhibernate query. /// consider /// DateTime d = DateTime.New; /// /// where u.RegistrationDate = d /// </summary> /// <param name="m"></param> /// <returns></returns> private Boolean IsInvocationOnDomainObject(System.Linq.Expressions.MemberExpression m) { //return m.Member.ReflectedType.IsAssignableFrom(rootCriteria.CriteriaClass); //This is a property of base class if (m.Member.ReflectedType.IsAssignableFrom(rootCriteria.CriteriaClass)) { return(true); } //The previous element is a cast so we change type CastWalker t = Peek() as CastWalker; if (t != null && m.Member.ReflectedType.IsAssignableFrom(t.CastTo)) { return(true); } return(false); }
} // End Function GetNamespaces static AccessorCache() { try { s_GetNamespaces = null; System.Linq.Expressions.ParameterExpression p = System.Linq.Expressions.Expression.Parameter(typeof(T)); System.Linq.Expressions.MemberExpression prop = System.Linq.Expressions.Expression.Property(p, "Namespaces"); System.Linq.Expressions.UnaryExpression con = System.Linq.Expressions.Expression.Convert(prop, typeof(System.Xml.Serialization.XmlSerializerNamespaces)); System.Linq.Expressions.LambdaExpression exp = System.Linq.Expressions.Expression.Lambda(con, p); s_GetNamespaces = (System.Func <T, System.Xml.Serialization.XmlSerializerNamespaces>)exp.Compile(); } catch (System.Exception ex) { System.Console.WriteLine(ex.Message); System.Console.WriteLine(ex.StackTrace); } } // End Static constructor
/// <summary>Visits an <see cref="EntityExtensions.Predicate" /> method call.</summary> /// <param name="expression">Expression to be visited.</param> /// <returns>Returns visited expression.</returns> protected virtual System.Linq.Expressions.Expression VisitPredicateMethodCall(System.Linq.Expressions.MethodCallExpression expression) { object objectValue = ((System.Linq.Expressions.ConstantExpression)expression.Arguments[1]).Value; if (objectValue is Uri) { Uri predicate = (Uri)objectValue; if (!predicate.IsAbsoluteUri) { predicate = new Uri(_entityContext.BaseUriSelector.SelectBaseUri(new EntityId(predicate)), predicate.ToString()); } Visit(expression.Arguments[0]); StrongEntityAccessor entityAccessor = null; Remotion.Linq.Clauses.FromClauseBase sourceExpression = null; if (expression.Arguments[0] is System.Linq.Expressions.MemberExpression) { System.Linq.Expressions.MemberExpression memberExpression = (System.Linq.Expressions.MemberExpression)expression.Arguments[0]; if (memberExpression.Member is PropertyInfo) { PropertyInfo propertyInfo = (PropertyInfo)memberExpression.Member; sourceExpression = new AdditionalFromClause(propertyInfo.Name, propertyInfo.PropertyType, memberExpression); _query.AddEntityAccessor(entityAccessor = this.GetEntityAccessor(sourceExpression)); } else { return(base.VisitMethodCall(expression)); } } else { entityAccessor = this.GetEntityAccessor(GetSourceExpression(expression.Arguments[0])); } if (entityAccessor != null) { return(VisitPredicateMethodCallInternal(expression, predicate, entityAccessor)); } return(expression); } else { return(base.VisitMethodCall(expression)); } }
private Remotion.Linq.Clauses.FromClauseBase GetSourceExpression(System.Linq.Expressions.Expression expression) { Remotion.Linq.Clauses.FromClauseBase result = null; System.Linq.Expressions.Expression currentExpression = expression; bool isChange = false; while (currentExpression != null) { if (currentExpression is System.Linq.Expressions.MemberExpression) { System.Linq.Expressions.MemberExpression memberExpression = (System.Linq.Expressions.MemberExpression)currentExpression; if (!(memberExpression.Member is PropertyInfo)) { throw CreateUnhandledItemException <System.Linq.Expressions.MemberExpression>(memberExpression, "GetSourceExpression"); } currentExpression = memberExpression.Expression; isChange = true; } else if (currentExpression is Remotion.Linq.Clauses.Expressions.QuerySourceReferenceExpression) { result = (Remotion.Linq.Clauses.FromClauseBase)((Remotion.Linq.Clauses.Expressions.QuerySourceReferenceExpression)currentExpression).ReferencedQuerySource; if (!typeof(IQueryable).IsAssignableFrom(result.FromExpression.Type)) { Stack <IQueryComponentNavigator> currentComponent = _currentComponent; _currentComponent = new Stack <IQueryComponentNavigator>(); Visit(result.FromExpression); _currentComponent = currentComponent; isChange = true; } break; } if (isChange) { isChange = false; } else { break; } } return(result); }
protected override System.Linq.Expressions.Expression VisitMemberAccess(System.Linq.Expressions.MemberExpression m) { if (m.Expression is System.Linq.Expressions.ParameterExpression) { string text = string.Empty; MemberInfo memberInfo = m.Member; if (memberInfo != null) { this._CurrentMemberInfo = memberInfo; this._CurrentMemberType = m.Type; Type valueType = memberInfo.ReflectedType; DMSTableKeys key = this.TableKeys.Where(q => q.AssemblyQualifiedName == valueType.AssemblyQualifiedName).LastOrDefault(); if (key != null && (this.ExcuteType == DMSExcuteType.SELECT || this.ExcuteType == DMSExcuteType.UPDATE_WHERE || this.ExcuteType == DMSExcuteType.INSERT_SELECT)) { text = key.TableSpecialName; if (this.SplitExpression.TableMapping.TokenFlag == true) { text = this.Provider.BuildColumnName(text); } this._strSql.Append(text); this._strSql.Append(this.Provider.TableToken); } text = GetMemberInfoName(memberInfo.Name); if (this.SplitExpression.TableMapping.TokenFlag == true) { text = this.Provider.BuildColumnName(text); } _strSql.Append(text); } return(m); } else if (m.Expression is System.Linq.Expressions.MemberExpression) { //q.UserName.Length string name = m.Member.Name; if (MemberProperties.ContainsKey(name)) { this.MethodFunc(MemberProperties[name], m.Expression); } return(m); } return(base.VisitMemberAccess(m)); }
public static System.Linq.IOrderedQueryable <TSource> OrderByDescending <TSource> (this System.Collections.Generic.IEnumerable <TSource> query, string propertyName) { var entityType = typeof(TSource); //Create x => x.PropName var propertyInfo = entityType.GetProperty(propertyName); System.Linq.Expressions.ParameterExpression arg = System.Linq.Expressions.Expression.Parameter(entityType, "x"); System.Linq.Expressions.MemberExpression property = System.Linq.Expressions.Expression.Property(arg, propertyName); var selector = System.Linq.Expressions.Expression.Lambda (property, new System.Linq.Expressions.ParameterExpression[] { arg }); //Get System.Linq.Queryable.OrderBy() method. var enumarableType = typeof(System.Linq.Queryable); var method = enumarableType.GetMethods() .Where(m => m.Name == "OrderByDescending" && m.IsGenericMethodDefinition) .Where(m => { var parameters = m.GetParameters().ToList(); //Put more restriction here to ensure selecting the right overload return(parameters.Count == 2); //overload that has 2 parameters }).Single(); //The linq's OrderBy<TSource, TKey> has two generic types, which provided here System.Reflection.MethodInfo genericMethod = method.MakeGenericMethod(entityType, propertyInfo.PropertyType); //Call query.OrderBy(selector), with query and selector: x=> x.PropName //Note that we pass the selector as Expression to the method and we don't compile it. //By doing so EF can extract "order by" columns and generate SQL for it.*/ var newQuery = (IOrderedQueryable <TSource>) genericMethod.Invoke(genericMethod, new object[] { query, selector }); return(newQuery); }
// MemberExpression #if LINQ private Result RewriteMemberExpression(Expression expr, Stack stack) { MemberExpression node = (MemberExpression)expr; // Expression is emitted on top of the stack in current state Result expression = RewriteExpression(node.Expression, stack); if (expression.Action != RewriteAction.None) { if (expression.Action == RewriteAction.SpillStack && node.Member is PropertyInfo) { // Only need to validate propreties because reading a field // is always side-effect free. RequireNotRefInstance(node.Expression); } expr = MemberExpressionStubs.Make(expression.Node, node.Member); } return(new Result(expression.Action, expr)); }
private System.Linq.Expressions.Expression VisitPredicateMethodCallInternal(System.Linq.Expressions.MethodCallExpression expression, Uri predicate, StrongEntityAccessor entityAccessor) { Type type = null; string name = null; if (predicate == Rdf.subject) { name = "Id"; type = typeof(IEntity); } else { IEntityMapping entityMapping = _entityContext.Mappings.MappingFor(expression.Arguments[0].Type); if (entityMapping == null) { return(VisitPredicateMethodCallUnsafe(expression, predicate, entityAccessor)); } IPropertyMapping propertyMapping = entityMapping.Properties.FirstOrDefault(item => item.Uri.AbsoluteUri == predicate.AbsoluteUri); if (propertyMapping == null) { ExceptionHelper.ThrowMappingException(predicate); } if (propertyMapping.DeclaringType != expression.Arguments[0].Type) { propertyMapping = _entityContext.Mappings.MappingFor(propertyMapping.DeclaringType).Properties.FirstOrDefault(item => item.Uri.AbsoluteUri == predicate.AbsoluteUri); if (propertyMapping == null) { ExceptionHelper.ThrowMappingException(predicate); } } type = propertyMapping.EntityMapping.EntityType; name = propertyMapping.Name; } System.Linq.Expressions.MemberExpression propertyExpression = System.Linq.Expressions.Expression.Property(expression.Arguments[0], type, name); return(VisitMember(propertyExpression)); }
// public static System.Func<T, object> GetGetter<T>(string fieldName) public static Getter_t <T> GetGetter <T>(string fieldName) { System.Linq.Expressions.ParameterExpression p = System.Linq.Expressions.Expression.Parameter(typeof(T)); System.Linq.Expressions.MemberExpression prop = System.Linq.Expressions.Expression.PropertyOrField(p, fieldName); System.Linq.Expressions.UnaryExpression con = System.Linq.Expressions.Expression.Convert(prop, typeof(object)); System.Linq.Expressions.Expression <Getter_t <T> > exp = System.Linq.Expressions.Expression.Lambda <Getter_t <T> >(con, p); return(exp.Compile()); //System.Linq.Expressions.LambdaExpression exp = System.Linq.Expressions.Expression.Lambda(con, p); //// Getter_t<T> getter = (Getter_t<T>)exp.Compile(); //System.Func<T, object> getter = (System.Func<T, object>)exp.Compile(); //// Getter_t<T> getter2 = (Getter_t<T>)(arg1 => getter(arg1)); //Getter_t<T> getter2 = (Getter_t<T>)delegate (T arg1) //{ // return getter(arg1); //}; // return getter; // return getter2; } // End Function GetGetter