C# Expression.Cast方法代碼示例

 internal static Expression InvokeConverter(LanguagePrimitives.ConversionData conversion, Expression value, Type resultType, bool debase, Expression formatProvider)
 {
     Expression expression;
     if ((conversion.Rank == ConversionRank.Identity) || (conversion.Rank == ConversionRank.Assignable))
     {
         expression = debase ? Expression.Call(CachedReflectionInfo.PSObject_Base, value) : value;
     }
     else
     {
         Expression expression2;
         Expression nullPSObject;
         if (debase)
         {
             expression2 = Expression.Call(CachedReflectionInfo.PSObject_Base, value);
             nullPSObject = value.Cast(typeof(PSObject));
         }
         else
         {
             expression2 = value.Cast(typeof(object));
             nullPSObject = ExpressionCache.NullPSObject;
         }
         expression = Expression.Call(Expression.Constant(conversion.Converter), conversion.Converter.GetType().GetMethod("Invoke"), new Expression[] { expression2, Expression.Constant(resultType), ExpressionCache.Constant(true), nullPSObject, formatProvider, ExpressionCache.NullTypeTable });
     }
     if (expression.Type.Equals(resultType) || resultType.Equals(typeof(LanguagePrimitives.InternalPSCustomObject)))
     {
         return expression;
     }
     if (resultType.IsValueType && (Nullable.GetUnderlyingType(resultType) == null))
     {
         return Expression.Unbox(expression, resultType);
     }
     return Expression.Convert(expression, resultType);
 }

 internal static Expression InvokeToString(Expression context, Expression target)
 {
     if (target.Type.Equals(typeof(string)))
     {
         return target;
     }
     return Expression.Call(CachedReflectionInfo.PSObject_ToStringParser, context.Cast(typeof(ExecutionContext)), target.Cast(typeof(object)));
 }

 private Expression SafeIndexResult(Expression expr)
 {
     ParameterExpression variable = Expression.Parameter(typeof(Exception));
     return Expression.TryCatch(expr.Cast(typeof(object)), new CatchBlock[] { Expression.Catch(variable, Expression.Block(Expression.Call(CachedReflectionInfo.CommandProcessorBase_CheckForSevereException, variable), Expression.IfThen(Compiler.IsStrictMode(3, null), Expression.Rethrow()), this.GetNullResult())) });
 }

 internal static Expression CallSetVariable(Expression variablePath, Expression rhs, Expression attributes = null)
 {
     return Expression.Call(CachedReflectionInfo.VariableOps_SetVariableValue,
                            variablePath, rhs.Cast(typeof(object)), _executionContextParameter,
                            attributes ?? ExpressionCache.NullConstant.Cast(typeof(AttributeAst[])));
 }

 public Expression GenerateCallContains(Expression lhs, Expression rhs, bool ignoreCase)
 {
     return Expression.Call(
         CachedReflectionInfo.ParserOps_ContainsOperatorCompiled,
         _executionContextParameter,
         Expression.Constant(CallSite<Func<CallSite, object, IEnumerator>>.Create(PSEnumerableBinder.Get())),
         Expression.Constant(CallSite<Func<CallSite, object, object, object>>.Create(
             PSBinaryOperationBinder.Get(ExpressionType.Equal, ignoreCase, scalarCompare: true))),
         lhs.Cast(typeof(object)),
         rhs.Cast(typeof(object)));
 }

        internal Expression CallAddPipe(Expression expr, Expression pipe)
        {
            if (!PSEnumerableBinder.IsStaticTypePossiblyEnumerable(expr.Type))
            {
                return Expression.Call(pipe, CachedReflectionInfo.Pipe_Add, expr.Cast(typeof(object)));
            }

            return DynamicExpression.Dynamic(PSPipeWriterBinder.Get(), typeof(void), expr, pipe, _executionContextParameter);
        }

 internal static Expression ConvertStringToNumber(Expression expr, Type toType)
 {
     if (!toType.IsNumeric())
     {
         toType = typeof(int);
     }
     return Expression.Call(CachedReflectionInfo.Parser_ScanNumber, expr.Cast(typeof(string)), Expression.Constant(toType));
 }

 public ArgumentsWrap(bool isNewArray, Expression[] args)
 {
     _isNewArray = isNewArray;
     var invalid = args.FirstOrDefault(x => !(x is IEvaluatesToString));
     if (invalid != null)
         throw new InvalidExpressionInRpcCallException(invalid, "Not supported expression");
     _args = args.Cast<IEvaluatesToString>().ToArray();
 }