public static ConvertChecked ( |
||
expression | An |
|
type | Type | A |
return |
private UnaryExpression UnaryExpression( ExpressionType nodeType, System.Type type, JObject obj) { var operand = this.Prop(obj, "operand", this.Expression); var method = this.Prop(obj, "method", this.Method); switch (nodeType) { case ExpressionType.ArrayLength: return(Expr.ArrayLength(operand)); case ExpressionType.Convert: return(Expr.Convert(operand, type, method)); case ExpressionType.ConvertChecked: return(Expr.ConvertChecked(operand, type, method)); case ExpressionType.Decrement: return(Expr.Decrement(operand, method)); case ExpressionType.Increment: return(Expr.Increment(operand, method)); case ExpressionType.IsFalse: return(Expr.IsFalse(operand, method)); case ExpressionType.IsTrue: return(Expr.IsTrue(operand, method)); case ExpressionType.Negate: return(Expr.Negate(operand, method)); case ExpressionType.NegateChecked: return(Expr.NegateChecked(operand, method)); case ExpressionType.Not: return(Expr.Not(operand, method)); case ExpressionType.OnesComplement: return(Expr.OnesComplement(operand, method)); case ExpressionType.PostDecrementAssign: return(Expr.PostDecrementAssign(operand, method)); case ExpressionType.PostIncrementAssign: return(Expr.PostIncrementAssign(operand, method)); case ExpressionType.PreDecrementAssign: return(Expr.PreDecrementAssign(operand, method)); case ExpressionType.PreIncrementAssign: return(Expr.PreIncrementAssign(operand, method)); case ExpressionType.Quote: return(Expr.Quote(operand)); case ExpressionType.Throw: return(Expr.Throw(operand, type)); case ExpressionType.TypeAs: return(Expr.TypeAs(operand, type)); case ExpressionType.UnaryPlus: return(Expr.UnaryPlus(operand, method)); case ExpressionType.Unbox: return(Expr.Unbox(operand, type)); default: throw new NotSupportedException(); } }
private Expression <Func <TBaseInput, TBaseResult> > CreatePolymorphicExpression() { // Objective: // x is [Mapping.InputType] ? // ([TResult]) [Mapping.MapperExpression { ([Mapping1.InputType]) x }] // : [Next Mapping OR default] var inputParameter = LinqExpression.Parameter(typeof(TBaseInput), "x"); var conditionalUnits = new List <(LinqExpression condition, LinqExpression expression)>(); foreach (var entry in _mapping.Entries) { var mappingExpression = entry.ExpressionGetter(); // (<Mapping.InputType>) x var castedParameter = LinqExpression.ConvertChecked(inputParameter, entry.InputType); // x is <Mapping.InputType> var condition = LinqExpression.TypeIs(inputParameter, entry.InputType); // Mapper((<Mapping.InputType>) x) var expression = MapperInliningOperations.InlineMapperExpression(mappingExpression, castedParameter, false); // This cast is needed to make the ternary work. // (TResult) Mapper((<Mapping.InputType>) x) expression = LinqExpression.ConvertChecked(expression, typeof(TBaseResult)); conditionalUnits.Add((condition, expression)); } // Traverse the units in reverse, we stack up the expressions as we go. LinqExpression?finalExpression = null; for (var i = conditionalUnits.Count - 1; i >= 0; i--) { var(condition, expression) = conditionalUnits[i]; finalExpression = LinqExpression.Condition(condition, expression, finalExpression ?? MakeDefaultExpression.For(typeof(TBaseResult))); } return(LinqExpression.Lambda <Func <TBaseInput, TBaseResult> >(finalExpression !, inputParameter)); }
public void UnaryExpression_ConvertChecked() => ExecuteBinaryExpr(Property.Active, active => Expr.ConvertChecked(active, typeof(int)), ExpressionType.ConvertChecked);
public static UnaryExpression ConvertChecked(Expression expression, Type type) => Expression.ConvertChecked(expression, type); // NB: Never binds to overload with MethodInfo parameter.