private void ResolvefieldIsBool(ExpressionParameter parameter, ExpressionParameter baseParameter, bool?isLeft, bool isSetTempData, MemberExpression expression, bool isSingle)
{
var fieldName = GetName(parameter, expression, isLeft, isSingle);
if (isSetTempData)
{
baseParameter.CommonTempData = fieldName;
}
else
{
fieldName = this.Context.DbMehtods.EqualTrue(fieldName.ObjToString());
AppendMember(parameter, isLeft, fieldName);
}
}
private void Select(MemberInitExpression expression, ExpressionParameter parameter, bool isSingle)
{
foreach (MemberBinding binding in expression.Bindings)
{
if (binding.BindingType != MemberBindingType.Assignment)
{
throw new NotSupportedException();
}
MemberAssignment memberAssignment = (MemberAssignment)binding;
var memberName = memberAssignment.Member.Name;
var item = memberAssignment.Expression;
ResolveNewExpressions(parameter, item, memberName);
}
}
private MemberExpression ResolveValue(ExpressionParameter parameter, ExpressionParameter baseParameter, MemberExpression expression, bool?isLeft, bool isSetTempData, bool isSingle)
{
expression = expression.Expression as MemberExpression;
baseParameter.ChildExpression = expression;
if (UtilMethods.GetUnderType(expression.Type) == UtilConstants.BoolType && parameter.BaseExpression != null && ExpressionTool.IsLogicOperator(parameter.BaseExpression))
{
ResolveBoolLogic(parameter, baseParameter, expression, isLeft, isSetTempData, isSingle);
}
else
{
ResolveWhereLogic(parameter, baseParameter, expression, isLeft, isSetTempData, isSingle);
}
return(expression);
}
private void Append(ExpressionParameter parameter, ExpressionType nodeType)
{
BaseParameter.ChildExpression = base.Expression;
this.IsLeft = parameter.IsLeft;
parameter.CommonTempData = CommonTempDataType.Append;
if (nodeType == ExpressionType.Not)
{
AppendNot(parameter.CommonTempData);
}
base.Start();
parameter.BaseParameter.CommonTempData = parameter.CommonTempData;
parameter.BaseParameter.ChildExpression = base.Expression;
parameter.CommonTempData = null;
}
private void Where(ExpressionParameter parameter, bool?isLeft, string name, IEnumerable <Expression> args, MethodCallExpressionModel model, List <MethodCallExpressionArgs> appendArgs = null)
{
foreach (var item in args)
{
AppendItem(parameter, name, args, model, item);
}
if (appendArgs != null)
{
model.Args.AddRange(appendArgs);
}
var methodValue = GetMdthodValue(name, model);
base.AppendValue(parameter, isLeft, methodValue);
}
public MethodCallExpressionResolve(ExpressionParameter parameter) : base(parameter)
{
var express = base.Expression as MethodCallExpression;
var isLeft = parameter.IsLeft;
string methodName = express.Method.Name;
var isValidNativeMethod = MethodMapping.ContainsKey(methodName) && express.Method.DeclaringType.Namespace == ("System");
List <MethodCallExpressionArgs> appendArgs = null;
if (MethodTimeMapping.ContainsKey(methodName))
{
appendArgs = new List <MethodCallExpressionArgs>();
var dateType = MethodTimeMapping[methodName];
string paramterName = this.Context.SqlParameterKeyWord + ExpressionConst.Const + this.Context.ParameterIndex;
appendArgs.Add(new MethodCallExpressionArgs()
{
IsMember = false, MemberName = paramterName, MemberValue = dateType
});
this.Context.Parameters.Add(new SugarParameter(paramterName, dateType.ToString()));
this.Context.ParameterIndex++;
methodName = "DateAdd";
isValidNativeMethod = true;
}
else if (methodName == "get_Item")
{
string paramterName = this.Context.SqlParameterKeyWord + ExpressionConst.Const + this.Context.ParameterIndex;
this.Context.Parameters.Add(new SugarParameter(paramterName, ExpressionTool.DynamicInvoke(express)));
this.Context.Result.Append(string.Format(" {0} ", paramterName));
this.Context.ParameterIndex++;
return;
}
else if (methodName == "NewGuid")
{
this.Context.Result.Append(this.Context.DbMehtods.GuidNew());
return;
}
if (!isValidNativeMethod && express.Method.DeclaringType.Namespace.IsIn("System.Linq", "System.Collections.Generic") && methodName == "Contains")
{
methodName = "ContainsArray";
isValidNativeMethod = true;
}
if (isValidNativeMethod)
{
NativeExtensionMethod(parameter, express, isLeft, MethodMapping[methodName], appendArgs);
}
else
{
SqlFuncMethod(parameter, express, isLeft);
}
}
public BinaryExpressionResolve(ExpressionParameter parameter) : base(parameter)
{
switch (parameter.Context.ResolveType)
{
case ResolveExpressType.FieldSingle:
case ResolveExpressType.FieldMultiple:
var sql = base.GetNewExpressionValue(this.Expression);
this.Context.Result.Append(sql);
break;
default:
Other(parameter);
break;
}
}
protected void AppendMember(ExpressionParameter parameter, bool?isLeft, object appendValue)
{
Context.ParameterIndex++;
if (isLeft == true)
{
appendValue += ExpressionConst.ExpressionReplace + parameter.BaseParameter.Index;
}
if (this.Context.Result.Contains(ExpressionConst.FormatSymbol))
{
this.Context.Result.Replace(ExpressionConst.FormatSymbol, appendValue.ObjToString());
}
else
{
this.Context.Result.Append(appendValue);
}
}
private void AppendItem(ExpressionParameter parameter, string name, IEnumerable <Expression> args, MethodCallExpressionModel model, Expression item)
{
var isBinaryExpression = item is BinaryExpression || item is MethodCallExpression;
var isConst = item is ConstantExpression;
var isIIF = name == "IIF";
var isIFFBoolMember = isIIF && (item is MemberExpression) && (item as MemberExpression).Type == UtilConstants.BoolType;
var isIFFUnary = isIIF && (item is UnaryExpression) && (item as UnaryExpression).Operand.Type == UtilConstants.BoolType;
var isIFFBoolBinary = isIIF && (item is BinaryExpression) && (item as BinaryExpression).Type == UtilConstants.BoolType;
var isIFFBoolMethod = isIIF && (item is MethodCallExpression) && (item as MethodCallExpression).Type == UtilConstants.BoolType;
var isFirst = item == args.First();
if (isFirst && isIIF && isConst)
{
var value = (item as ConstantExpression).Value.ObjToBool() ? this.Context.DbMehtods.True() : this.Context.DbMehtods.False();
var methodCallExpressionArgs = new MethodCallExpressionArgs()
{
IsMember = true,
MemberName = value,
MemberValue = value
};
model.Args.Add(methodCallExpressionArgs);
}
else if (isIFFUnary && !isFirst)
{
AppendModelByIIFMember(parameter, model, (item as UnaryExpression).Operand);
}
else if (isIFFBoolMember && !isFirst)
{
AppendModelByIIFMember(parameter, model, item);
}
else if (isIFFBoolBinary && !isFirst)
{
AppendModelByIIFBinary(parameter, model, item);
}
else if (isIFFBoolMethod && !isFirst)
{
AppendModelByIIFMethod(parameter, model, item);
}
else if (isBinaryExpression)
{
model.Args.Add(GetMethodCallArgs(parameter, item));
}
else
{
AppendModel(parameter, model, item);
}
}
private void ResolveMemberValue(ExpressionParameter parameter, ExpressionParameter baseParameter, bool?isLeft, bool isSetTempData, MemberExpression expression)
{
var value = ExpressionTool.GetMemberValue(expression.Member, expression);
if (isSetTempData)
{
if (value is MapperSql)
{
value = (value as MapperSql).Sql;
}
baseParameter.CommonTempData = value;
}
else
{
AppendValue(parameter, isLeft, value);
}
}
public MemberExpressionResolve(ExpressionParameter parameter) : base(parameter)
{
ExpressionParameter baseParameter;
MemberExpression expression;
bool?isLeft;
bool isSetTempData, isValue, isValueBool, isLength, isDateValue, isHasValue, isDateDate, isMemberValue, isSingle, fieldIsBool, isSelectField, isField;
SettingParameters(parameter, out baseParameter, out expression, out isLeft, out isSetTempData, out isValue, out isValueBool, out isLength, out isDateValue, out isHasValue, out isDateDate, out isMemberValue, out isSingle, out fieldIsBool, out isSelectField, out isField);
baseParameter.ChildExpression = expression;
if (isLength)
{
ResolveLength(parameter, isLeft, expression);
}
else if (isHasValue)
{
ResolveHasValue(parameter, expression);
}
else if (isDateValue)
{
ResolveDateValue(parameter, isLeft, expression);
}
else if (isValueBool)
{
ResolveValueBool(parameter, baseParameter, expression, isLeft, isSingle);
}
else if (isValue)
{
ResolveValue(parameter, baseParameter, expression, isLeft, isSetTempData, isSingle);
}
else if (isDateDate)
{
ResolveDateDate(parameter, isLeft, expression);
}
else if (isMemberValue)
{
ResolveMemberValue(parameter, baseParameter, isLeft, isSetTempData, expression);
}
else if (fieldIsBool && !isField && !isSelectField)
{
ResolvefieldIsBool(parameter, baseParameter, isLeft, isSetTempData, expression, isSingle);
}
else
{
ResolveDefault(parameter, baseParameter, expression, isLeft, isSetTempData, isSingle);
}
}
public MemberNoExpressionResolve(ExpressionParameter parameter) : base(parameter)
{
var expression = base.Expression as MemberExpression;
var isLeft = parameter.IsLeft;
object value = null;
var isField = expression.Member is System.Reflection.FieldInfo;
var isProperty = expression.Member is System.Reflection.PropertyInfo;
var baseParameter = parameter.BaseParameter;
var isSetTempData = baseParameter.CommonTempData.HasValue() && baseParameter.CommonTempData.Equals(CommonTempDataType.Result);
if (isField)
{
value = ExpressionTool.GetFiledValue(expression);
}
else if (isProperty)
{
value = ExpressionTool.GetPropertyValue(expression);
}
switch (base.Context.ResolveType)
{
case ResolveExpressType.WhereSingle:
case ResolveExpressType.WhereMultiple:
case ResolveExpressType.SelectSingle:
case ResolveExpressType.SelectMultiple:
case ResolveExpressType.Update:
if (isSetTempData)
{
baseParameter.CommonTempData = value;
}
else
{
AppendValue(parameter, isLeft, value);
}
break;
case ResolveExpressType.FieldSingle:
break;
case ResolveExpressType.FieldMultiple:
break;
default:
break;
}
}
public UnaryExpressionResolve(ExpressionParameter parameter) : base(parameter)
{
var expression = base.Expression as UnaryExpression;
var baseParameter = parameter.BaseParameter;
switch (this.Context.ResolveType)
{
case ResolveExpressType.WhereSingle:
case ResolveExpressType.WhereMultiple:
case ResolveExpressType.FieldSingle:
case ResolveExpressType.FieldMultiple:
case ResolveExpressType.SelectSingle:
case ResolveExpressType.SelectMultiple:
case ResolveExpressType.Update:
var nodeType = expression.NodeType;
base.Expression = expression.Operand;
var isMember = expression.Operand is MemberExpression;
var isConst = expression.Operand is ConstantExpression;
if (baseParameter.CurrentExpression is NewArrayExpression)
{
Result(parameter, nodeType);
}
else if (base.Expression is BinaryExpression || parameter.BaseExpression is BinaryExpression || baseParameter.CommonTempData.ObjToString() == CommonTempDataType.Append.ToString())
{
Append(parameter, nodeType);
}
else if (isMember)
{
MemberLogic(parameter, baseParameter, nodeType);
}
else if (isConst)
{
Result(parameter, nodeType);
}
else
{
Append(parameter, nodeType);
}
break;
default:
break;
}
}
public NewExpressionResolve(ExpressionParameter parameter) : base(parameter)
{
var expression = base.Expression as NewExpression;
Check.Exception(expression.Type == UtilConstants.GuidType, "Not Support new Guid(), Use Guid.New()");
switch (parameter.Context.ResolveType)
{
case ResolveExpressType.WhereSingle:
Check.ThrowNotSupportedException(expression.ToString());
break;
case ResolveExpressType.WhereMultiple:
Check.ThrowNotSupportedException(expression.ToString());
break;
case ResolveExpressType.SelectSingle:
Check.Exception(expression.Type == UtilConstants.DateType, "ThrowNotSupportedException {0} ", expression.ToString());
Select(expression, parameter, true);
break;
case ResolveExpressType.SelectMultiple:
Check.Exception(expression.Type == UtilConstants.DateType, "ThrowNotSupportedException {0} ", expression.ToString());
Select(expression, parameter, false);
break;
case ResolveExpressType.FieldSingle:
Check.ThrowNotSupportedException(expression.ToString());
break;
case ResolveExpressType.FieldMultiple:
case ResolveExpressType.ArrayMultiple:
case ResolveExpressType.ArraySingle:
foreach (var item in expression.Arguments)
{
base.Expression = item;
base.Start();
}
break;
default:
break;
}
}
protected MethodCallExpressionArgs GetMethodCallArgs(ExpressionParameter parameter, Expression item)
{
var newContext = this.Context.GetCopyContext();
newContext.Resolve(item, this.Context.IsJoin ? ResolveExpressType.WhereMultiple : ResolveExpressType.WhereSingle);
this.Context.Index = newContext.Index;
this.Context.ParameterIndex = newContext.ParameterIndex;
if (newContext.Parameters.IsValuable())
{
this.Context.Parameters.AddRange(newContext.Parameters);
}
var methodCallExpressionArgs = new MethodCallExpressionArgs()
{
IsMember = true,
MemberName = newContext.Result.GetResultString()
};
return(methodCallExpressionArgs);
}
private void ResolveDateDiff(ExpressionParameter parameter, bool?isLeft, MemberExpression expression)
{
var binaryExp = expression.Expression as BinaryExpression;
var beginExp = binaryExp.Right;
var endExp = binaryExp.Left;
var dateType = DateType.Day;
var begin = GetNewExpressionValue(beginExp);
var end = GetNewExpressionValue(endExp);
foreach (var item in UtilMethods.EnumToDictionary <DateType>())
{
if (expression.Member.Name.ToLower().Contains(item.Key.ToLower()))
{
dateType = item.Value;
break;
}
}
var result = this.Context.DbMehtods.DateDiff(new MethodCallExpressionModel()
{
Args = new List <MethodCallExpressionArgs>()
{
new MethodCallExpressionArgs()
{
MemberName = dateType,
MemberValue = dateType
},
new MethodCallExpressionArgs()
{
MemberName = begin,
MemberValue = begin
},
new MethodCallExpressionArgs()
{
MemberName = end,
MemberValue = end
}
}
});;
base.AppendMember(parameter, isLeft, result);
}
private void ResolveDateDateByCall(ExpressionParameter parameter, bool?isLeft, MemberExpression expression)
{
var value = GetNewExpressionValue(expression.Expression);
if (expression.Member.Name == "Date")
{
AppendMember(parameter, isLeft, GetToDateShort(value));
}
else
{
foreach (int myCode in Enum.GetValues(typeof(DateType)))
{
string strName = Enum.GetName(typeof(DateType), myCode);//获取名称
if (expression.Member.Name == strName)
{
AppendMember(parameter, isLeft, this.Context.DbMehtods.MergeString(this.GetDateValue(value, (DateType)(myCode))));
}
}
}
}
private void ResolveHasValue(ExpressionParameter parameter, MemberExpression expression)
{
parameter.CommonTempData = CommonTempDataType.Result;
this.Expression = expression.Expression;
this.Start();
var methodParamter = new MethodCallExpressionArgs()
{
IsMember = true, MemberName = parameter.CommonTempData, MemberValue = null
};
var result = this.Context.DbMehtods.HasValue(new MethodCallExpressionModel()
{
Args = new List <MethodCallExpressionArgs>()
{
methodParamter
}
});
this.Context.Result.Append(result);
parameter.CommonTempData = null;
}
private void NewValueType(ExpressionParameter parameter, NewExpression expression)
{
try
{
var value = ExpressionTool.DynamicInvoke(expression);
var isSetTempData = parameter.CommonTempData.HasValue() && parameter.CommonTempData.Equals(CommonTempDataType.Result);
if (isSetTempData)
{
parameter.CommonTempData = value;
}
else
{
AppendValue(parameter, parameter.IsLeft, value);
}
}
catch (Exception ex)
{
Check.Exception(expression.Type == UtilConstants.DateType, "ThrowNotSupportedException {0} ", ex.ToString());
}
}
public TypeParameterExpressionReolve(ExpressionParameter parameter) : base(parameter)
{
var expression = (ParameterExpression)base.Expression;
switch (parameter.Context.ResolveType)
{
case ResolveExpressType.WhereSingle:
break;
case ResolveExpressType.WhereMultiple:
break;
case ResolveExpressType.Update:
parameter.BaseParameter.CommonTempData = expression.Name;
break;
case ResolveExpressType.SelectSingle:
case ResolveExpressType.SelectMultiple:
if (parameter.BaseParameter != null && parameter.BaseParameter.CurrentExpression.NodeType == ExpressionType.Lambda)
{
this.Context.Result.Append(expression.Name + ".*");
}
else
{
parameter.BaseParameter.CommonTempData = expression.Name;
}
break;
case ResolveExpressType.FieldSingle:
break;
case ResolveExpressType.FieldMultiple:
break;
case ResolveExpressType.Join:
break;
default:
break;
}
}
private void CusMethod(ExpressionParameter parameter, MethodCallExpression express, bool?isLeft)
{
try
{
var constValue = ExpressionTool.DynamicInvoke(express);
parameter.BaseParameter.CommonTempData = constValue;
var parameterName = base.AppendParameter(constValue);
if (parameter.BaseParameter.CommonTempData != null && parameter.BaseParameter.CommonTempData.Equals(CommonTempDataType.Result))
{
this.Context.Result.Append(parameterName);
}
else
{
base.AppendValue(parameter, isLeft, parameterName);
}
}
catch
{
Check.Exception(true, string.Format(ErrorMessage.MethodError, express.Method.Name));
}
}
private void ResolveDateDate(ExpressionParameter parameter, bool?isLeft, MemberExpression expression)
{
var name = expression.Member.Name;
var oldCommonTempDate = parameter.CommonTempData;
parameter.CommonTempData = CommonTempDataType.Result;
this.Expression = expression.Expression;
this.Start();
var isConst = parameter.CommonTempData.GetType() == UtilConstants.DateType;
if (isConst)
{
AppendValue(parameter, isLeft, parameter.CommonTempData.ObjToDate().Date);
}
else
{
var GetYear = new MethodCallExpressionModel()
{
Args = new List <MethodCallExpressionArgs>()
{
new MethodCallExpressionArgs()
{
IsMember = true, MemberName = parameter.CommonTempData, MemberValue = parameter.CommonTempData
},
new MethodCallExpressionArgs()
{
MemberName = DateType.Year, MemberValue = DateType.Year
}
}
};
AppendMember(parameter, isLeft, GetToDate(this.Context.DbMehtods.MergeString(
this.GetDateValue(parameter.CommonTempData, DateType.Year),
"'-'",
this.GetDateValue(parameter.CommonTempData, DateType.Month),
"'-'",
this.GetDateValue(parameter.CommonTempData, DateType.Day))));
}
parameter.CommonTempData = oldCommonTempDate;
}
private void Select(MemberInitExpression expression, ExpressionParameter parameter, bool isSingle)
{
foreach (MemberBinding binding in expression.Bindings)
{
if (binding.BindingType != MemberBindingType.Assignment)
{
throw new NotSupportedException();
}
MemberAssignment memberAssignment = (MemberAssignment)binding;
var memberName = memberAssignment.Member.Name;
var item = memberAssignment.Expression;
if (IsNullable(item) && item is UnaryExpression)
{
var memtype = ExpressionTool.GetMemberInfoType(memberAssignment.Member);
if (IsNullable(memtype) && UtilMethods.GetUnderType(memtype) == UtilMethods.GetUnderType(item.Type))
{
item = (item as UnaryExpression).Operand;
}
}
ResolveNewExpressions(parameter, item, memberName);
}
}
private void ResolveCallValue(ExpressionParameter parameter, ExpressionParameter baseParameter, MemberExpression expression, bool?isLeft, bool isSetTempData, bool isSingle)
{
try
{
baseParameter.ChildExpression = expression;
string fieldName = string.Empty;
if (isSetTempData)
{
var value = ExpressionTool.DynamicInvoke(expression);
baseParameter.CommonTempData = value;
}
else
{
var value = ExpressionTool.DynamicInvoke(expression);
base.AppendValue(parameter, isLeft, value);
}
}
catch
{
Check.Exception(true, "Not Support {0}", expression.ToString());
}
}
private void Where(ExpressionParameter parameter, bool?isLeft, string name, IEnumerable <Expression> args, MethodCallExpressionModel model, List <MethodCallExpressionArgs> appendArgs = null)
{
foreach (var item in args)
{
var isBinaryExpression = item is BinaryExpression || item is MethodCallExpression;
if (isBinaryExpression)
{
model.Args.Add(GetMethodCallArgs(parameter, item));
}
else
{
Default(parameter, model, item);
}
}
if (appendArgs != null)
{
model.Args.AddRange(appendArgs);
}
var methodValue = GetMdthodValue(name, model);
base.AppendValue(parameter, isLeft, methodValue);
}
private void ResolveDayOfWeek(ExpressionParameter parameter, bool?isLeft, MemberExpression expression)
{
var exp = expression.Expression;
var value = GetNewExpressionValue(exp);
var result = this.Context.DbMehtods.DateValue(new MethodCallExpressionModel()
{
Args = new List <MethodCallExpressionArgs>()
{
new MethodCallExpressionArgs()
{
MemberName = value,
MemberValue = value
},
new MethodCallExpressionArgs()
{
MemberName = DateType.Weekday,
MemberValue = DateType.Weekday
}
}
});;
base.AppendMember(parameter, isLeft, result);
}
private void Where(ExpressionParameter parameter, bool?isLeft, string name, IEnumerable <Expression> args, MethodCallExpressionModel model, List <MethodCallExpressionArgs> appendArgs = null)
{
foreach (var item in args)
{
AppendItem(parameter, name, args, model, item);
}
if (appendArgs != null)
{
model.Args.AddRange(appendArgs);
}
var methodValue = GetMdthodValue(name, model);
if (parameter.BaseExpression is BinaryExpression && parameter.OppsiteExpression.Type == UtilConstants.BoolType && name == "HasValue" && !(parameter.OppsiteExpression is BinaryExpression))
{
methodValue = this.Context.DbMehtods.CaseWhen(new List <KeyValuePair <string, string> >()
{
new KeyValuePair <string, string>("IF", methodValue.ObjToString()),
new KeyValuePair <string, string>("Return", "1"),
new KeyValuePair <string, string>("End", "0")
});
}
base.AppendValue(parameter, isLeft, methodValue);
}
protected MethodCallExpressionArgs GetMethodCallArgs(ExpressionParameter parameter, Expression item)
{
var newContext = this.Context.GetCopyContext();
newContext.MappingColumns = this.Context.MappingColumns;
newContext.MappingTables = this.Context.MappingTables;
newContext.IgnoreComumnList = this.Context.IgnoreComumnList;
newContext.SqlFuncServices = this.Context.SqlFuncServices;
newContext.Resolve(item, this.Context.IsJoin ? ResolveExpressType.WhereMultiple : ResolveExpressType.WhereSingle);
this.Context.Index = newContext.Index;
this.Context.ParameterIndex = newContext.ParameterIndex;
if (newContext.Parameters.HasValue())
{
this.Context.Parameters.AddRange(newContext.Parameters);
}
var methodCallExpressionArgs = new MethodCallExpressionArgs()
{
IsMember = true,
MemberName = newContext.Result.GetResultString()
};
return(methodCallExpressionArgs);
}
public ConditionalExpressionResolve(ExpressionParameter parameter) : base(parameter)
{
var express = base.Expression as ConditionalExpression;
var isLeft = parameter.IsLeft;
switch (base.Context.ResolveType)
{
case ResolveExpressType.None:
case ResolveExpressType.WhereSingle:
case ResolveExpressType.WhereMultiple:
case ResolveExpressType.SelectSingle:
case ResolveExpressType.SelectMultiple:
case ResolveExpressType.FieldSingle:
case ResolveExpressType.FieldMultiple:
case ResolveExpressType.Join:
case ResolveExpressType.ArraySingle:
case ResolveExpressType.ArrayMultiple:
case ResolveExpressType.Update:
default:
Check.Exception(true, "Does not support it.xx==value ? true:false , Use SqlFunc.IIF (it.xx==value,true,false)");
break;
}
}
private void Select(ExpressionParameter parameter, bool?isLeft, string name, IEnumerable <Expression> args, MethodCallExpressionModel model, List <MethodCallExpressionArgs> appendArgs = null)
{
if (name == "GetSelfAndAutoFill")
{
var memberValue = (args.First() as MemberExpression).Expression.ToString();
model.Args.Add(new MethodCallExpressionArgs()
{
MemberValue = memberValue, IsMember = true, MemberName = memberValue
});
}
else
{
foreach (var item in args)
{
AppendItem(parameter, name, args, model, item);
}
if (appendArgs != null)
{
model.Args.AddRange(appendArgs);
}
}
parameter.BaseParameter.CommonTempData = GetMdthodValue(name, model);
}
