// 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
