protected override MemberAssignment VisitMemberAssignment(MemberAssignment node)
{
return(GiveUp(node));
}
protected virtual bool CompareMemberAssignment(MemberAssignment a, MemberAssignment b)
{
return(a.Member == b.Member &&
this.Compare(a.Expression, b.Expression));
}
/// <summary>
/// Visits a MemberAssignment.
/// </summary>
/// <param name="node">The MemberAssignment.</param>
/// <returns>The MemberAssignment.</returns>
protected override MemberAssignment VisitMemberAssignment(MemberAssignment node)
{
_sb.Append("<MemberAssignment>");
return(node);
}
// {new App() {Id = p.Id}}
private Expression VisitMemberInitImpl(MemberInitExpression node, bool topBinding)
{
// 如果有一对多的导航属性会产生嵌套的SQL，这时需要强制主表选择的列里面必须包含导航外键
// TODO #对 Bindings 进行排序，保证导航属性的赋值一定要最后面#
// 未实现，在书写表达式时人工保证 ##
if (node.NewExpression != null)
{
this.VisitNewImpl(node.NewExpression);
}
if (_navChainHopper.Count == 0)
{
_navChainHopper.Add(node.Type.Name);
}
for (int i = 0; i < node.Bindings.Count; i++)
{
MemberAssignment binding = node.Bindings[i] as MemberAssignment;
if (binding == null)
{
throw new XFrameworkException("Only 'MemberAssignment' binding supported.");
}
Type propertyType = (node.Bindings[i].Member as System.Reflection.PropertyInfo).PropertyType;
bool isNavigation = !TypeUtils.IsPrimitiveType(propertyType);
#region 一般属性
// 非导航属性
if (!isNavigation)
{
if (binding.Expression.CanEvaluate())
{
_builder.Append(binding.Expression.Evaluate().Value, binding.Member, node.Type);
}
else
{
base.VisitMemberBinding(binding);
}
// 选择字段
string newName = AddColumn(_columns, binding.Member.Name);
// 添加字段别名
_builder.AppendAs(newName);
_builder.Append(',');
_builder.AppendNewLine();
}
#endregion
#region 导航属性
else
{
// 非显式指定的导航属性需要有 ForeignKeyAttribute
if (binding.Expression.NodeType == ExpressionType.MemberAccess && binding.Expression.Acceptable())
{
TypeRuntimeInfo typeRuntime = TypeRuntimeInfoCache.GetRuntimeInfo(binding.Member.DeclaringType);
var attribute = typeRuntime.GetInvokerAttribute <ForeignKeyAttribute>(binding.Member.Name);
if (attribute == null)
{
throw new XFrameworkException("Complex property {{{0}}} must mark 'ForeignKeyAttribute' ", binding.Member.Name);
}
}
// 生成导航属性描述集合，以类名.属性名做为键值
int n = _navChainHopper.Count;
string keyName = _navChainHopper.Count > 0 ? _navChainHopper[_navChainHopper.Count - 1] : string.Empty;
keyName = !string.IsNullOrEmpty(keyName) ? keyName + "." + binding.Member.Name : binding.Member.Name;
Navigation descriptor = new Navigation(keyName, binding.Member);
if (!_navigations.ContainsKey(keyName))
{
// fix issue# XC 列占一个位
descriptor.Start = _columns.Count;
descriptor.FieldCount = GetFieldCount(binding.Expression) + (binding.Expression.NodeType == ExpressionType.MemberAccess && binding.Expression.Acceptable() ? 1 : 0);
_navigations.Add(keyName, descriptor);
_navChainHopper.Add(keyName);
}
// 1.不显式指定导航属性，例：a.Client.ClientList
// 2.表达式里显式指定导航属性，例：b
if (binding.Expression.NodeType == ExpressionType.MemberAccess)
{
this.VisitNavigation(binding.Expression as MemberExpression, binding.Expression.Acceptable());
}
else if (binding.Expression.NodeType == ExpressionType.New)
{
this.VisitNewImpl(binding.Expression as NewExpression);
}
else if (binding.Expression.NodeType == ExpressionType.MemberInit)
{
this.VisitMemberInitImpl(binding.Expression as MemberInitExpression, false);
}
// 恢复访问链
// 在访问导航属性时可能是 Client.CloudServer，这时要恢复为 Client，以保证能访问 Client 的下一个导航属性
if (_navChainHopper.Count != n)
{
_navChainHopper.RemoveAt(_navChainHopper.Count - 1);
}
}
#endregion
base._visitedMember.Clear();
}
return(node);
}
protected MemberAssignment UpdateMemberAssignment(MemberAssignment assignment, MemberInfo member, Expression expression)
{
if (expression != assignment.Expression || member != assignment.Member)
{
return Expression.Bind(member, expression);
}
return assignment;
}
protected override MemberAssignment VisitMemberAssignment(MemberAssignment node)
{
var expression = context.Rewrite(node.Expression, new Converter <Expression, Expression>(Visit));
return(ReferenceEquals(expression, node.Expression) ? node : node.Update(expression));
}
public void UpdateSameReturnsSame()
{
MemberAssignment bind = Expression.Bind(typeof(PropertyAndFields).GetProperty("StringProperty"), Expression.Constant("Hello Property"));
Assert.Same(bind, bind.Update(bind.Expression));
}
internal MemberAssignmentRewriter(MemberAssignment binding, StackSpiller spiller, Stack stack) :
base(binding, spiller)
{
Result result = spiller.RewriteExpression(binding.Expression, stack);
_action = result.Action;
_rhs = result.Node;
}
protected override MemberAssignment VisitMemberAssignment(MemberAssignment node) => base.VisitMemberAssignment(node);
public void UpdateDifferentReturnsDifferent()
{
MemberAssignment bind = Expression.Bind(typeof(PropertyAndFields).GetProperty("StringProperty"), Expression.Constant("Hello Property"));
Assert.NotSame(bind, Expression.Default(typeof(string)));
}
private void Update(MemberInitExpression expression, ExpressionParameter parameter)
{
int i = 0;
foreach (MemberBinding binding in expression.Bindings)
{
++i;
if (binding.BindingType != MemberBindingType.Assignment)
{
throw new NotSupportedException();
}
MemberAssignment memberAssignment = (MemberAssignment)binding;
var type = expression.Type;
var memberName = this.Context.GetDbColumnName(type.Name, memberAssignment.Member.Name);
var item = memberAssignment.Expression;
if ((item is MemberExpression) && ((MemberExpression)item).Expression == null)
{
var paramterValue = ExpressionTool.DynamicInvoke(item);
string parameterName = AppendParameter(paramterValue);
this.Context.Result.Append(base.Context.GetEqString(memberName, parameterName));
}
else if (IsMethod(item))
{
if (item is UnaryExpression)
{
item = (item as UnaryExpression).Operand;
}
var callMethod = item as MethodCallExpression;
if (MethodTimeMapping.Any(it => it.Key == callMethod.Method.Name) || MethodMapping.Any(it => it.Key == callMethod.Method.Name) || IsExtMethod(callMethod.Method.Name) || IsSubMethod(callMethod) || callMethod.Method.DeclaringType.FullName.StartsWith(UtilConstants.AssemblyName + UtilConstants.Dot))
{
MethodCall(parameter, memberName, item);
}
else
{
var paramterValue = ExpressionTool.DynamicInvoke(item);
string parameterName = AppendParameter(paramterValue);
this.Context.Result.Append(base.Context.GetEqString(memberName, parameterName));
}
}
else if (IsConst(item))
{
base.Expression = item;
base.Start();
string parameterName = this.Context.SqlParameterKeyWord + ExpressionConst.Const + this.Context.ParameterIndex;
parameter.Context.Result.Append(base.Context.GetEqString(memberName, parameterName));
this.Context.Parameters.Add(new SugarParameter(parameterName, parameter.CommonTempData));
this.Context.ParameterIndex++;
}
else if (item is MemberExpression)
{
if (base.Context.Result.IsLockCurrentParameter == false)
{
base.Context.Result.CurrentParameter = parameter;
base.Context.Result.IsLockCurrentParameter = true;
parameter.IsAppendTempDate();
base.Expression = item;
base.Start();
parameter.IsAppendResult();
parameter.Context.Result.Append(base.Context.GetEqString(memberName, parameter.CommonTempData.ObjToString()));
base.Context.Result.CurrentParameter = null;
}
}
else if (item is BinaryExpression)
{
var result = GetNewExpressionValue(item);
this.Context.Result.Append(base.Context.GetEqString(memberName, result));
}
else if (item is MemberInitExpression)
{
try
{
var value = ExpressionTool.DynamicInvoke(item);
var parameterName = AppendParameter(value);
parameter.Context.Result.Append(base.Context.GetEqString(memberName, parameterName));
}
catch (Exception ex)
{
throw new NotSupportedException("Not Supported " + item.ToString() + " " + ex.Message);
}
}
else if (item is NewExpression)
{
try
{
var value = ExpressionTool.DynamicInvoke(item);
var parameterName = AppendParameter(value);
parameter.Context.Result.Append(base.Context.GetEqString(memberName, parameterName));
}
catch (Exception ex)
{
throw new NotSupportedException("Not Supported " + item.ToString() + " " + ex.Message);
}
}
}
}
protected virtual bool CompareMemberAssignment(MemberAssignment a, MemberAssignment b)
{
return a.Member == b.Member
&& this.Compare(a.Expression, b.Expression);
}
protected virtual MemberAssignment VisitMemberAssignment(MemberAssignment assignment)
{
Expression e = this.Visit(assignment.Expression);
return this.UpdateMemberAssignment(assignment, assignment.Member, e);
}
protected override MemberAssignment VisitMemberAssignment(MemberAssignment node)
{
return(null);
}
public void MemberBindingTypeAssignment()
{
MemberAssignment bind = Expression.Bind(typeof(PropertyAndFields).GetProperty("StringProperty"), Expression.Constant("Hello Property"));
Assert.Equal(MemberBindingType.Assignment, bind.BindingType);
}
/// <summary>
/// Visits the children of the <see cref="MemberAssignment" />.
/// </summary>
/// <param name="node">The expression to visit.</param>
/// <returns>The modified expression, if it or any subexpression was modified;
/// otherwise, returns the original expression.</returns>
protected virtual MemberAssignment VisitMemberAssignment(MemberAssignment node)
{
return(node.Update(Visit(node.Expression)));
}
private static void BuildBranches(Expression expression, PropertyAccessTree tree, Stack <PropertyAccessTreeNode> currentNodeBranch, Predicate <Type> typeFilter)
{
BinaryExpression binaryExpression = expression as BinaryExpression;
if (binaryExpression != null)
{
BuildBranches(binaryExpression.Left, tree, currentNodeBranch, typeFilter);
BuildBranches(binaryExpression.Right, tree, currentNodeBranch, typeFilter);
return;
}
UnaryExpression unaryExpression = expression as UnaryExpression;
if (unaryExpression != null)
{
BuildBranches(unaryExpression.Operand, tree, currentNodeBranch, typeFilter);
return;
}
MethodCallExpression methodCallExpression = expression as MethodCallExpression;
if (methodCallExpression != null)
{
foreach (Expression argument in methodCallExpression.Arguments)
{
BuildBranches(argument, tree, currentNodeBranch, typeFilter);
}
return;
}
ConditionalExpression conditionalExpression = expression as ConditionalExpression;
if (conditionalExpression != null)
{
BuildBranches(conditionalExpression.Test, tree, currentNodeBranch, typeFilter);
BuildBranches(conditionalExpression.IfTrue, tree, currentNodeBranch, typeFilter);
BuildBranches(conditionalExpression.IfFalse, tree, currentNodeBranch, typeFilter);
return;
}
InvocationExpression invocationExpression = expression as InvocationExpression;
if (invocationExpression != null)
{
foreach (Expression argument in invocationExpression.Arguments)
{
BuildBranches(argument, tree, currentNodeBranch, typeFilter);
}
BuildBranches(invocationExpression.Expression, tree, currentNodeBranch, typeFilter);
return;
}
switch (expression.NodeType)
{
case ExpressionType.MemberAccess:
MemberExpression memberExpression = (MemberExpression)expression;
PropertyInfo property = memberExpression.Member as PropertyInfo;
FieldInfo fieldInfo = memberExpression.Member as FieldInfo;
if (property != null)
{
PropertyAccessNode node = new PropertyAccessNode(property);
currentNodeBranch.Push(node);
BuildBranches(memberExpression.Expression, tree, currentNodeBranch, typeFilter);
}
else if (fieldInfo != null)
{
if (typeFilter(fieldInfo.FieldType))
{
ConstantExpression constantExpression = (ConstantExpression)memberExpression.Expression;
if (constantExpression.Value != null)
{
object value = fieldInfo.GetValue(constantExpression.Value);
ConstantNode constantNode = new ConstantNode((INotifyPropertyChanged)value);
currentNodeBranch.Push(constantNode);
AddBranch(tree, currentNodeBranch);
}
}
else
{
currentNodeBranch.Clear();
}
}
else
{
BuildBranches(memberExpression.Expression, tree, currentNodeBranch, typeFilter);
}
break;
case ExpressionType.Parameter:
ParameterExpression parameterExpression = (ParameterExpression)expression;
ParameterNode parameterNode = new ParameterNode(expression.Type, parameterExpression.Name);
currentNodeBranch.Push(parameterNode);
AddBranch(tree, currentNodeBranch);
break;
case ExpressionType.Constant:
{
ConstantExpression constantExpression = (ConstantExpression)expression;
if (typeFilter(constantExpression.Type) &&
constantExpression.Value != null)
{
ConstantNode constantNode = new ConstantNode((INotifyPropertyChanged)constantExpression.Value);
currentNodeBranch.Push(constantNode);
AddBranch(tree, currentNodeBranch);
}
else
{
currentNodeBranch.Clear();
}
}
break;
case ExpressionType.New:
{
NewExpression newExpression = (NewExpression)expression;
foreach (Expression argument in newExpression.Arguments)
{
BuildBranches(argument, tree, currentNodeBranch, typeFilter);
}
}
break;
case ExpressionType.MemberInit:
{
MemberInitExpression memberInitExpression = (MemberInitExpression)expression;
BuildBranches(memberInitExpression.NewExpression, tree, currentNodeBranch, typeFilter);
foreach (var memberBinding in memberInitExpression.Bindings)
{
MemberAssignment assignment = memberBinding as MemberAssignment;
if (assignment != null)
{
BuildBranches(assignment.Expression, tree, currentNodeBranch, typeFilter);
}
}
}
break;
default:
throw new InvalidProgramException(string.Format("CLINQ does not support expressions of type: {0}", expression.NodeType));
}
}
protected internal virtual void PostWalk(MemberAssignment node) { }
protected override MemberAssignment VisitMemberAssignment(MemberAssignment node)
{
Trace(MethodInfo.GetCurrentMethod(), node);
return(base.VisitMemberAssignment(node));
}
protected override MemberBinding VisitMemberAssignment(MemberAssignment memberAssigment)
{
return(base.VisitMemberAssignment(memberAssigment));
}
protected override MemberAssignment VisitMemberAssignment(MemberAssignment assignment)
{
return(base.VisitMemberAssignment(assignment));
}
protected override MemberAssignment VisitMemberAssignment(MemberAssignment node)
{
Console.WriteLine($"VisitMemberAssignment");
return(base.VisitMemberAssignment(node));
}
/// <summary>
/// Visits the children of <see cref="System.Linq.Expressions.MemberAssignment"/>.
/// </summary>
/// <param name="node">The expression to visit.</param>
/// <returns>The modified expression, if it or any subexpression was modified; otherwise,
/// returns the original expression.</returns>
protected override MemberAssignment VisitMemberAssignment(MemberAssignment node)
{
throw new NotSupportedException(string.Format(Resources.EX_PROCESS_NODE_NOT_SUPPORT, node.GetType().Name));
}
private object GenerateXmlFromAssignment(MemberAssignment memberAssignment)
{
return(new XElement("MemberAssignment",
GenerateXmlFromProperty(memberAssignment.Member.GetType(), "Member", memberAssignment.Member),
GenerateXmlFromProperty(memberAssignment.Expression.GetType(), "Expression", memberAssignment.Expression)));
}
protected override MemberAssignment VisitMemberAssignment(MemberAssignment node)
{
throw new ExpressionParseException(0, $"Member assignments not supported in binding expressions.");
}
protected override MemberBinding VisitMemberAssignment(MemberAssignment memberAssigment)
{
CheckAndVisitMemberAssignment(memberAssigment.Member, memberAssigment.Expression);
return(memberAssigment);
}
protected virtual void VisitMemberAssignment(MemberAssignment assignment)
{
Visit(assignment.Expression);
}
private bool CompareMemberAssignment(MemberAssignment a, MemberAssignment b) => Equals(a.Member, b.Member) && Compare(a.Expression, b.Expression);
protected override MemberAssignment VisitMemberAssignment(MemberAssignment node)
{
throw new NotImplementedException();
}
protected virtual MemberAssignment VisitMemberAssignment(MemberAssignment assignment)
{
Expression e = this.Visit(assignment.Expression);
return(this.UpdateMemberAssignment(assignment, assignment.Member, e));
}
public static RecordsAndFields VisitMemberAssignment(this Func <Expression, RecordsAndFields> self, MemberAssignment assignment)
{
return(self(assignment.Expression));
}
/// <summary>
/// MemberAssignment visit method
/// </summary>
/// <param name="assignment">The MemberAssignment to visit</param>
/// <returns>The visited MemberAssignmentt</returns>
internal virtual MemberAssignment VisitMemberAssignment(MemberAssignment assignment)
{
Expression e = this.Visit(assignment.Expression);
return(e != assignment.Expression ? Expression.Bind(assignment.Member, e) : assignment);
}
private bool EqualsMemberAssignment(MemberAssignment x, MemberAssignment y)
{
return(this.Equals(x.Expression, y.Expression));
}
MemberAssignment ParseMemberAssignment(MemberAccess variable, string op)
{
// assignment:
// {variable} += {value}
ReadNextToken(); // skip '+='
MemberAssignment a = null;
if (op == "++" || op == "--")
a = new MemberAssignment(variable, op, null);
else
a = new MemberAssignment(variable, op, ParseExpression());
return a;
}
protected virtual MemberAssignment VisitMemberAssignment(MemberAssignment assignment)
{
var e = Visit(assignment.Expression);
return(e != assignment.Expression ? Expression.Bind(assignment.Member, e) : assignment);
}
// MemberAssignment
protected internal virtual bool Walk(MemberAssignment node) { return true; }
protected override MemberAssignment VisitMemberAssignment(MemberAssignment expression)
{
this.hashCode ^= expression.BindingType.GetHashCode();
this.hashCode ^= expression.Member?.GetHashCode() ?? 0;
return(base.VisitMemberAssignment(expression));
}
private void EmitMemberAssignment(MemberAssignment binding, Type objectType)
{
EmitExpression(binding.Expression);
FieldInfo fi = binding.Member as FieldInfo;
if (fi != null)
{
_ilg.Emit(OpCodes.Stfld, fi);
}
else
{
PropertyInfo pi = binding.Member as PropertyInfo;
if (pi != null)
{
EmitCall(objectType, pi.GetSetMethod(true));
}
else
{
throw Error.UnhandledBinding();
}
}
}
protected override MemberAssignment VisitMemberAssignment(MemberAssignment assignment)
{
Accumulate(assignment.Member);
return base.VisitMemberAssignment(assignment);
}
