public static Convert ( |
||
expression | An |
|
type | Type | A |
Résultat |
Expression ReplaceParameter(IDictionary<Expression,Expression> expressionAccessors, Expression expression, Action<string> setName) { return expression.Convert(expr => { if (expr.NodeType == ExpressionType.Constant) { var c = (ConstantExpression)expr; if (!ExpressionHelper.IsConstant(expr.Type) || _asParameters.Contains(c)) { var val = expressionAccessors[expr]; expr = Expression.Convert(val, expr.Type); if (expression.NodeType == ExpressionType.MemberAccess) { var ma = (MemberExpression)expression; setName(ma.Member.Name); } } } return expr; }); }
private static Func <object, object, object> CreateFunc(string program) { var assemblyName = new AssemblyName(Guid.NewGuid().ToString()) { Version = new Version(1, 0) }; AssemblyBuilder assemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.Run); ModuleBuilder moduleBuilder = assemblyBuilder.DefineDynamicModule("Program"); ParameterExpression valueParameter = Expression.Parameter(typeof(object), "value"); ParameterExpression parameterParameter = Expression.Parameter(typeof(object), "parameter"); AstHelper astHelper = AstHelper.Default(moduleBuilder); astHelper.Variables.Add("value", valueParameter); astHelper.Variables.Add("parameter", parameterParameter); Expression rootExpression = ProgramExpression.Compile(astHelper, program); Expression <Func <object, object, object> > lambda = Expression.Lambda <Func <object, object, object> >(Expression.Convert(rootExpression, typeof(object)), valueParameter, parameterParameter); return(lambda.Compile()); }
// Pseudocode: //string input => //{ // R result = 0; // for (int i = input.Length - 1; i >= 0; i--) // { // result <<= 6; // var m = _invMap[input[i]]; // if (m == 0xff) // return default(ConversionResult<R>); // result += m; // } // return new ConversionResult<R>(result); //} private LambdaExpression fromLambda(Type to) { var stringthis = typeof(string).GetTypeInfo().DeclaredProperties.First(p => p.GetIndexParameters().Length == 1 && p.GetIndexParameters()[0].ParameterType == typeof(int)); var input = Ex.Parameter(typeof(string), "input"); var result = Ex.Parameter(to, "result"); var i = Ex.Parameter(typeof(int), "i"); var m = Ex.Parameter(typeof(byte), "m"); var loopstart = Ex.Label("loopstart"); var end = Ex.Label(typeof(ConversionResult <>).MakeGenericType(to), "end"); var loop = Ex.Block( Ex.Label(loopstart), Ex.IfThen(Ex.MakeBinary(ExpressionType.LessThan, i, Ex.Constant(0)), Ex.Goto(end, Result(to, result))), Ex.LeftShiftAssign(result, Ex.Constant(6)), Ex.Assign(m, Ex.ArrayIndex(Ex.Constant(_invMap), Ex.Convert(Ex.MakeIndex(input, stringthis, new[] { i }), typeof(int)))), Ex.IfThen(Ex.MakeBinary(ExpressionType.Equal, m, Ex.Constant((byte)0xff)), Ex.Goto(end, NoResult(to))), Ex.AddAssign(result, Ex.Convert(m, result.Type)), Ex.PostDecrementAssign(i), Ex.Goto(loopstart)); var block = Ex.Block(new[] { result, i, m }, Ex.Assign(result, Ex.Convert(Ex.Constant(0), to)), Ex.Assign(i, Ex.MakeBinary(ExpressionType.Subtract, Ex.Property(input, nameof(string.Length)), Ex.Constant(1))), loop, Ex.Label(end, NoResult(to))); return(Ex.Lambda(block, input)); }
internal bool AddSplattedArgumentTest(object value, Expression /*!*/ expression, out int listLength, out ParameterExpression /*!*/ listVariable) { if (value == null) { AddRestriction(Ast.Equal(expression, Ast.Constant(null))); } else { // test exact type: AddTypeRestriction(value.GetType(), expression); List <object> list = value as List <object>; if (list != null) { Type type = typeof(List <object>); listLength = list.Count; listVariable = GetTemporary(type, "#list"); AddCondition(Ast.Equal( Ast.Property(Ast.Assign(listVariable, Ast.Convert(expression, type)), type.GetProperty("Count")), Ast.Constant(list.Count)) ); return(true); } } listLength = -1; listVariable = null; return(false); }
public static Expression Call(ProcedureCall call) { if (ReferenceEquals(call, null)) { throw new ArgumentNullException(nameof(call)); } var services = Services.Instance; var procedure = services.GetProcedureSignature(call); if (!procedure.HasReturnType) { throw new InvalidOperationException( "Cannot use a procedure that does not return a value."); } var arguments = services.GetArguments(procedure, call.Arguments); var servicesExpr = LinqExpression.Constant(services); var executeCallMethod = typeof(Services).GetMethod( "ExecuteCall", new[] { typeof(Scanner.ProcedureSignature), typeof(object[]) }); var procedureExpr = LinqExpression.Constant(procedure); var argumentsExpr = LinqExpression.Constant(arguments); var result = LinqExpression.Call( servicesExpr, executeCallMethod, new[] { procedureExpr, argumentsExpr }); var value = LinqExpression.Convert( LinqExpression.Property(result, "Value"), procedure.ReturnType); return(new Expression(value)); }
/// <summary> /// Transform as expression (value is read). /// </summary> protected internal override MAst Transform() { if (_innerExpression.Type == typeof(string)) { Expression <Func <string, bool> > result = str => !string.IsNullOrEmpty(str); MAst arg = _innerExpression.Transform(); UnaryExpression converted = arg.Convert <string>(); return(result.eInvoke(converted)); } else if (_innerExpression.Type.IsValueType) { var zero = (ValueType)(Activator.CreateInstance(_innerExpression.Type)); return(MAst.NotEqual(_innerExpression.Transform(), MAst.Constant(zero, _innerExpression.Type))); } else if (_innerExpression.Type == typeof(Null)) { return(MAst.Constant(false, typeof(bool))); } else { Expression <Func <object, bool> > result = o => (o != null); MAst arg = _innerExpression.Transform(); UnaryExpression converted = arg.Convert <object>(); return(result.eInvoke(converted)); } }
public static Expression Power(Expression arg0, Expression arg1) { var arg0b = LinqExpression.Convert(arg0, typeof(double)); var arg1b = LinqExpression.Convert(arg1, typeof(double)); return(new Expression(LinqExpression.Convert(LinqExpression.Power(arg0b, arg1b), arg0.Type))); }
private static TSetLambda CreateSetter <TGetLambda, TSetLambda>( this Expression <TGetLambda> getter, Type propertyType) { var memberExpression = (MemberExpression)getter.Body; var property = (PropertyInfo)memberExpression.Member; var setMethod = property.GetSetMethod(); if (setMethod == null) { return(default(TSetLambda)); } var parameterValue = Expression.Parameter(propertyType); var callParameter = Equals(propertyType, memberExpression.Type) ? (Expression)parameterValue : Expression.Convert(parameterValue, memberExpression.Type); var newExpression = Expression.Lambda <TSetLambda>( Expression.Call(memberExpression.Expression, setMethod, callParameter), getter.Parameters.Concat(new[] { parameterValue }) ); return(newExpression.Compile()); }
private static Accessor GetAccessor <TAttribute>(Type targetType) where TAttribute : Attribute { Accessor accessor; var cache = GetCache <TAttribute>(); if (cache.TryGetValue(targetType, out accessor)) { return(accessor); } var member = FindMember <TAttribute>(targetType); if (member == null) { cache[targetType] = NullCallback; return(NullCallback); } var targetParameter = E.Parameter(typeof(object), "target"); var accessorExpression = E.Lambda <Accessor>( E.Convert( E.MakeMemberAccess( E.Convert(targetParameter, targetType), member), typeof(object)), targetParameter); accessor = accessorExpression.Compile(); cache[targetType] = accessor; return(accessor); }
protected override ExpressionBody Transform(Ast.LambdaExpression lmx) { var parameters = lmx.Parameters.Select(px => Tuple.Create(px, LX.Parameter(typeof(LogEventPropertyValue), px.ParameterName))).ToList(); var paramSwitcher = new ExpressionConstantMapper(parameters.ToDictionary(px => (object)px.Item1, px => (System.Linq.Expressions.Expression)px.Item2)); var rewritten = paramSwitcher.Visit(Transform(lmx.Body)); Type delegateType; if (lmx.Parameters.Length == 1) { delegateType = typeof(Func <LogEventPropertyValue, LogEventPropertyValue>); } else if (lmx.Parameters.Length == 2) { delegateType = typeof(Func <LogEventPropertyValue, LogEventPropertyValue, LogEventPropertyValue>); } else { throw new NotSupportedException("Unsupported lambda signature."); } var lambda = LX.Lambda(delegateType, rewritten !, parameters.Select(px => px.Item2).ToArray()); // Unfortunately, right now, functions need to be threaded through in constant scalar values :-D return(LX.New(typeof(ScalarValue).GetConstructor(new[] { typeof(object) }) !, LX.Convert(lambda, typeof(object)))); }
public LambdaExpression CreateLambda(Type from, Type to) { var input = Ex.Parameter(from, "input"); var fromInfo = infos[from]; var toInfo = infos[to]; if (fromInfo <= toInfo) // Can make use of an implicit conversion { var block = Result(to, Ex.Convert(input, to)); var lambda = Ex.Lambda(block, input); return(lambda); } else // Cannot make use of an implicit conversion, bounds must be checked. Precision might be lost. { var block = Ex.Condition( Ex.MakeBinary(Et.AndAlso, Ex.MakeBinary(Et.GreaterThanOrEqual, input, Ex.Convert(Ex.Constant(toInfo.MinValue), from)), Ex.MakeBinary(Et.LessThanOrEqual, input, Ex.Convert(Ex.Constant(toInfo.MaxValue), from))), Result(to, Ex.Convert(input, to)), NoResult(to)); var lambda = Ex.Lambda(block, input); return(lambda); } }
private LambdaExpression toDictLambda(Type from, Type to) { var valueType = recordCreator.GetValueType(to); var recType = typeof(IRecord <>).MakeGenericType(valueType); var set = recType.GetTypeInfo().GetDeclaredMethod(nameof(IRecord <object> .SetValue)); var input = Ex.Parameter(from, "input"); var tmp = Ex.Parameter(typeof(ConversionResult <>).MakeGenericType(valueType), "tmp"); var res = Ex.Parameter(typeof(IDictionary <,>).MakeGenericType(typeof(string), valueType), "res"); var rec = Ex.Parameter(recType, "rec"); var getters = GetReadablePropertiesForType(from); var converters = getters.Select(g => Ref.GetLambda(g.PropertyType, valueType)); var end = Ex.Label(typeof(ConversionResult <>).MakeGenericType(to)); var block = Ex.Block(new[] { tmp, res, rec }, Ex.Assign(res, Ex.New(GetParameterlessConstructor(to))), Ex.Assign(rec, recordCreator.Creator(to).ApplyTo(res)), Ex.IfThen(Ex.MakeBinary(ExpressionType.Equal, rec, Ex.Default(rec.Type)), Ex.Goto(end, NoResult(to))), Ex.Block(getters.Zip(converters, (g, c) => new { g, c }) .Select(x => Ex.Block( Ex.Assign(tmp, x.c.ApplyTo(Ex.Property(input, x.g))), Ex.IfThenElse(Ex.Property(tmp, nameof(IConversionResult.IsSuccessful)), Ex.Call(rec, set, Ex.Constant(x.g.Name), Ex.Property(tmp, nameof(IConversionResult.Result))), Ex.Goto(end, NoResult(to)))))), Ex.Label(end, Result(to, Ex.Convert(res, to)))); return(Ex.Lambda(block, input)); }
static GlyphRunFormatter() { var refType = typeof(CharacterBufferReference); _textFormattingMode = typeof(GlyphRun).GetField("_textFormattingMode", BindingFlags.NonPublic | BindingFlags.Instance); { var property = refType.GetProperty("CharacterBuffer", BindingFlags.NonPublic | BindingFlags.Instance); var param0 = Expr.Parameter(refType); var expr = Expr.Convert(Expr.Property(param0, property), typeof(IList <char>)); var lambda = Expr.Lambda <Func <CharacterBufferReference, IList <char> > >(expr, param0); getCharBuf = lambda.Compile(); } { var property = refType.GetProperty("OffsetToFirstChar", BindingFlags.NonPublic | BindingFlags.Instance); var param0 = Expr.Parameter(refType); var expr = Expr.Property(param0, property); var lambda = Expr.Lambda <Func <CharacterBufferReference, int> >(expr, param0); getCharOffset = lambda.Compile(); } { var ctor = typeof(TextBounds).GetConstructors(BindingFlags.NonPublic | BindingFlags.Instance)[0]; var param0 = Expr.Parameter(typeof(Rect)); var expr = Expr.New(ctor, param0, Expr.Constant(FlowDirection.LeftToRight), Expr.Constant(null, typeof(IList <TextRunBounds>))); var lambda = Expr.Lambda <Func <Rect, TextBounds> >(expr, param0); makeBounds = lambda.Compile(); } }
private object CastResult(object result, Type targetType) { if (result == null || result == DependencyProperty.UnsetValue || result == System.Windows.Data.Binding.DoNothing || targetType == null || targetType == typeof(object)) { return(result); } if (targetType == typeof(string)) { return(result.ToString()); } Func <object, object> cast; if (!castFunctions.TryGetValue(targetType, out cast)) { ParameterExpression par = Expression.Parameter(typeof(object)); cast = Expression.Lambda <Func <object, object> >(Expression.Convert(Expression.Dynamic(Binder.Convert(CSharpBinderFlags.ConvertExplicit, targetType, typeof(object)), targetType, par), typeof(object)), par).Compile(); castFunctions.TryAdd(targetType, cast); } if (cast != null) { try { result = cast(result); } catch { castFunctions[targetType] = null; } } return(result); }
/// <summary> /// Returns node's value for the given context. /// </summary> /// <param name="context">Object to evaluate node against.</param> /// <param name="variables">Expression variables map.</param> /// <returns>Node's value.</returns> public object GetValue(object context, IDictionary <string, object> variables) { // todo: oczywiœcie ten lock jest z dupy... // lock (this) { if (_compiledExpression == null) { if (_lastEvaluationContext != null) { _lastEvaluationContext.Reuse(context, variables); } else { _lastEvaluationContext = new EvaluationContext(context, variables); } // todo: zapamiêtujemy zbudowane expression! // todo: zapamiêtujemy funkcjê, która dostaje na ryja obecta! z contextem! // todo: i go rzutuje! LExpression getContextExpression; var ctxParam = LExpression.Parameter(typeof(object), "context"); if (context == null) { getContextExpression = LExpression.Constant(null); } else { getContextExpression = LExpression.Convert(ctxParam, context.GetType()); } var getEvalContextExpression = LExpression.Parameter( typeof(EvaluationContext), "evalContext"); var exp = GetExpressionTreeIfPossible(getContextExpression, getEvalContextExpression); exp = LExpression.Convert(exp, typeof(object)); //var convExp = System.Linq.Expressions.Expression.Convert(expr, typeof(object)); Expression <Func <object, EvaluationContext, object> > lambda = LExpression.Lambda <Func <object, EvaluationContext, object> >(exp, ctxParam, getEvalContextExpression); // no i co dalej... jak // todo: co z lastEvaluationContext? mo¿e nie jest potrzebny? oto jest pytanie! // todo: mo¿emy go tutaj przekazaæ... albo po prostu utworzyæ w œrodku... // todo: pytanie, czy mo¿emy do na rz¹danie utworzyæ? kurde... raczej nie... _compiledExpression = lambda.Compile(); } return(_compiledExpression(context, _lastEvaluationContext)); // todo: jeœli siê coœ wyjeba³o albo null, to oczywiœcie wychodzimy i jedziemy star¹, woln¹ œcie¿k¹.... return(Get(context, _lastEvaluationContext)); } }
static Expression ToBool(DynamicMetaObject target) { if (target.LimitType == typeof(bool)) { return(Expr.Convert(target.Expression, typeof(bool))); } return(Expr.NotEqual(target.Expression, Expr.Constant(null))); }
public LambdaExpression CreateLambda(Type from, Type to) { var input = Ex.Parameter(from, "input"); var block = Result(to, Ex.Convert(input, to)); var lambda = Ex.Lambda(block, input); return(lambda); }
public override SysExpr ToExpression() { if (NodeType == ExpressionType.Convert) { return(SysExpr.Convert(Operand.ToExpression(), Type)); } throw new NotSupportedException("Cannot convert Expression to Expression of type " + NodeType); }
/// <summary> /// Creates a function that accepts 0 parameters and returns an untyped result /// </summary> /// <param name="Host">The declaring type instance, if applicable</param> /// <returns></returns> public Func <object> Func0(object Host = null) { var instance = Host != null?XPR.Constant(Host) : default(XPR); var result = XPR.Convert(XPR.Call(instance, this), typeof(object)); return(XPR.Lambda <Func <object> >(result).Compile()); }
private static Expression <Func <T, object> > ToLambda <T>(string propertyName) { var parameter = Expression.Parameter(typeof(T)); var property = Expression.Property(parameter, propertyName); var propAsObject = Expression.Convert(property, typeof(object)); return(Expression.Lambda <Func <T, object> >(propAsObject, parameter)); }
private static Func <PluginMetadata, object> MakeCreateFunc(Type type, string name) { // TODO: what do i want the visibiliy of Init methods to be? var ctors = type.GetConstructors(BindingFlags.Public | BindingFlags.Instance) .Select(c => (c, attr: c.GetCustomAttribute <InitAttribute>())) .NonNull(t => t.attr) .OrderByDescending(t => t.c.GetParameters().Length) .Select(t => t.c).ToArray(); if (ctors.Length > 1) { Logger.loader.Warn($"Plugin {name} has multiple [Init] constructors. Picking the one with the most parameters."); } bool usingDefaultCtor = false; var ctor = ctors.FirstOrDefault(); if (ctor == null) { // this is a normal case usingDefaultCtor = true; ctor = type.GetConstructor(Type.EmptyTypes); if (ctor == null) { throw new InvalidOperationException($"{type.FullName} does not expose a public default constructor and has no constructors marked [Init]"); } } var initMethods = type.GetMethods(BindingFlags.Public | BindingFlags.Instance) .Select(m => (m, attr: m.GetCustomAttribute <InitAttribute>())) .NonNull(t => t.attr).Select(t => t.m).ToArray(); // verify that they don't have lifecycle attributes on them foreach (var method in initMethods) { var attrs = method.GetCustomAttributes(typeof(IEdgeLifecycleAttribute), false); if (attrs.Length != 0) { throw new InvalidOperationException($"Method {method} on {type.FullName} has both an [Init] attribute and a lifecycle attribute."); } } var metaParam = Expression.Parameter(typeof(PluginMetadata), "meta"); var objVar = ExpressionEx.Variable(type, "objVar"); var persistVar = ExpressionEx.Variable(typeof(object), "persistVar"); var createExpr = Expression.Lambda <Func <PluginMetadata, object> >( ExpressionEx.Block(new[] { objVar, persistVar }, initMethods .Select(m => PluginInitInjector.InjectedCallExpr(m.GetParameters(), metaParam, persistVar, es => Expression.Call(objVar, m, es))) .Prepend(ExpressionEx.Assign(objVar, usingDefaultCtor ? Expression.New(ctor) : PluginInitInjector.InjectedCallExpr(ctor.GetParameters(), metaParam, persistVar, es => Expression.New(ctor, es)))) .Append(Expression.Convert(objVar, typeof(object)))), metaParam); // TODO: since this new system will be doing a f**k load of compilation, maybe add FastExpressionCompiler return(createExpr.Compile()); }
/// <summary> /// Creates a function that accepts 3 untyped parameters and returns an untyped result /// </summary> /// <param name="Host">The declaring type instance, if applicable</param> /// <returns></returns> public Func <object, object, object, object> Func3(object Host = null) { var instance = Host != null?XPR.Constant(Host) : default; var callResult = XPR.Call(null, this, ArgumentExpressions); var result = XPR.Convert(callResult, typeof(object)); return(XPR.Lambda <Func <object, object, object, object> >(result, GetParameters(3)).Compile()); }
public void BinaryExpression_Power() { ExecuteBinaryExpr(Property.Id, id => { var pow = Expr.Convert(Expr.Power(Expr.Convert(id, typeof(double)), Expr.Constant(2.0)), typeof(int)); return(pow); }, ExpressionType.Power); }
public TExPI(Expression ex) : base(ex) { id = Ex.Field(ex, "id"); t = Ex.Field(ex, "t"); loc = Ex.Field(ex, "loc"); locx = Ex.Field(loc, "x"); locy = Ex.Field(loc, "y"); index = Ex.Field(ex, "index"); findex = Ex.Convert(index, ExUtils.tfloat); }
private Expression <Func <object, object> > ToExpression(Type type) { var parameter = LinqExpression.Parameter(typeof(object)); var castedParameter = LinqExpression.Convert(parameter, type); var jsonpathExpr = Root.ToExpression(castedParameter); var castedResult = LinqExpression.Convert(jsonpathExpr, typeof(object)); var lambda = LinqExpression.Lambda <Func <object, object> >(castedResult, parameter); return(lambda); }
protected TExPI(ExMode m, string?name) : base(m, name) { id = Ex.Field(ex, "id"); t = Ex.Field(ex, "t"); loc = Ex.Field(ex, "loc"); locx = Ex.Field(loc, "x"); locy = Ex.Field(loc, "y"); index = Ex.Field(ex, "index"); findex = Ex.Convert(index, ExUtils.tfloat); }
private static RuleGenerator /*!*/ CreateGetter(int index) { return(delegate(MetaObjectBuilder /*!*/ metaBuilder, CallArguments /*!*/ args, string /*!*/ name) { metaBuilder.Result = Ast.Call( Ast.Convert(args.TargetExpression, typeof(RubyStruct)), typeof(RubyStruct).GetMethod("GetValue"), Ast.Constant(index) ); }); }
static ExpressionBody CompileLogical(Func <ExpressionBody, ExpressionBody, ExpressionBody> apply, ExpressionBody lhs, ExpressionBody rhs) { return(LX.Convert( LX.New( typeof(ScalarValue).GetConstructor(new[] { typeof(object) }) !, LX.Convert(apply( LX.Call(CoerceToScalarBooleanMethod, lhs), LX.Call(CoerceToScalarBooleanMethod, rhs)), typeof(object))), typeof(LogEventPropertyValue))); }
/// <inheritdoc/> protected override IEnumerable <Act> Query(Expression <Func <Act, bool> > query, Guid queryId, int offset, int count, out int totalResults) { var typeReference = Expression.MakeBinary(ExpressionType.Equal, Expression.Convert(Expression.MakeMemberAccess(query.Parameters[0], typeof(Act).GetProperty(nameof(Act.ClassConceptKey))), typeof(Guid)), Expression.Constant(ActClassKeys.Condition)); var anyRef = this.CreateConceptSetFilter(ConceptSetKeys.AdverseEventActs, query.Parameters[0]); query = Expression.Lambda <Func <Act, bool> >(Expression.AndAlso(Expression.AndAlso(query.Body, anyRef), typeReference), query.Parameters); return(base.Query(query, queryId, offset, count, out totalResults)); }
public static Func <object, object> FieldGet(this Type type, string fieldName) { var param = Expression.Parameter(typeof(object), "arg"); var paramCast = Expression.Convert(param, type); var member = Expression.Field(paramCast, fieldName); var memberCast = Expression.Convert(member, typeof(object)); var lambda = Expression.Lambda(memberCast, param); return((Func <object, object>)lambda.Compile()); }
/// <summary> /// Creates a functor for converting an object of the specified type to DynamoDBEntry /// </summary> private static Func <object, DynamoDBEntry> GetToDynamoDbEntryConversionFunctor(Type valueType) { // parameter, that represents input value var valueParameter = Expression.Parameter(typeof(object)); if (valueType.IsPrimitive()) { // first converting to a valueType (or to int, if it's an enum) var primitiveConversionExp = Expression.Convert(valueParameter, valueType.BaseType == typeof(Enum) ? typeof(int) : valueType); // then to Primitive | Since AWSSDK 2.3.2.0, conversion to DynamoDbEntry type now yields object of internal type UnconvertedDynamoDBEntry which is not derived from Primitive thus breaking Linq2DynamoDb primitiveConversionExp = Expression.Convert(primitiveConversionExp, typeof(Primitive)); return((Func <object, DynamoDBEntry>)Expression.Lambda(primitiveConversionExp, valueParameter).Compile()); } // now trying to create a routine for converting a collection Type elementType = null; bool isListOrArray = false; if (valueType.IsArray) { elementType = valueType.GetElementType(); isListOrArray = true; } else if (valueType.ImplementsInterface(typeof(ICollection <>))) { elementType = valueType.GetGenericArguments()[0]; isListOrArray = true; } if (isListOrArray) { if ( (elementType == null) || (!elementType.IsPrimitive()) ) { var toDynamoDbListMethodInfo = ((Func <object, Type, DynamoDBList>)ToDynamoDbList).Method; var toDynamoDbConversionExp = Expression.Call(toDynamoDbListMethodInfo, valueParameter, Expression.Constant(elementType)); return((Func <object, DynamoDBEntry>)Expression.Lambda(toDynamoDbConversionExp, valueParameter).Compile()); //throw new InvalidCastException(string.Format("Cannot convert type {0} to DynamoDbEntry", valueType)); } var toPrimitiveListMethodInfo = ((Func <object, Type, PrimitiveList>)ToPrimitiveList).Method; var conversionExp = Expression.Call(toPrimitiveListMethodInfo, valueParameter, Expression.Constant(elementType)); return((Func <object, DynamoDBEntry>)Expression.Lambda(conversionExp, valueParameter).Compile()); } var documentConvertor = GetEntityToDocumentConvertorFunctor(valueType); return(documentConvertor); }
public Expression BuildExpression(IParseContext context, Expression expression) { var newExpr = expression.Convert(pi => { switch (pi.NodeType) { case ExpressionType.MemberAccess: { if (IsSubQuery(context, pi)) return BuildSubQuery(context, pi); if (IsServerSideOnly(pi) || PreferServerSide(pi)) return BuildSql(context, pi); var ctx = GetContext(context, pi); if (ctx != null) return ctx.BuildExpression(pi, 0); var ma = (MemberExpression)pi; var ex = ma.Expression; /* if (query.Sources.Length > 0) { var field = query.GetBaseField(lambda, ma); if (field != null) { if (field is QueryField.Column) return BuildField(ma, field, converter); if (field is QuerySource.SubQuery) return BuildSubQuerySource(ma, (QuerySource.SubQuery)field, converter); if (field is QueryField.ExprColumn) { var col = (QueryField.ExprColumn)field; return BuildNewExpression(lambda, col.QuerySource, col.Expr, converter); } if (field is QuerySource.Table) return BuildTable(ma, (QuerySource.Table)field, null, converter); if (field is QueryField.SubQueryColumn) return BuildSubQuerySource(ma, (QueryField.SubQueryColumn)field, converter); if (field is QueryField.GroupByColumn) return BuildGroupBy(ma, (QueryField.GroupByColumn)field, converter); if (field is QuerySource.SubQuerySourceColumn) return BuildSubQuerySourceColumn(pi, (QuerySource.SubQuerySourceColumn)field, converter); throw new InvalidOperationException(); } //if (ex.Expr == expr.Expr && query is QuerySource.Scalar && ex.NodeType == ExpressionType.Constant) // return BuildField(lambda, query, ma); } else { var field = GetField(lambda, ma, query); if (field != null) return BuildField(ma, field, converter/*i => i/); } */ if (ex != null && ex.NodeType == ExpressionType.Constant) { // field = localVariable // var c = _expressionAccessors[ex]; return Expression.MakeMemberAccess(Expression.Convert(c, ex.Type), ma.Member); } break; } case ExpressionType.Parameter: { if (pi == ParametersParam) break; var ctx = GetContext(context, pi); if (ctx != null) return ctx.BuildExpression(pi, 0); throw new NotImplementedException(); /* if (query.Lambda != null && query.Lambda.MethodInfo != null && query.Lambda.MethodInfo.Name == "Select" && query.Lambda.Parameters.Length == 2 && query.Lambda.Parameters[1] == pi) { return Expression.MakeMemberAccess(_contextParam, QueryCtx.Counter); } var field = query.GetBaseField(lambda, pi); if (field != null) { //Func<FieldIndex,FieldIndex> conv = i => converter(query.EnsureField(i.Field).Select(this)[0]); if (field is QuerySource.Table) return BuildTable(pi, (QuerySource.Table)field, null, converter); if (field is QuerySource.Scalar) { var source = (QuerySource)field; return BuildNewExpression(lambda, source, source.Lambda.Body, converter); } if (field is QuerySource.Expr) { var source = (QuerySource)field; return BuildQuerySourceExpr(query, source.Lambda.Body, converter); } if (field is QuerySource.GroupJoin) return BuildGroupJoin(pi, (QuerySource.GroupJoin)field, converter); if (field is QuerySource.SubQuery) return BuildSubQuerySource(pi, (QuerySource.SubQuery)field, converter); if (field is QuerySource.SubQuerySourceColumn) return BuildSubQuerySourceColumn(pi, (QuerySource.SubQuerySourceColumn)field, converter); throw new InvalidOperationException(); } //if (query.Lambda == null && query is QuerySource.SubQuerySourceColumn) //{ // return BuildSubQuerySourceColumn(pi, (QuerySource.SubQuerySourceColumn)query, converter); //} break; */ } case ExpressionType.Constant: { if (ExpressionHelper.IsConstant(pi.Type)) break; if (_expressionAccessors.ContainsKey(pi)) return Expression.Convert(_expressionAccessors[pi], pi.Type); throw new NotImplementedException(); /* if (query.Sources.Length == 0) { var field = GetField(lambda, pi, query); if (field != null) { var idx = field.Select(this); return BuildField(pi, field.GetExpressions(this)[0], idx.Select(i => converter(i).Index).ToArray()); } } if (query is QuerySource.Scalar && CurrentSql.Select.Columns.Count == 0 && expr == pi) return BuildField(lambda, query.BaseQuery, pi, converter); if (query is QuerySource.SubQuerySourceColumn) return BuildSubQuerySourceColumn(pi, (QuerySource.SubQuerySourceColumn)query, converter); return Expression.Convert(ExpressionAccessors[pi], pi.Type); */ } case ExpressionType.Coalesce: if (pi.Type == typeof(string) && MappingSchema.GetDefaultNullValue<string>() != null) return BuildSql(context, pi); if (CanBeTranslatedToSql(context, pi, true)) return BuildSql(context, pi); break; case ExpressionType.Conditional: if (CanBeTranslatedToSql(context, pi, true)) return BuildSql(context, pi); break; case ExpressionType.Call: { var ce = (MethodCallExpression)pi; var cm = ConvertMethod(ce); if (cm != null) if (ce.Method.GetCustomAttributes(typeof(MethodExpressionAttribute), true).Length != 0) return BuildExpression(context, cm); if (IsSubQuery(context, pi)) return BuildSubQuery(context, pi); if (IsServerSideOnly(pi) || PreferServerSide(pi)) return BuildSql(context, pi); } break; } if (EnforceServerSide(context)) { switch (pi.NodeType) { case ExpressionType.MemberInit: case ExpressionType.New: case ExpressionType.Convert: break; default: if (CanBeCompiled(pi)) break; return BuildSql(context, pi); } } return pi; }); return newExpr; }
internal static Expression ConvertValue(ITypeName typeName, Expression expr) { Type reflectionType = typeName.GetReflectionType(); if (reflectionType == null) { return Expression.Dynamic(PSDynamicConvertBinder.Get(), typeof(object), Expression.Call(CachedReflectionInfo.TypeOps_ResolveTypeName, Expression.Constant(typeName)), expr); } if (reflectionType.Equals(typeof(void))) { return Expression.Block(typeof(void), new Expression[] { expr }); } return expr.Convert(reflectionType); }
Expression IAssignableValue.SetValue(Compiler compiler, Expression rhs) { IEnumerable<PropertyInfo> enumerable; bool flag; if (this.VariablePath.IsVariable && this.VariablePath.UnqualifiedPath.Equals("null", StringComparison.OrdinalIgnoreCase)) { return rhs; } Type type = this.GetVariableType(compiler, out enumerable, out flag); Type type2 = rhs.Type; if ((flag && (type.Equals(typeof(object)) || type.Equals(typeof(PSObject)))) && (type2.Equals(typeof(object)) || type2.Equals(typeof(PSObject)))) { rhs = Expression.Dynamic(PSVariableAssignmentBinder.Get(), typeof(object), rhs); } rhs = rhs.Convert(type); if (!flag) { return Compiler.CallSetVariable(Expression.Constant(this.VariablePath), rhs, null); } Expression localVariablesParameter = compiler.LocalVariablesParameter; foreach (PropertyInfo info in enumerable) { localVariablesParameter = Expression.Property(localVariablesParameter, info); } return Expression.Assign(localVariablesParameter, rhs); }
Expression BuildSubQuery(IParseContext context, Expression expression) { if (expression.NodeType == ExpressionType.MemberAccess) { var ma = (MemberExpression)expression; if (ma.Expression != null) { switch (ma.Expression.NodeType) { case ExpressionType.Call : case ExpressionType.MemberAccess : case ExpressionType.Parameter : { var ctx = GetSubQuery(context, ma.Expression); var ex = expression.Convert(e => e == ma.Expression ? Expression.Constant(null, ma.Expression.Type) : e); var sql = ctx.ConvertToSql(ex, 0, ConvertFlags.Field); if (sql.Length != 1) throw new NotImplementedException(); //ctx.SqlQuery.Select.Columns.Clear(); ctx.SqlQuery.Select.Add(sql[0].Sql); var idx = context.SqlQuery.Select.Add(ctx.SqlQuery); return BuildSql(expression.Type, idx); } } } } var sequence = GetSubQuery(context, expression); return sequence.BuildExpression(null, 0); throw new NotImplementedException(); /* ParentQueries.Insert(0, new ParentQuery { Parent = query.BaseQuery, Parameter = query.Lambda.Parameters[0]}); var sql = CurrentSql; CurrentSql = new SqlQuery { ParentSql = sql }; var prev = _isSubQueryParsing; _isSubQueryParsing = true; var seq = ParseSequence(expr)[0]; _isSubQueryParsing = prev; if (seq.Fields.Count == 1 && CurrentSql.Select.Columns.Count == 0) seq.Fields[0].Select(this); var column = new QueryField.ExprColumn(query, CurrentSql, null); query.Fields.Add(column); var idx = column.Select(this); var result = BuildField(expr, column.GetExpressions(this)[0], idx.Select(i => converter(i).Index).ToArray()); CurrentSql = sql; ParentQueries.RemoveAt(0); ParsingTracer.DecIndentLevel(); return result; */ }
ISqlExpression ParseSubQuery(IParseContext context, Expression expression) { if (expression.NodeType == ExpressionType.MemberAccess) { var ma = (MemberExpression)expression; if (ma.Expression != null) { switch (ma.Expression.NodeType) { case ExpressionType.Call : case ExpressionType.MemberAccess : case ExpressionType.Parameter : { var ctx = GetSubQuery(context, ma.Expression); var ex = expression.Convert(e => e == ma.Expression ? Expression.Constant(null, ma.Expression.Type) : e); var sql = ctx.ConvertToSql(ex, 0, ConvertFlags.Field); if (sql.Length != 1) throw new NotImplementedException(); ctx.SqlQuery.Select.Add(sql[0].Sql); var idx = context.SqlQuery.Select.Add(ctx.SqlQuery); return context.SqlQuery.Select.Columns[idx]; } } } } var sequence = GetSubQuery(context, expression); /* if (expr.NodeType == ExpressionType.Call) { var call = (MethodCallExpression)expr; if (call.Method.Name == "Any" && (call.Method.DeclaringType == typeof(Queryable) || call.Method.DeclaringType == typeof(Enumerable))) return ((SqlQuery.Predicate.FuncLike) result.Where.SearchCondition.Conditions[0].Predicate).Function; } */ return sequence.SqlQuery; }
public Expression BuildExpression(IBuildContext context, Expression expression) { var newExpr = expression.Convert(pi => { switch (pi.NodeType) { case ExpressionType.MemberAccess: { if (IsServerSideOnly(pi) || PreferServerSide(pi)) return BuildSql(context, pi); var ma = (MemberExpression)pi; if (ConvertMember(ma.Member) != null) break; var ctx = GetContext(context, pi); if (ctx != null) return ctx.BuildExpression(pi, 0); var ex = ma.Expression; if (ex != null && ex.NodeType == ExpressionType.Constant) { // field = localVariable // var c = _expressionAccessors[ex]; return Expression.MakeMemberAccess(Expression.Convert(c, ex.Type), ma.Member); } break; } case ExpressionType.Parameter: { if (pi == ParametersParam) break; var ctx = GetContext(context, pi); if (ctx != null) return ctx.BuildExpression(pi, 0); throw new NotImplementedException(); } case ExpressionType.Constant: { if (ExpressionHelper.IsConstant(pi.Type)) break; if (_expressionAccessors.ContainsKey(pi)) return Expression.Convert(_expressionAccessors[pi], pi.Type); throw new NotImplementedException(); } case ExpressionType.Coalesce: if (pi.Type == typeof(string) && MappingSchema.GetDefaultNullValue<string>() != null) return BuildSql(context, pi); if (CanBeTranslatedToSql(context, ConvertExpression(pi), true)) return BuildSql(context, pi); break; case ExpressionType.Conditional: if (CanBeTranslatedToSql(context, ConvertExpression(pi), true)) return BuildSql(context, pi); break; case ExpressionType.Call: { var ce = (MethodCallExpression)pi; var cm = ConvertMethod(ce); if (cm != null) if (ce.Method.GetCustomAttributes(typeof(MethodExpressionAttribute), true).Length != 0) return BuildExpression(context, cm); if (IsSubQuery(context, ce)) return GetSubQuery(context, ce).BuildExpression(null, 0); if (IsServerSideOnly(pi) || PreferServerSide(pi)) return BuildSql(context, pi); } break; } if (EnforceServerSide(context)) { switch (pi.NodeType) { case ExpressionType.MemberInit: case ExpressionType.New: case ExpressionType.Convert: break; default: if (CanBeCompiled(pi)) break; return BuildSql(context, pi); } } return pi; }); return newExpr; }
internal static Expression ConvertValue(TypeConstraintAst typeConstraint, Expression expr) { var typeName = typeConstraint.TypeName; var toType = typeName.GetReflectionType(); if (toType != null) { if (toType == typeof(void)) { return Expression.Block(typeof(void), expr); } return expr.Convert(toType); } // typeName can't be resolved at compile time, so defer resolution until runtime. return DynamicExpression.Dynamic(PSDynamicConvertBinder.Get(), typeof(object), Expression.Call(CachedReflectionInfo.TypeOps_ResolveTypeName, Expression.Constant(typeName), Expression.Constant(typeName.Extent)), expr); }