protected override Expression VisitNew(NewExpression node)
{
var originalConstructorParameters = node.Arguments.Select(x => x.Type).ToList();
var genericType = node.Constructor.DeclaringType.GetGenericTypeDefinition();
var genericTypeParameters = genericType.GetTypeInfo().GenericTypeArguments.ToList();
var originalGenericArgs = node.Constructor.DeclaringType.GetTypeInfo().GenericTypeArguments.ToList();
if (genericTypeParameters.Count != _newGenericArgs.Length)
{
throw new InvalidOperationException("Wrong number of generic argument values specified. This type requires " + genericTypeParameters.Count + " generic type arguments");
}
for (int i = 0; i < _newGenericArgs.Length; i++)
{
var constraints = genericTypeParameters[i].GetTypeInfo().GetGenericParameterConstraints().ToList();
foreach (var constraint in constraints)
{
if (!constraint.GetTypeInfo().IsAssignableFrom(_newGenericArgs[i].GetTypeInfo()))
{
throw new InvalidOperationException("Generic type parameter " + i + " is constrained to type " + constraint + ". The supplied type " + _newGenericArgs[i] + " does not meet this constraint");
}
}
}
result = genericType.MakeGenericType(_newGenericArgs.ToArray()).GetTypeInfo().DeclaredConstructors.Where(x => x == node.Constructor).Single();
throw new VisitStoppedException();
}
public MemberInitExpression Update(NewExpression newExpression, IEnumerable<MemberBinding> bindings)
{
Contract.Requires(newExpression != null);
Contract.Requires(bindings != null);
Contract.Ensures(Contract.Result<MemberInitExpression>() != null);
return default(MemberInitExpression);
}
private object InvokeConstructor(NewExpression expression, object[] args, out int argumentCount)
{
object valueToSet;
int nestedArgumentCount;
argumentCount = 0;
ArrayList argList = new ArrayList();
int i = 0;
foreach (var arg in expression.Arguments)
{
switch (arg.NodeType)
{
case ExpressionType.New:
valueToSet = InvokeConstructor((NewExpression)arg, args.Skip(i).ToArray(), out nestedArgumentCount);
i += nestedArgumentCount;
break;
case ExpressionType.MemberInit:
valueToSet = InvokeMemberInitExpression((MemberInitExpression)arg,
args.Skip(i).ToArray(), out nestedArgumentCount);
i += nestedArgumentCount;
break;
default:
valueToSet = LinqUtil.ChangeType(args[i], arg.Type);
i++;
break;
}
argList.Add(valueToSet);
}
argumentCount = i;
return expression.Constructor.Invoke(argList.ToArray());
}
/// <summary>
/// Converts the new invocation call into a select clause.
/// </summary>
/// <param name="newExpression">The new expression.</param>
/// <returns></returns>
public static SelectClause NewToSelectClause(System.Linq.Expressions.NewExpression newExpression)
{
var selectClause = new SelectClause();
selectClause.IsDistinct = false;
selectClause.StreamSelector = StreamSelector.RSTREAM_ISTREAM_BOTH;
selectClause.SelectList = new List <SelectClauseElement>();
foreach (var argExpression in newExpression.Arguments)
{
if (argExpression is MemberExpression)
{
var memberExpression = (MemberExpression)argExpression;
var propertyExpression = MemberToSoda(memberExpression);
var selectClauseElement = new SelectClauseExpression(propertyExpression);
selectClause.SelectList.Add(selectClauseElement);
}
else
{
throw new ArgumentException(
String.Format("Expression of type {0} is not supported", argExpression.NodeType));
}
}
return(selectClause);
}
protected override Expression VisitNew(NewExpression node)
{
var newNode = (NewExpression)base.VisitNew(node);
if (newNode.Type.IsGenericType
&& newNode.Type.GetGenericTypeDefinition() == typeof(HashSet<>)
&& newNode.Arguments.Count == 1
&& newNode.Arguments[0] is AccumulatorExpression
&& ((AccumulatorExpression)newNode.Arguments[0]).AccumulatorType == AccumulatorType.Push)
{
Guid correlationId = Guid.Empty;
if (_groupMap == null || TryGetCorrelatedGroup(node.Arguments[0], out correlationId))
{
Expression accumulator = new AccumulatorExpression(
newNode.Type,
AccumulatorType.AddToSet,
((AccumulatorExpression)newNode.Arguments[0]).Argument);
if (_groupMap != null)
{
accumulator = new CorrelatedAccumulatorExpression(
correlationId,
(AccumulatorExpression)accumulator);
}
return accumulator;
}
}
return newNode;
}
public ListInitExpression Update(NewExpression newExpression, IEnumerable<ElementInit> initializers)
{
Contract.Requires(newExpression != null);
Contract.Requires(initializers != null);
Contract.Ensures(Contract.Result<ListInitExpression>() != null);
return default(ListInitExpression);
}
protected override Expression VisitNew(NewExpression node)
{
// specialize for DateTime
if (FormatIfExprIsDateTime(node)) return node;
// promising type initializer(goto:VisitMemberInit)
if (!node.Type.IsAnonymousType()) return node;
var indent = BuildIndent();
var innerTranslator = new BigQueryTranslateVisitor(depth, indentSize);
var merge = node.Members.Zip(node.Arguments, (x, y) =>
{
var rightValue = innerTranslator.VisitAndClearBuffer(y);
if (x.Name == rightValue.Trim('[', ']')) return "[" + x.Name + "]";
return rightValue + " AS " + "[" + x.Name + "]";
});
var command = string.Join("," + Environment.NewLine,
merge.Select(x => indent + x));
sb.Append(command);
return node;
}
protected override Expression VisitNew(NewExpression nex)
{
nex = (NewExpression)base.VisitNew(nex);
var instance = (Expression)null;
var method = (MethodBase)null;
return Matcher
.For(nex)
.Type(t => t.IsSubclassOf<Delegate>())
.Argument(0).AssignTo(out instance)
.For(nex)
.Argument(1).As<AddressOfExpression>()
.Do(x => method = x.Method)
.IfMatched<Expression>(
() => Expression.Call(null, CreateDelegateMethodInfo, new[] {
Expression.Constant(nex.Type),
instance,
Expression.Constant(method),
Expression.Constant(true)
}).Convert(nex.Type),
nex
);
}
public LetSelectExpressionNode(MethodCallExpressionParseInfo parseInfo, LambdaExpression selector)
: base(Utils.CheckNotNull("parseInfo", parseInfo), Utils.CheckNotNull("selector", selector))
{
// Heuristically detect "let" constructs
// Assume a Select call is a "let" construct if its selector looks like this: <x> => new { <x> = <x>, <y> = ... }
var selectorBody = selector.Body as NewExpression;
if (selectorBody != null
&& selectorBody.Arguments.Count == 2
&& selectorBody.Arguments[0] == selector.Parameters[0]
//&& selectorBody.Constructor.DeclaringType.IsDefined(typeof(CompilerGeneratedAttribute), false)
&& selectorBody.Members != null
&& selectorBody.Members.Count == 2)
{
_letConstruction = selectorBody;
_resolvedAdaptedSelector = new ResolvedExpressionCache<Expression>(this);
_resolvedLetExpression = new ResolvedExpressionCache<Expression>(this);
}
else
{
_letConstruction = null;
_resolvedAdaptedSelector = null;
_resolvedLetExpression = null;
}
}
protected override Expression VisitNew(NewExpression newExpression)
{
Check.NotNull(newExpression, nameof(newExpression));
var newNewExpression = base.VisitNew(newExpression);
var selectExpression = QueryModelVisitor.TryGetQuery(_querySource);
if (selectExpression != null)
{
for (var i = 0; i < newExpression.Arguments.Count; i++)
{
var aliasExpression
= selectExpression.Projection
.OfType<AliasExpression>()
.SingleOrDefault(ae => ae.SourceExpression == newExpression.Arguments[i]);
if (aliasExpression != null)
{
aliasExpression.SourceMember
= newExpression.Members?[i]
?? (newExpression.Arguments[i] as MemberExpression)?.Member;
}
}
}
return newNewExpression;
}
/// <summary>
/// Returns a factory method that calls a default constructor of a type T.
/// </summary>
public static Func <T> GenerateFactory <T>() where T : new()
{
Expression <Func <T> > expr = () => new T();
System.Linq.Expressions.NewExpression newExpr = (System.Linq.Expressions.NewExpression)expr.Body;
var method = new DynamicMethod(
name: "lambda",
returnType: newExpr.Type,
parameterTypes: new Type[0],
m: typeof(DynamicModuleLambdaCompiler).Module,
skipVisibility: true);
ILGenerator ilGen = method.GetILGenerator();
// Constructor for value types could be null
if (newExpr.Constructor != null)
{
ilGen.Emit(OpCodes.Newobj, newExpr.Constructor);
}
else
{
LocalBuilder temp = ilGen.DeclareLocal(newExpr.Type);
ilGen.Emit(OpCodes.Ldloca, temp);
ilGen.Emit(OpCodes.Initobj, newExpr.Type);
ilGen.Emit(OpCodes.Ldloc, temp);
}
ilGen.Emit(OpCodes.Ret);
return((Func <T>)method.CreateDelegate(typeof(Func <T>)));
}
/// <summary>
/// Visits new object expression like new DateTime().
/// </summary>
/// <param name="node">Node to visit.</param>
/// <returns>Original node.</returns>
protected override Expression VisitNew(NewExpression node)
{
var newObject = node.Constructor.Invoke(node.Arguments.Select(a => ((ConstantExpression)a).Value).ToArray());
PrintConstant(newObject);
return node;
}
/// <summary>
/// Constructor with an <see cref="NewExpression"/> and an <see cref="ExpressionConverter"/>.
/// </summary>
/// <param name="expression">The original, not serializable <see cref="Expression"/>.</param>
/// <param name="expConverter">The <see cref="ExpressionConverter"/> to convert contained <see cref="Expression">Expressions</see>.</param>
public SerializableNewExpression(NewExpression expression, ExpressionConverter expConverter)
: base(expression, expConverter)
{
Arguments = expression.Arguments.MakeSerializableCollection<SerializableExpression>(expConverter);
Members = InterLinqTypeSystem.Instance.GetCollectionOf<InterLinqMemberInfo>(expression.Members);
Constructor = InterLinqTypeSystem.Instance.GetInterLinqVersionOf<InterLinqConstructorInfo>(expression.Constructor);
}
static void Main(string[] args)
{
//int maxCount = 40000;
//List<HotSpotEntities> collection = new List<HotSpotEntities>();
//for (int i = 0; i < maxCount; i++)
//{
// Console.WriteLine(string.Format("成功创建连接对象{0}", i));
// var db = new HotSpotEntities();
// db.Connection.Open();
// collection.Add(db);
//}
Expression<Func<int, bool>> exp1 = x => x > 5;
Expression<Func<int, bool>> exp2 = x => x < 10;
ParameterExpression y = Expression.Parameter(typeof(int), "y");
var newExp = new NewExpression(y);
var newexp1 = newExp.Replace(exp1.Body);
var newexp2 = newExp.Replace(exp2.Body);
var newbody = Expression.And(newexp1, newexp2);
Expression<Func<int, bool>> res = Expression.Lambda<Func<int, bool>>(newbody, y);
//将表达式树描述的lambda表达式编译为可执行代码，并生成表示该lambda表达式的委托
Func<int, bool> del = res.Compile();
Console.WriteLine(del(7));
Console.ReadLine();
}
protected MemberInitExpression UpdateMemberInit(MemberInitExpression init, NewExpression nex, IEnumerable<MemberBinding> bindings)
{
if (nex != init.NewExpression || bindings != init.Bindings) {
return Expression.MemberInit(nex, bindings);
}
return init;
}
protected ListInitExpression UpdateListInit(ListInitExpression init, NewExpression nex, IEnumerable<ElementInit> initializers)
{
if (nex != init.NewExpression || initializers != init.Initializers) {
return Expression.ListInit(nex, initializers);
}
return init;
}
public MetaTableExpression(NewExpression newExpression, IList<SqlExpression> values)
: base(SqlExpressionType.MetaTable, newExpression.Type)
{
SourceExpression = newExpression;
Values = values;
foreach(var v in Values)
Operands.Add(v);
}
//CONFORMING
public static ListInitExpression ListInit(NewExpression newExpression, MethodInfo addMethod, params Expression[] initializers) {
if (addMethod == null) {
return ListInit(newExpression, initializers as IEnumerable<Expression>);
}
ContractUtils.RequiresNotNull(newExpression, "newExpression");
ContractUtils.RequiresNotNull(initializers, "initializers");
return ListInit(newExpression, addMethod, initializers as IEnumerable<Expression>);
}
protected override Expression VisitNew(NewExpression nex)
{
nex = (NewExpression)base.VisitNew(nex);
if (!nex.Constructor.DeclaringType.IsGenericTypeDefinedAs(typeof(Nullable<>)))
return nex;
return Expression.Convert(nex.Arguments[0], nex.Type);
}
protected override Expression VisitNew(NewExpression node)
{
var args = node.Arguments.Cast<ConstantExpression>().Select(c => c.Value).ToArray();
var value = node.Constructor.Invoke(args);
var cex = Expression.Constant(value);
return Visit(cex);
}
/// <summary>
/// Creates a new expression that is like this one, but using the
/// supplied children. If all of the children are the same, it will
/// return this expression.
/// </summary>
/// <param name="newExpression">The <see cref="NewExpression"/> property of the result.</param>
/// <param name="initializers">The <see cref="Initializers"/> property of the result.</param>
/// <returns>This expression if no children changed, or an expression with the updated children.</returns>
public ListInitExpression Update(NewExpression newExpression, IEnumerable<ElementInit> initializers)
{
if (newExpression == NewExpression && initializers == Initializers)
{
return this;
}
return Expression.ListInit(newExpression, initializers);
}
protected override NewExpression VisitNew(NewExpression nex)
{
if (nex.Arguments.Count == 0 && nex.Type.IsGenericType)
{
VisitConstant(Expression.Constant(null));
}
VisitExpressionList(nex.Arguments);
return nex;
}
private static Node NewObject(NewExpression e)
{
string value = GetValue(e, false);
return new ConstantNode
{
Text = value
};
}
protected static ListInitExpression UpdateListInit(ListInitExpression node, NewExpression nex,
IEnumerable<ElementInit> initializers)
{
if (node.NewExpression != nex || node.Initializers != initializers)
{
return Expression.ListInit(nex, initializers);
}
return node;
}
protected override Expression VisitNew(NewExpression node)
{
// Test if this is a nullable type
if (IsNullable(node.Type) && node.Arguments.Count == 1)
{
return Expression.Convert(Visit(node.Arguments[0]), node.Type);
}
return base.VisitNew(node);
}
protected override Expression VisitNew(NewExpression n)
{
var replacedArguments = new List<Expression>();
foreach (var argument in n.Arguments)
{
replacedArguments.Add(this.Visit(argument));
}
return Expression.New(n.Constructor, replacedArguments.ToArray());
}
public static XmlNewExpression From(NewExpression nex)
{
return new XmlNewExpression
{
Method = XmlMetadataInfo.FromMetadata(nex.Constructor),
Arguments = XmlExpression.FromMany(nex.Arguments),
Members = XmlMetadataInfo.FromMany(nex.Members)
};
}
private static MemberInitExpression CreateMemberInitExpression(ParameterExpression left, Type entityType, Type dtoType, Tuple <Type, string>[] linkEntityNames)
{
System.Linq.Expressions.NewExpression newAnimal = System.Linq.Expressions.Expression.New(dtoType);
List <MemberBinding> bindings = new List <MemberBinding>();
var members = dtoType.GetProperties();//获取Dto的各个属性
members.ToList().ForEach(p =>
{
try
{
if (linkEntityNames != null && linkEntityNames.Length > 0)
{
var container = linkEntityNames.ToList().FirstOrDefault(x => p.Name.Contains(x.Item2));
if (container != null)
{
var rightStr = p.Name.Replace(container.Item2, "");
Expression right = Expression.Property(left, entityType.GetProperty(container.Item2));
MemberExpression mem = Expression.Property(right, rightStr);
//这里传的mem是 用 a.name给它赋值
System.Linq.Expressions.MemberBinding speciesMemberBinding = System.Linq.Expressions.Expression.Bind(p, mem);
bindings.Add(speciesMemberBinding);
}
else
{
MemberExpression mem = Expression.Property(left, p.Name);
//这里传的mem是 用 a.name给它赋值
System.Linq.Expressions.MemberBinding speciesMemberBinding = System.Linq.Expressions.Expression.Bind(p, mem);
bindings.Add(speciesMemberBinding);
}
}
else
{
try
{
MemberExpression mem = Expression.Property(left, p.Name);
//这里传的mem是 用 a.name给它赋值
System.Linq.Expressions.MemberBinding speciesMemberBinding = System.Linq.Expressions.Expression.Bind(p, mem);
bindings.Add(speciesMemberBinding);
}
catch (Exception ex)
{
}
}
}
catch
{
}
});
System.Linq.Expressions.MemberInitExpression memberInitExpression = System.Linq.Expressions.Expression.MemberInit(newAnimal, bindings.ToArray());
return(memberInitExpression);
}
private IEnumerable<ColumnMap> ComputeColumnMaps(NewExpression newExpression)
{
for (var i = 0; i < newExpression.Members.Count; i++)
{
foreach (var _ in ComputeColumnMaps(newExpression.Arguments[i]).Select(_ => _.RightShift(newExpression.Members[i].Name)))
{
yield return _;
}
}
}
protected override Expression VisitNew(NewExpression node) {
var arguments = node.Arguments.Cast<ParameterExpression>()
.Select(a => Visit(a))
.ToListOf<ParameterExpressionConfiguration>();
return new NewExpressionConfiguration {
arguments = arguments,
type = node.Type.GetQualifiedName()
};
}
//CONFORMING
public static ListInitExpression ListInit(NewExpression newExpression, IEnumerable<Expression> initializers) {
ContractUtils.RequiresNotNull(newExpression, "newExpression");
ContractUtils.RequiresNotNull(initializers, "initializers");
ReadOnlyCollection<Expression> initializerlist = initializers.ToReadOnly();
if (initializerlist.Count == 0) {
throw Error.ListInitializerWithZeroMembers();
}
MethodInfo addMethod = FindMethod(newExpression.Type, "Add", null, new Expression[] { initializerlist[0] }, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
return ListInit(newExpression, addMethod, initializers);
}
private NewExpression Convert(LinqExp.NewExpression linqNew)
{
return((linqNew.Members != null)
? Expression.New(
linqNew.Constructor,
Convert(linqNew.Arguments),
linqNew.Members)
: Expression.New(
linqNew.Constructor,
Convert(linqNew.Arguments)));
}
/// <summary>
/// Visits new object expression (e.g. new DateTime()).
/// </summary>
/// <param name="node">Node to visit.</param>
/// <returns>Original node.</returns>
protected override Expression VisitNew(NewExpression node)
{
if (node == null)
{
throw new ArgumentNullException("node");
}
var newObject = node.Constructor.Invoke(node.Arguments.Select(a => ((ConstantExpression)a).Value).ToArray());
PrintConstant(newObject);
return node;
}
public static void CreateMemberInitExpression()
{
System.Linq.Expressions.NewExpression newAnimal =
System.Linq.Expressions.Expression.New(typeof(Animal));
System.Reflection.MemberInfo speciesMember =
typeof(Animal).GetMember("Species")[0];
System.Reflection.MemberInfo ageMember =
typeof(Animal).GetMember("Age")[0];
// Create a MemberBinding object for each member
// that you want to initialize.
System.Linq.Expressions.MemberBinding speciesMemberBinding =
System.Linq.Expressions.Expression.Bind(
speciesMember,
System.Linq.Expressions.Expression.Constant("horse"));
System.Linq.Expressions.MemberBinding ageMemberBinding =
System.Linq.Expressions.Expression.Bind(
ageMember,
System.Linq.Expressions.Expression.Constant(12));
// Create a MemberInitExpression that represents initializing
// two members of the 'Animal' class.
System.Linq.Expressions.MemberInitExpression memberInitExpression =
System.Linq.Expressions.Expression.MemberInit(
newAnimal,
speciesMemberBinding,
ageMemberBinding);
//// Create a MemberInitExpression that represents initializing
//// two members of the 'Animal' class.
//System.Linq.Expressions.MemberInitExpression memberInitExpression =
// System.Linq.Expressions.Expression.MemberInit(
// newAnimal,
// speciesMemberBinding);
Console.WriteLine(memberInitExpression.ToString());
var expression = Expression.Lambda <Func <Dog, Animal> >(memberInitExpression);
var compile = expression.Compile();
var dog = new Dog()
{
Species = "DOG"
};
var test = compile(dog);
Console.WriteLine(test.ToJson());
// This code produces the following output:
//
// new Animal() {Species = "horse", Age = 12}
}
protected override NewExpression VisitNew(NewExpression nex)
{
nex = DoVisitNew(nex);
assignments.Add(new AssignmentInformation()
{
Declaration = nex,
MembershipPath = membershipPath,
});
return nex;
}
private new RemoteLinq.NewExpression VisitNew(SystemLinq.NewExpression node)
{
IEnumerable <RemoteLinq.Expression>?arguments = null;
if (node.Arguments?.Count > 0)
{
arguments = node.Arguments
.Select(Visit)
.Select(Unwrap);
}
return(node.Constructor is null
? new RemoteLinq.NewExpression(_typeInfoProvider.GetTypeInfo(node.Type))
: new RemoteLinq.NewExpression(_typeInfoProvider.GetConstructorInfo(node.Constructor), arguments, node.Members?.Select(x => _typeInfoProvider.GetMemberInfo(x))));
}
/// <summary>
/// 获取SelectLambda
/// </summary>
/// <returns></returns>
public static System.Linq.Expressions.Expression <Func <T, V> > GetSelectLambda(Expression <Func <T, V> > selectEx = null)
{
ParameterExpression param = Expression.Parameter(typeof(T), "c");
Expression Iwhere = null;
List <MemberBinding> mebers = new List <MemberBinding>();
if (selectEx != null)
{
param = selectEx.Parameters.FirstOrDefault();
mebers = ((MemberInitExpression)selectEx.Body).Bindings.ToList();
}
System.Linq.Expressions.NewExpression newAnimal =
System.Linq.Expressions.Expression.New(typeof(V));
foreach (System.Reflection.PropertyInfo pinfo in typeof(V).GetProperties())
{
try
{
if (mebers.Exists(s => s.Member.Name == pinfo.Name))
{
continue;
}
Expression valueEx = null;
object ob = pinfo.GetCustomAttributes(typeof(DataAttribute), false).FirstOrDefault();
object ea = pinfo.GetCustomAttributes(typeof(ChildTableAttribute), false).FirstOrDefault();
object opAttr = pinfo.GetCustomAttributes(typeof(OperationAttribute), false).FirstOrDefault();
System.Reflection.PropertyInfo TableInfo = null;
if (ea != null)
{
valueEx = (ea as ChildTableAttribute).GetExpression(param, typeof(T));
TableInfo = (ea as ChildTableAttribute).getPropertyInfo(typeof(T));
}
MemberBinding Select = null;
if (ob != null || (opAttr != null && valueEx != null))
{
#region 存在子实体数据
//存在子实体数据
DataAttribute dataAtt = (DataAttribute)ob;
System.Reflection.MemberInfo Minfo = null;
if (TableInfo == null)
{
if (dataAtt.TableName != null)
{
TableInfo = typeof(T).GetProperty(dataAtt.TableName);
}
else
{
// 当前表别名处理无子从表
valueEx = Expression.Property(param, dataAtt.ColName);
if (valueEx.Type != pinfo.PropertyType)
{
valueEx = Expression.Convert(valueEx, pinfo.PropertyType);
}
Select = Expression.Bind(pinfo, valueEx);
mebers.Add(Select);
continue;
}
}
//获取外键表类映射
if (TableInfo.PropertyType.IsGenericType && TableInfo.PropertyType.GetGenericTypeDefinition() == typeof(System.Collections.Generic.ICollection <>))
{
#region 子从表外键
// 如果外键表是子从表
object op = pinfo.GetCustomAttributes(typeof(OperAttribute), false).FirstOrDefault();
if (op != null)
{
// 条件运算
OperAttribute opAtt = (OperAttribute)op;
// 统计表
Type tableType = BaseToolClass.GetObType(TableInfo.PropertyType);
// 分表实体
ParameterExpression paramd = Expression.Parameter(tableType, "d");
Expression whereRight = null;
if (ea != null)
{
if (opAttr == null)
{
whereRight = (ob as ExpressAttrInterface).GetExpression(paramd, tableType);
}
else
{
whereRight = (opAttr as ExpressAttrInterface).GetExpression(paramd, tableType);
}
}
else
{
whereRight = Expression.Property(paramd, tableType.GetProperty(dataAtt.ColName));
}
// 筛选检索条件where
object[] otList = pinfo.GetCustomAttributes(typeof(OtherKeyAttribute), false);
Expression whereAll = null;
foreach (object ot in otList)
{
OtherKeyAttribute otAtt = (OtherKeyAttribute)ot;
MemberExpression whereLeft = Expression.Property(paramd, tableType.GetProperty(otAtt.CkColName));
Expression whereZ = whereSymbol(otAtt.Symbol, whereLeft, null, otAtt.values);
if (whereAll == null)
{
whereAll = whereZ;
}
else
{
whereAll = Expression.And(Iwhere, whereZ);
}
}
//object otList1 = pinfo.GetCustomAttributes(typeof(SearchKeyAttribute), false);
//if (otList1 != null)
//{
// SearchKeyAttribute otAtt = (SearchKeyAttribute)otList1;
// int num = otAtt.Num;
// for (int i = 0; i < num; i++)
// {
// MemberExpression whereLeft = Expression.Property(paramd, tableType.GetProperty(otAtt.ColName[i]));
// Expression whereZ = whereSymbol(otAtt.Symbol[i], whereLeft, null, otAtt.Values[i]);
// if (whereAll == null)
// {
// whereAll = whereZ;
// }
// else
// {
// whereAll = Expression.And(Iwhere, whereZ);
// }
// }
//}
System.Reflection.MethodInfo methInfo = BaseToolClass.GetMethodInfo(typeof(Expression), "Lambda", null, new Type[] { typeof(Expression), typeof(ParameterExpression[]) }, true);
object Value = methInfo.MakeGenericMethod(typeof(Func <,>).MakeGenericType(tableType, typeof(bool))).Invoke(null, new object[] { whereAll, new System.Linq.Expressions.ParameterExpression[] { paramd } });
Expression whereTable = valueEx;
var WhereExpression = Expression.Lambda(whereAll, paramd);
var resultExpression = Expression.Call(null,
BaseToolClass.GetMethodInfo(typeof(Enumerable), "Where", null, new Type[] { typeof(IEnumerable <TSource_1>), typeof(Func <TSource_1, bool>) }, true).MakeGenericMethod(tableType)
, whereTable, WhereExpression);
// 统计属性
Expression syValue = null;
if (whereRight.Type != pinfo.PropertyType)
{
whereRight = Expression.Convert(whereRight, pinfo.PropertyType);
}
syValue = Expression.Lambda(whereRight, paramd);
Type OType = pinfo.PropertyType;
if (opAtt.Symol == OperSymol.Count)
{
OType = typeof(int);
}
whereTable = Expression.Call(
null,
BaseToolClass.GetMethodInfo(typeof(Enumerable), opAtt.ToMethodStr(), null, new Type[] { typeof(IEnumerable <TSource_1>), typeof(Func <,>).MakeGenericType(typeof(TSource_1), OType) }, true, OType).MakeGenericMethod(tableType),
resultExpression,
syValue
);
Minfo = pinfo;
valueEx = whereTable;
Select = Expression.Bind(Minfo, valueEx);
mebers.Add(Select);
}
continue;
#endregion
}
else
{
// 如果外键表是外键关联表
if (valueEx == null)
{
valueEx = (ob as ExpressAttrInterface).GetExpression(param, typeof(T));
}
else
{
if (opAttr == null)
{
if (ea != null)
{
valueEx = (ob as ExpressAttrInterface).GetExpression(valueEx, valueEx.Type);
}
else
{
valueEx = Expression.Property(valueEx, dataAtt.ColName);
}
}
else
{
valueEx = (opAttr as ExpressAttrInterface).GetExpression(valueEx, valueEx.Type);
}
}
Minfo = pinfo;
}
if (valueEx.Type != pinfo.PropertyType)
{
valueEx = Expression.Convert(valueEx, pinfo.PropertyType);
}
Select = Expression.Bind(Minfo, valueEx);
mebers.Add(Select);
#endregion
}
else
{
if (opAttr != null)
{
if (valueEx == null)
{
valueEx = (opAttr as ExpressAttrInterface).GetExpression(param, param.Type);
}
else
{
valueEx = (opAttr as ExpressAttrInterface).GetExpression(valueEx, valueEx.Type);
}
}
else
{
if (valueEx == null)
{
valueEx = Expression.Property(param, pinfo.Name);
}
else
{
valueEx = Expression.Property(valueEx, pinfo.Name);
}
}
if (valueEx.Type != typeof(V).GetProperty(pinfo.Name).PropertyType)
{
valueEx = Expression.Convert(valueEx, typeof(V).GetProperty(pinfo.Name).PropertyType);
}
mebers.Add(Expression.Bind(typeof(V).GetProperty(pinfo.Name), valueEx));
}
}
catch { }
}
Expression sel = Expression.MemberInit(newAnimal, mebers);
return(Expression.Lambda <Func <T, V> >(sel, param));
}
public MemberInitExpression Update(NewExpression newExpression, IEnumerable <MemberBinding> bindings)
{
throw new NotImplementedException();
}
public NewExpressionProxy(NewExpression node)
{
ContractUtils.RequiresNotNull(node, nameof(node));
_node = node;
}
/// <summary>Creates a <see cref="MemberInitExpression" />.</summary>
/// <returns>
/// A <see cref="MemberInitExpression" /> that has the <see cref="NodeType" /> property equal to
/// <see cref="ExpressionType.MemberInit" /> and the <see cref="MemberInitExpression.NewExpression" /> and
/// <see cref="MemberInitExpression.Bindings" /> properties set to the specified values.
/// </returns>
/// <param name="newExpression">
/// A <see cref="NewExpression" /> to set the <see cref="MemberInitExpression.NewExpression" />
/// property equal to.
/// </param>
/// <param name="bindings">
/// An array of <see cref="MemberBinding" /> objects to use to populate the
/// <see cref="MemberInitExpression.Bindings" /> collection.
/// </param>
/// <exception cref="ArgumentNullException">
/// <paramref name="newExpression" /> or <paramref name="bindings" /> is null.
/// </exception>
/// <exception cref="ArgumentException">
/// The <see cref="MemberBinding.Member" /> property of an element of
/// <paramref name="bindings" /> does not represent a member of the type that <paramref name="newExpression" />.Type
/// represents.
/// </exception>
public static MemberInitExpression MemberInit(NewExpression newExpression, params MemberBinding[] bindings)
{
return(MemberInit(newExpression, (IEnumerable <MemberBinding>)bindings));
}
internal MemberInitExpression(NewExpression newExpression, MemberBinding[] bindings)
{
NewExpression = newExpression;
_bindings = bindings;
_bindingsAsReadOnlyCollection = ReadOnlyCollectionEx.Create(_bindings);
}
internal ListInitExpression(NewExpression newExpression, ElementInit[] initializers)
{
_newExpression = newExpression;
_initializers = new TrueReadOnlyCollection <ElementInit>(initializers);
}
protected internal override Expression VisitNew(NewExpression node)
{
Out(".New " + node.Type.ToString());
VisitExpressions('(', node.Arguments);
return(node);
}
/// <summary>
/// Creates a <see cref="ListInitExpression"/> that uses specified <see cref="M:ElementInit"/> objects to initialize a collection.
/// </summary>
/// <param name="newExpression">A <see cref="NewExpression"/> to set the <see cref="P:ListInitExpression.NewExpression"/> property equal to.</param>
/// <param name="initializers">An array that contains <see cref="M:ElementInit"/> objects to use to populate the <see cref="ListInitExpression.Initializers"/> collection.</param>
/// <returns>
/// A <see cref="ListInitExpression"/> that has the <see cref="P:Expressions.NodeType"/> property equal to ListInit
/// and the <see cref="P:ListInitExpression.NewExpression"/> and <see cref="P:ListInitExpression.Initializers"/> properties set to the specified values.
/// </returns>
/// <remarks>
/// The <see cref="P:Expressions.Type"/> property of <paramref name="newExpression"/> must represent a type that implements <see cref="System.Collections.IEnumerable"/>.
/// The <see cref="P:Expressions.Type"/> property of the resulting <see cref="ListInitExpression"/> is equal to newExpression.Type.
/// </remarks>
public static ListInitExpression ListInit(NewExpression newExpression, params ElementInit[] initializers)
{
return(ListInit(newExpression, (IEnumerable <ElementInit>)initializers));
}
/// <summary>
/// Creates a <see cref="ListInitExpression"/> that uses a specified method to add elements to a collection.
/// </summary>
/// <param name="newExpression">A <see cref="NewExpression"/> to set the <see cref="P:ListInitExpression.NewExpression"/> property equal to.</param>
/// <param name="addMethod">A <see cref="MethodInfo"/> that represents an instance method named "Add" (case insensitive), that adds an element to a collection. </param>
/// <param name="initializers">An array of <see cref="Expression"/> objects to use to populate the <see cref="ListInitExpression.Initializers"/> collection.</param>
/// <returns>A <see cref="ListInitExpression"/> that has the <see cref="P:ListInitExpression.NodeType"/> property equal to ListInit and the <see cref="P:ListInitExpression.NewExpression"/> property set to the specified value.</returns>
public static ListInitExpression ListInit(NewExpression newExpression, MethodInfo addMethod, params Expression[] initializers)
{
return(ListInit(newExpression, addMethod, initializers as IEnumerable <Expression>));
}
internal ListInitExpression(NewExpression newExpression, ReadOnlyCollection <ElementInit> initializers)
{
_newExpression = newExpression;
_initializers = initializers;
}
protected override NewExpression VisitNew(NewExpression nex) => InvokeEvent(NewVisited, nex, base.VisitNew);
/// <summary>
/// These are static classes as far as we are concerned - so they should never be able to run.
/// </summary>
/// <param name="expression"></param>
/// <param name="result"></param>
/// <param name="gc"></param>
/// <param name="context"></param>
/// <param name="container"></param>
/// <returns></returns>
public System.Linq.Expressions.Expression ProcessNew(System.Linq.Expressions.NewExpression expression, out IValue result, IGeneratedQueryCode gc, System.ComponentModel.Composition.Hosting.CompositionContainer container)
{
throw new NotImplementedException();
}
protected virtual void VisitNew(NewExpression nex)
{
this.VisitExpressionList(nex.Arguments);
}
internal MemberInitExpression(NewExpression new_expression, ReadOnlyCollection <MemberBinding> bindings)
: base(ExpressionType.MemberInit, new_expression.Type)
{
this.new_expression = new_expression;
this.bindings = bindings;
}
protected override MSAst.Expression VisitNew(MSAst.NewExpression node)
{
return(VisitCall(base.VisitNew(node)));
}
/// <summary>
/// Creates a <see cref="ListInitExpression"/> that uses a specified method to add elements to a collection.
/// </summary>
/// <param name="newExpression">A <see cref="NewExpression"/> to set the <see cref="P:ListInitExpression.NewExpression"/> property equal to.</param>
/// <param name="addMethod">A <see cref="MethodInfo"/> that represents an instance method named "Add" (case insensitive), that adds an element to a collection. </param>
/// <param name="initializers">An <see cref="IEnumerable{T}"/> that contains <see cref="Expression"/> objects to use to populate the Initializers collection.</param>
/// <returns>A <see cref="ListInitExpression"/> that has the <see cref="P:ListInitExpression.NodeType"/> property equal to ListInit and the <see cref="P:ListInitExpression.NewExpression"/> property set to the specified value.</returns>
public static ListInitExpression ListInit(NewExpression newExpression, MethodInfo addMethod, IEnumerable <Expression> initializers)
{
if (addMethod == null)
{
return(ListInit(newExpression, initializers));
}
ContractUtils.RequiresNotNull(newExpression, "newExpression");
ContractUtils.RequiresNotNull(initializers, "initializers");
List <ElementInit> initList = null;
ElementInit[] initArray = null;
initializers = initializers.NullOrEmptyChecked
(
() =>
{
throw Error.ListInitializerWithZeroMembers();
},
() => initList = new List <ElementInit>(),
count => initArray = new ElementInit[count]
);
var enumerator = initializers.GetEnumerator();
try
{
enumerator.MoveNext();
var initializer = enumerator.Current;
if (addMethod == null)
{
return(ListInit(newExpression, initializers));
}
if (initList != null)
{
initList.Add(ElementInit(addMethod, initializer));
while (enumerator.MoveNext())
{
initializer = enumerator.Current;
initList.Add(ElementInit(addMethod, initializer));
}
initArray = initList.ToArray();
}
else
{
var index = 0;
initArray[index] = ElementInit(addMethod, initializer);
index++;
while (enumerator.MoveNext())
{
initializer = enumerator.Current;
initArray[index] = ElementInit(addMethod, initializer);
index++;
}
}
}
finally
{
enumerator.Dispose();
}
ValidateListInitArgs(newExpression.Type, initArray);
return(new ListInitExpression(newExpression, initArray));
}
