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();
}
