private static LinqExpression BuildChildrenExpr(Expression expr, System.Linq.Expressions.ParameterExpression resourceAttrParameterExpr) { var compExpr = expr as CompAttributeExpression; var logExpr = expr as LogicalExpression; if (compExpr != null) { var act = new Func <System.Linq.Expressions.ParameterExpression, LinqExpression>((p) => { return(GetComparisonExpression(compExpr, p)); }); return(EvaluateChildren(compExpr.Path, resourceAttrParameterExpr, act)); } var leftExpr = logExpr.AttributeLeft; var rightExpr = logExpr.AttributeRight; var leftChildConds = BuildChildrenExpr(leftExpr, resourceAttrParameterExpr); var rightChildConds = BuildChildrenExpr(rightExpr, resourceAttrParameterExpr); LinqExpression result = null; switch (logExpr.Operator) { case LogicalOperators.and: result = LinqExpression.AndAlso(leftChildConds, rightChildConds); break; case LogicalOperators.or: result = LinqExpression.OrElse(leftChildConds, rightChildConds); break; } return(result); }
public Delegate MakeDelegate(Type deltype) { #if NETFX_CORE Delegate rv = null; if (_Cache.TryGetValue(deltype, out rv)) { return(rv); } System.Linq.Expressions.ParameterExpression[] expars = new System.Linq.Expressions.ParameterExpression[0]; var pars = deltype.GetMethod("Invoke").GetParameters(); if (pars != null) { expars = new System.Linq.Expressions.ParameterExpression[pars.Length]; for (int i = 0; i < pars.Length; ++i) { expars[i] = System.Linq.Expressions.Expression.Parameter(pars[i].ParameterType, pars[i].Name); } } System.Linq.Expressions.ConstantExpression extar = System.Linq.Expressions.Expression.Constant(this); rv = System.Linq.Expressions.Expression.Lambda( deltype, System.Linq.Expressions.Expression.Call(extar, "Call", null, expars), true, expars ).Compile(); _Cache[deltype] = rv; return(rv); #else return(Delegate.CreateDelegate(deltype, this, "Call")); #endif }
private static LinqExpression Evaluate(this Expression expression, System.Linq.Expressions.ParameterExpression resourceAttrParameterExpr) { if (expression == null) { throw new ArgumentNullException(nameof(expression)); } var compAttrExpression = expression as CompAttributeExpression; var attrExpression = expression as AttributeExpression; var logicalExpression = expression as LogicalExpression; if (compAttrExpression != null) { return(compAttrExpression.Evaluate(resourceAttrParameterExpr)); } if (attrExpression != null) { return(attrExpression.Evaluate(resourceAttrParameterExpr)); } if (logicalExpression != null) { return(logicalExpression.Evaluate(resourceAttrParameterExpr)); } return(null); }
internal BlockExpression(VariableExpression[] variables, Expression[] expressions) : base(expressions.Last().Type) { Debug.Assert(variables != null); Debug.Assert(expressions != null); this.Variables = variables; this.Expressions = expressions; if (variables.Length == 0) { return; } boundVariables_ = System.Linq.Expressions.Expression.Parameter(objectArrayType_, "l"); for (var index = 0; index < variables.Length; index++) { var variable = variables[index]; Debug.Assert(variable.BoundVariables == null); Debug.Assert(variable.BoundVariablesIndex == -1); variable.BoundVariables = boundVariables_; variable.BoundVariablesIndex = index; } }
static Expr GenerateAddFlagsGuts(ExprParam paramV, ExprParam paramF) { var v_as_int = Expr.Convert(paramV, kUnderlyingType); // integer v = (integer)value var f_as_int = Expr.Convert(paramF, kUnderlyingType); // integer f = (integer)flags return(Expr.Convert(Expr.Or(v_as_int, f_as_int), kEnumType)); // (TEnum)(v | f) }
public EditConditionWindow(System.Linq.Expressions.ParameterExpression inparameter,Type type,int Level) : this(type) { parameter = inparameter; level = Level; this.Title = String.Format("{0}阶表达式", level); }
public static T GetValue <T>(object instance, string propPath) { Delegate runtimeDelegate; System.Linq.Expressions.ParameterExpression instanceParameter = System.Linq.Expressions.Expression.Parameter(instance.GetType(), "p"); string[] properties = propPath.Split('.'); System.Linq.Expressions.MemberExpression currentExpression = System.Linq.Expressions.Expression.PropertyOrField(instanceParameter, properties[0]); System.Linq.Expressions.LambdaExpression lambdaExpression = System.Linq.Expressions.Expression.Lambda(currentExpression, instanceParameter); for (int i = 1; i < properties.Length; i++) { currentExpression = System.Linq.Expressions.Expression.PropertyOrField(lambdaExpression.Body, properties[i]); lambdaExpression = System.Linq.Expressions.Expression.Lambda(currentExpression, instanceParameter); } runtimeDelegate = lambdaExpression.Compile(); return((T)runtimeDelegate.DynamicInvoke(instance)); }
/* * public static TP CleanProperty<T, TP>(T obj, System.Linq.Expressions.Expression<System.Func<T, TP>> propertySelector) where TP : class * { * var valueParam = System.Linq.Expressions.Expression.Parameter(typeof(TP), "value"); * var getValue = propertySelector.Compile(); * * // Use the propertySelector body as the left sign of an assign and all the complexity of getting to the property is handled. * var setValue = System.Linq.Expressions.Expression.Lambda<System.Action<T, TP>>( * System.Linq.Expressions.Expression.Assign(propertySelector.Body, valueParam), * propertySelector.Parameters[0], valueParam).Compile(); * * var value = getValue(obj); * // if (value != null && IsJunk(value)) * // setValue(obj, null); * return value; * } */ public static void oldGet(System.Collections.Generic.List <string> ls) { System.Type targetType = ls.GetType(); //System.Linq.Expressions.ParameterExpression p = System.Linq.Expressions.Expression.Parameter(typeof(string)); System.Linq.Expressions.ParameterExpression p = System.Linq.Expressions.Expression.Parameter(targetType); //var prop = System.Linq.Expressions.Expression.Property(p, "Length"); //System.Linq.Expressions.Expression.Field(p, "fieldName"); var prop = System.Linq.Expressions.Expression.PropertyOrField(p, "Count"); // var prop = System.Linq.Expressions.Expression.Property(p, "Count"); var con = System.Linq.Expressions.Expression.Convert(prop, typeof(object)); var exp = System.Linq.Expressions.Expression.Lambda(con, p); //var func = (System.Func<string, object>)exp.Compile(); //var func = (System.Func<System.Collections.Generic.List<string>, object>)exp.Compile(); var func = (System.Func <System.Collections.Generic.List <string>, object>)exp.Compile(); var obj = ls; int len = (int)func(obj); }
public Func <object, object> GetFunc( Type instanceType, string memberName) { System.Reflection.PropertyInfo member = instanceType.GetProperty( memberName, System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Instance); System.Linq.Expressions.ParameterExpression instance = System.Linq.Expressions.Expression.Parameter(typeof(object), "i"); System.Linq.Expressions.MemberExpression memberExp = System.Linq.Expressions.Expression.Property( System.Linq.Expressions.Expression.Convert(instance, member.DeclaringType), member); System.Linq.Expressions.Expression <Func <object, object> > getter = System.Linq.Expressions.Expression.Lambda <Func <object, object> >( System.Linq.Expressions.Expression.Convert(memberExp, typeof(object)), instance); Func <object, object> func = getter.Compile(); return(func); }
// 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); }
public void SetDelegate(Delegate del) { if (del == null) { _DelWrapped = null; } else { #if NETFX_CORE var extar = System.Linq.Expressions.Expression.Constant(del); System.Linq.Expressions.ParameterExpression[] expars = new System.Linq.Expressions.ParameterExpression[0]; var pars = DelType.GetMethod("Invoke").GetParameters(); if (pars != null) { expars = new System.Linq.Expressions.ParameterExpression[pars.Length]; for (int i = 0; i < pars.Length; ++i) { expars[i] = System.Linq.Expressions.Expression.Parameter(pars[i].ParameterType, pars[i].Name); } } var invoke = System.Linq.Expressions.Expression.Invoke(extar, expars); var func = System.Linq.Expressions.Expression.Lambda(DelType, invoke, expars).Compile(); _DelWrapped = func; #else _DelWrapped = Delegate.CreateDelegate(DelType, del.Target, del.Method, false); #endif } }
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
static Expr GenerateRemoveFlagsGuts(ExprParam paramV, ExprParam paramF) { var v_as_int = Expr.Convert(paramV, kUnderlyingType); // integer v = (integer)value var f_as_int = Expr.Convert(paramF, kUnderlyingType); // integer f = (integer)flags var f_complement = Expr.Not(f_as_int); // ~f return(Expr.Convert(Expr.And(v_as_int, f_complement), kEnumType)); // (TEnum)(v & ~f) }
static Expr GenerateAddFlagsGuts(ExprParam paramV, ExprParam paramF) { var param_v_member = Expr.PropertyOrField(paramV, EnumUtils.kMemberName); // value.value__ var param_f_member = Expr.PropertyOrField(paramF, EnumUtils.kMemberName); // flags.value__ var or = Expr.Or(param_v_member, param_f_member); return(Expr.Assign(param_v_member, or)); //return Expr.OrAssign(param_v_member, param_f_member); // value.value__ |= flags.value__ }
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); }
internal OrderByLinqExpression(string expr, System.Linq.Expressions.ParameterExpression instance) { string[] parts = expr.Split(new char[] { ' ', '\t', '\r', '\n' }, System.StringSplitOptions.RemoveEmptyEntries ); this.Selector = System.Linq.Expressions.Expression.PropertyOrField(instance, parts[0]); this.Ascending = System.StringComparer .InvariantCultureIgnoreCase.Equals(parts[1], "ASC"); }
public static Func <T, bool> GetFilter <T>(this Telerik.Windows.Data.IFilterDescriptor filterDescriptor) { // Create parameter of Type T System.Linq.Expressions.ParameterExpression parameter = System.Linq.Expressions.Expression.Parameter(typeof(T)); // Create filter expression var result = filterDescriptor.CreateFilterExpression(parameter); // Compile Lambda expression return(System.Linq.Expressions.Expression.Lambda <Func <T, bool> >(result, parameter).Compile()); }
protected override System.Linq.Expressions.Expression VisitParameter(System.Linq.Expressions.ParameterExpression p) { System.Linq.Expressions.ParameterExpression replacement; if (map.TryGetValue(p, out replacement)) { p = replacement; } return(base.VisitParameter(p)); }
static Expr GenerateRemoveFlagsGuts(ExprParam paramV, ExprParam paramF) { var param_v_member = Expr.PropertyOrField(paramV, EnumUtils.kMemberName); // value.value__ var param_f_member = Expr.PropertyOrField(paramF, EnumUtils.kMemberName); // flags.value__ var f_complement = Expr.Not(param_f_member); // ~flags.value__ var and = Expr.And(param_v_member, f_complement); return(Expr.Assign(param_v_member, and)); //return Expr.AndAssign(param_v_member, f_complement); // value.value__ &= ~flags.value__ }
private static LinqExpression Evaluate(this LogicalExpression expression, System.Linq.Expressions.ParameterExpression arg) { if (expression == null) { throw new ArgumentNullException(nameof(expression)); } if (arg == null) { throw new ArgumentNullException(nameof(arg)); } LinqExpression leftExpression = null; LinqExpression rightExpression = null; if (expression.AttributeLeft != null) { leftExpression = expression.AttributeLeft.Evaluate(arg); } if (expression.AttributeRight != null) { rightExpression = expression.AttributeRight.Evaluate(arg); } if (leftExpression != null && rightExpression != null) { switch (expression.Operator) { case LogicalOperators.and: return(LinqExpression.And(leftExpression, rightExpression)); case LogicalOperators.or: return(LinqExpression.Or(leftExpression, rightExpression)); } } if (leftExpression != null) { return(leftExpression); } if (rightExpression != null) { return(rightExpression); } return(null); }
protected override void Validate() { try { var paramExpressions = new System.Linq.Expressions.ParameterExpression[] { System.Linq.Expressions.Expression.Parameter(typeof(double), "y") }; var lambda = DynamicExpression.ParseLambda(paramExpressions, typeof(double), this.functionString); this.F = (Func <double, double>)lambda.Compile(); IsValid = true; } catch { IsValid = false; } }
internal static DMS DMSInsertIdentity(this DMS dms, IEntity entity) { dms.ExcuteType = DMSExcuteType.INSERTIDENTITY; IDictionary <string, object> ChangedProperties = ((IEntity)entity).ChangedMappingProperties; if (ChangedProperties == null || ChangedProperties.Count == 0) { Log.Debug(ReflectionUtils.GetMethodBaseInfo(System.Reflection.MethodBase.GetCurrentMethod()), "插入字段为空,不能进行添加数据", null); throw new DMSFrameException("插入字段为空,不能进行添加数据"); } System.Linq.Expressions.ParameterExpression yExpr = System.Linq.Expressions.Expression.Parameter(entity.GetType(), "x"); System.Linq.Expressions.LambdaExpression lambdaExpr = System.Linq.Expressions.Expression.Lambda(System.Linq.Expressions.Expression.Constant(ChangedProperties), yExpr); dms.ColumnsExpressioin.Append(lambdaExpr); return(dms); }
public virtual LinqExpr LookUp(string Name) { ParamExpr expr = decls.SingleOrDefault(i => i.Name == Name); if (expr != null) { return(expr); } if (parent != null) { return(parent.LookUp(Name)); } return(null); }
private static System.Func <T, T, T> CompileSubtract <T>() { // Declare the parameters System.Linq.Expressions.ParameterExpression paramA = System.Linq.Expressions.Expression.Parameter(typeof(T), "a"); System.Linq.Expressions.ParameterExpression paramB = System.Linq.Expressions.Expression.Parameter(typeof(T), "b"); // Subtract the parameters System.Linq.Expressions.BinaryExpression body = System.Linq.Expressions.Expression.Subtract(paramA, paramB); // Compile it System.Func <T, T, T> subtract = System.Linq.Expressions.Expression.Lambda <System.Func <T, T, T> > (body, paramA, paramB).Compile(); return(subtract); }
private static System.Func <T, T, T> CompileAdd <T>() { // Declare the parameters System.Linq.Expressions.ParameterExpression paramA = System.Linq.Expressions.Expression.Parameter(typeof(T), "a"); System.Linq.Expressions.ParameterExpression paramB = System.Linq.Expressions.Expression.Parameter(typeof(T), "b"); // Add the parameters System.Linq.Expressions.BinaryExpression body = System.Linq.Expressions.Expression.Add(paramA, paramB); // Compile it System.Func <T, T, T> add = System.Linq.Expressions.Expression.Lambda <System.Func <T, T, T> > (body, paramA, paramB).Compile(); return(add); }
//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
} // 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
static Arithmetics() { MINUS_ONE = (T)System.Convert.ChangeType(-1, typeof(T)); ZERO = (T)System.Convert.ChangeType(0, typeof(T)); ONE = (T)System.Convert.ChangeType(1, typeof(T)); TWO = (T)System.Convert.ChangeType(2, typeof(T)); THREE = (T)System.Convert.ChangeType(3, typeof(T)); DecimalEpsilon = new decimal(1, 0, 0, false, 27); DecimalPositiveInfinity = 1m / DecimalEpsilon; DecimalNegativeInfinity = -1m / DecimalEpsilon; System.Linq.Expressions.ParameterExpression paramA = System.Linq.Expressions.Expression.Parameter(typeof(T), "a"); System.Linq.Expressions.ParameterExpression paramB = System.Linq.Expressions.Expression.Parameter(typeof(T), "b"); // Add the parameters together System.Linq.Expressions.BinaryExpression addBody = System.Linq.Expressions.Expression.Add(paramA, paramB); // a-b System.Linq.Expressions.BinaryExpression subtractBody = System.Linq.Expressions.Expression.Subtract(paramA, paramB); // a*b System.Linq.Expressions.BinaryExpression multiplyBody = System.Linq.Expressions.Expression.Multiply(paramA, paramB); // a/b System.Linq.Expressions.BinaryExpression divideBody = System.Linq.Expressions.Expression.Divide(paramA, paramB); // a%b System.Linq.Expressions.BinaryExpression moduloBody = System.Linq.Expressions.Expression.Modulo(paramA, paramB); Add = System.Linq.Expressions.Expression.Lambda <Operation_T>(addBody, paramA, paramB).Compile(); Subtract = System.Linq.Expressions.Expression.Lambda <Operation_T>(subtractBody, paramA, paramB).Compile(); MultiplyInternal = System.Linq.Expressions.Expression.Lambda <Operation_T>(multiplyBody, paramA, paramB).Compile(); Divide = System.Linq.Expressions.Expression.Lambda <Operation_T>(divideBody, paramA, paramB).Compile(); Mod = System.Linq.Expressions.Expression.Lambda <Operation_T>(moduloBody, paramA, paramB).Compile(); }
public static dynamic TryGetProperty(dynamic dynamicObject, String PropertyName, dynamic Default) { try { if (!HasProperty(dynamicObject, PropertyName)) { return(Default); } if (dynamicObject.GetType() == typeof(System.Web.Helpers.DynamicJsonObject)) { // good thing this type of documentation was easy to find System.Web.Helpers.DynamicJsonObject obj = (System.Web.Helpers.DynamicJsonObject)dynamicObject; Type scope = obj.GetType(); System.Dynamic.IDynamicMetaObjectProvider provider = obj as System.Dynamic.IDynamicMetaObjectProvider; if (provider != null) { System.Linq.Expressions.ParameterExpression param = System.Linq.Expressions.Expression.Parameter(typeof(object)); System.Dynamic.DynamicMetaObject mobj = provider.GetMetaObject(param); System.Dynamic.GetMemberBinder binder = (System.Dynamic.GetMemberBinder)Microsoft.CSharp.RuntimeBinder.Binder.GetMember(0, PropertyName, scope, new Microsoft.CSharp.RuntimeBinder.CSharpArgumentInfo[] { Microsoft.CSharp.RuntimeBinder.CSharpArgumentInfo.Create(0, null) }); System.Dynamic.DynamicMetaObject ret = mobj.BindGetMember(binder); System.Linq.Expressions.BlockExpression final = System.Linq.Expressions.Expression.Block( System.Linq.Expressions.Expression.Label(System.Runtime.CompilerServices.CallSiteBinder.UpdateLabel), ret.Expression ); System.Linq.Expressions.LambdaExpression lambda = System.Linq.Expressions.Expression.Lambda(final, param); Delegate del = lambda.Compile(); return(del.DynamicInvoke(obj)); } else { return(obj.GetType().GetProperty(PropertyName, System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Instance).GetValue(obj, null)); } } else if (dynamicObject.GetType() == typeof(System.Collections.IDictionary)) { return((Dictionary <String, object>)dynamicObject[PropertyName]); } return(Default); } catch (Exception ex) { throw new Exception("Could not determine if dynamic object has property.", ex); } }
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); }
private static LinqExpression GetAttributesAny(LinqExpression expr, System.Linq.Expressions.ParameterExpression arg, System.Linq.Expressions.ParameterExpression raArg) { if (expr == null) { throw new ArgumentNullException(nameof(expr)); } if (arg == null) { throw new ArgumentNullException(nameof(arg)); } var representationAttributesProperty = LinqExpression.Property(arg, "Attributes"); var anyLambda = LinqExpression.Lambda <Func <RepresentationAttribute, bool> >(expr, raArg); var anyExpr = LinqExpression.Call(typeof(Enumerable), _anyMethodName, new[] { typeof(RepresentationAttribute) }, representationAttributesProperty, anyLambda); var itemCount = LinqExpression.Call(typeof(Enumerable), "Count", new[] { typeof(RepresentationAttribute) }, representationAttributesProperty); var moreThanZero = LinqExpression.GreaterThan(itemCount, LinqExpression.Constant(0)); return(LinqExpression.AndAlso(moreThanZero, anyExpr)); }
///////////////////////////////////////////////////////////////////////////// private static object [] ConvertLastIsArray( Type arrayElementType, IList<object> argsIn, IList<Type> convertToTypes ) { // ****** // // on entry we are "guaranteed" that lastParamType.IsArray // and nArgsIn is >= nConvertToTypes - 1 which will allow // us (at a minimum) to fill in all params except (maybe) // the last // //Type arrayElementType = lastParamType.GetElementType(); TypeCode typeCode = Type.GetTypeCode( arrayElementType ); // ****** // // method( int arg0, params object [] args ) // // method( params string [] strArgs ) // // called with: // // method( a, b, c ) // method() // // ****** // // convert only the first nConvertToTypes - 1 from argsIn, if they can be converted then we'll // bundle up the remainder argsIn as an object or string array - note ConvertArguments() will // create the newArgs array as nConvertToTypes length // int nArgsIn = argsIn.Count; //Length; int nConvertToTypes = convertToTypes.Count; //Length; object [] newArgs = Arguments.ConvertArguments( argsIn, nConvertToTypes - 1, convertToTypes, nConvertToTypes ); if( null == newArgs ) { // // unable to convert an argument, the following never returns // return null; } // ****** // // add one additional for the last parameter which we is the array and was not // converted above - diference between the lengths plus the array entry // int nObjectsToCopy = 1 + nArgsIn - nConvertToTypes; object [] array = null; if( TypeCode.String == typeCode ) { array = new string[ nObjectsToCopy ]; for( int iArg = nConvertToTypes - 1, index = 0; iArg < argsIn.Count; iArg++, index++ ) { array[ index ] = (string) Arguments.ChangeType( argsIn[iArg], typeof(string) ); } } else if( arrayElementType.Equals(typeof(System.Linq.Expressions.ParameterExpression)) ) { // // array type is: System.Linq.Expressions.ParameterExpression // array = new System.Linq.Expressions.ParameterExpression [ nObjectsToCopy ]; for( int iSource = nConvertToTypes - 1, iDest = 0; iDest < nObjectsToCopy; iSource++, iDest++ ) { array [ iDest ] = argsIn [ iSource ] as System.Linq.Expressions.ParameterExpression; } } else { array = new object[ nObjectsToCopy ]; for( int iSource = nConvertToTypes - 1, iDest = 0; iDest < nObjectsToCopy; iSource++, iDest++ ) { array[ iDest ] = argsIn[ iSource ]; } } // ****** newArgs[ nConvertToTypes - 1 ] = array; return newArgs; }
protected override void Validate() { try { var paramExpressions = new System.Linq.Expressions.ParameterExpression[] { System.Linq.Expressions.Expression.Parameter(typeof(double), "x") }; var lambda = DynamicExpression.ParseLambda(paramExpressions, typeof(double), this.functionString); this.F = (Func<double, double>)lambda.Compile(); IsValid = true; } catch { IsValid = false; } }
public MainWindow() { InitializeComponent(); parameter = System.Linq.Expressions.Expression.Parameter(typeof(Customer)); InitDate(); }