C# DynamicMetaObject.CombineRestrictions方法代码示例

 private DynamicMetaObject CheckForSlicing(DynamicMetaObject target, DynamicMetaObject[] indexes)
 {
     if (this._allowSlicing)
     {
         if (indexes.Length > 1)
         {
             PSGetIndexBinder nonSlicingBinder = Get(1, this._constraints, false);
             return new DynamicMetaObject(Expression.NewArrayInit(typeof(object), (IEnumerable<Expression>) (from i in indexes select Expression.Dynamic(nonSlicingBinder, typeof(object), target.Expression, i.Expression))), target.CombineRestrictions(indexes));
         }
         DynamicMetaObject obj2 = PSEnumerableBinder.IsEnumerable(indexes[0]);
         if (obj2 != null)
         {
             return new DynamicMetaObject(Expression.Call(CachedReflectionInfo.EnumerableOps_SlicingIndex, target.Expression.Cast(typeof(object)), obj2.Expression.Cast(typeof(IEnumerator)), Expression.Constant(this.GetNonSlicingIndexer())), target.CombineRestrictions(new DynamicMetaObject[] { obj2 }));
         }
     }
     return null;
 }

 private static DynamicMetaObject CallImplicitOp(string methodName, DynamicMetaObject target, DynamicMetaObject arg, string errorOperator, DynamicMetaObject errorSuggestion)
 {
     if (errorSuggestion == null || target.Value as DynamicObject == null)
     {
         DynamicMetaObject[] dynamicMetaObjectArray = new DynamicMetaObject[1];
         dynamicMetaObjectArray[0] = arg;
         return new DynamicMetaObject(Expression.Call(CachedReflectionInfo.ParserOps_ImplicitOp, target.Expression.Cast(typeof(object)), arg.Expression.Cast(typeof(object)), Expression.Constant(methodName), ExpressionCache.NullExtent, Expression.Constant(errorOperator)), target.CombineRestrictions(dynamicMetaObjectArray));
     }
     else
     {
         return errorSuggestion;
     }
 }

 private DynamicMetaObject BinaryNumericStringOp(DynamicMetaObject target, DynamicMetaObject arg)
 {
     Expression number;
     Expression boxedFalse;
     List<ParameterExpression> parameterExpressions = new List<ParameterExpression>();
     List<Expression> expressions = new List<Expression>();
     Expression expression = target.Expression;
     if (target.LimitType.Equals(typeof(string)))
     {
         expression = PSBinaryOperationBinder.ConvertStringToNumber(target.Expression, arg.LimitType);
     }
     if (arg.LimitType.Equals(typeof(string)))
     {
         number = PSBinaryOperationBinder.ConvertStringToNumber(arg.Expression, target.LimitType);
     }
     else
     {
         number = arg.Expression;
     }
     Expression expression1 = number;
     expressions.Add(Expression.Dynamic(PSBinaryOperationBinder.Get(base.Operation, true, false), typeof(object), expression, expression1));
     Expression expression2 = Expression.Block(parameterExpressions, expressions);
     if (base.Operation == ExpressionType.Equal || base.Operation == ExpressionType.NotEqual)
     {
         Expression expression3 = expression2;
         CatchBlock[] catchBlockArray = new CatchBlock[1];
         CatchBlock[] catchBlockArray1 = catchBlockArray;
         int num = 0;
         Type type = typeof(InvalidCastException);
         if (base.Operation == ExpressionType.Equal)
         {
             boxedFalse = ExpressionCache.BoxedFalse;
         }
         else
         {
             boxedFalse = ExpressionCache.BoxedTrue;
         }
         catchBlockArray1[num] = Expression.Catch(type, boxedFalse);
         expression2 = Expression.TryCatch(expression3, catchBlockArray);
     }
     DynamicMetaObject[] dynamicMetaObjectArray = new DynamicMetaObject[1];
     dynamicMetaObjectArray[0] = arg;
     return new DynamicMetaObject(expression2, target.CombineRestrictions(dynamicMetaObjectArray));
 }

 private DynamicMetaObject InvokeIndexer(DynamicMetaObject target, DynamicMetaObject[] indexes, DynamicMetaObject value, DynamicMetaObject errorSuggestion, string methodName)
 {
     DynamicMetaObject dynamicMetaObject;
     Func<Expression, Expression, Expression, Expression> func = null;
     MethodInfo methodInfo = PSInvokeMemberBinder.FindBestMethod(target, indexes.Append<DynamicMetaObject>(value), string.Concat("set_", methodName), false, this._constraints);
     if (methodInfo != null)
     {
         ParameterInfo[] parameters = methodInfo.GetParameters();
         if ((int)parameters.Length == (int)indexes.Length + 1)
         {
             Expression[] expressionArray = new Expression[(int)parameters.Length];
             int num = 0;
             while (num < (int)parameters.Length)
             {
                 Type parameterType = parameters[num].ParameterType;
                 Expression[] expressionArray1 = expressionArray;
                 int num1 = num;
                 if (num == (int)parameters.Length - 1)
                 {
                     dynamicMetaObject = value;
                 }
                 else
                 {
                     dynamicMetaObject = indexes[num];
                 }
                 expressionArray1[num1] = PSGetIndexBinder.ConvertIndex(dynamicMetaObject, parameterType);
                 if (expressionArray[num] != null)
                 {
                     num++;
                 }
                 else
                 {
                     DynamicMetaObject dynamicMetaObject1 = errorSuggestion;
                     DynamicMetaObject dynamicMetaObject2 = dynamicMetaObject1;
                     if (dynamicMetaObject1 == null)
                     {
                         dynamicMetaObject2 = PSConvertBinder.ThrowNoConversion(target, parameterType, this, this._version, indexes.Append<DynamicMetaObject>(value).ToArray<DynamicMetaObject>());
                     }
                     return dynamicMetaObject2;
                 }
             }
             if ((int)parameters.Length == 2 && parameters[0].ParameterType.Equals(typeof(int)) && target.Value as IDictionary == null)
             {
                 PropertyInfo property = target.LimitType.GetProperty("Length");
                 PropertyInfo propertyInfo = property;
                 if (property == null)
                 {
                     propertyInfo = target.LimitType.GetProperty("Count");
                 }
                 PropertyInfo propertyInfo1 = propertyInfo;
                 if (propertyInfo1 != null)
                 {
                     PSSetIndexBinder pSSetIndexBinder = this;
                     DynamicMetaObject dynamicMetaObject3 = new DynamicMetaObject(target.Expression.Cast(target.LimitType), target.PSGetTypeRestriction());
                     DynamicMetaObject dynamicMetaObject4 = new DynamicMetaObject(expressionArray[0], indexes[0].PSGetTypeRestriction());
                     DynamicMetaObject dynamicMetaObject5 = new DynamicMetaObject(expressionArray[1], value.PSGetTypeRestriction());
                     PropertyInfo propertyInfo2 = propertyInfo1;
                     if (func == null)
                     {
                         func = (Expression t, Expression i, Expression v) => Expression.Call(t, methodInfo, i, v);
                     }
                     return pSSetIndexBinder.IndexWithNegativeChecks(dynamicMetaObject3, dynamicMetaObject4, dynamicMetaObject5, propertyInfo2, func);
                 }
             }
             BindingRestrictions bindingRestriction = target.CombineRestrictions(indexes).Merge(value.PSGetTypeRestriction());
             bindingRestriction = bindingRestriction.Merge(BinderUtils.GetVersionCheck(this, this._version));
             bindingRestriction = bindingRestriction.Merge(BinderUtils.GetLanguageModeCheckIfHasEverUsedConstrainedLanguage());
             Expression expression = expressionArray[(int)expressionArray.Length - 1];
             ParameterExpression parameterExpression = Expression.Parameter(expression.Type, "value");
             expressionArray[(int)expressionArray.Length - 1] = parameterExpression;
             ParameterExpression[] parameterExpressionArray = new ParameterExpression[1];
             parameterExpressionArray[0] = parameterExpression;
             Expression[] expressionArray2 = new Expression[3];
             expressionArray2[0] = Expression.Assign(parameterExpression, expression);
             expressionArray2[1] = Expression.Call(target.Expression.Cast(target.LimitType), methodInfo, expressionArray);
             expressionArray2[2] = parameterExpression.Cast(typeof(object));
             return new DynamicMetaObject(Expression.Block(parameterExpressionArray, expressionArray2), bindingRestriction);
         }
         else
         {
             DynamicMetaObject dynamicMetaObject6 = errorSuggestion;
             DynamicMetaObject dynamicMetaObject7 = dynamicMetaObject6;
             if (dynamicMetaObject6 == null)
             {
                 dynamicMetaObject7 = this.CannotIndexTarget(target, indexes, value);
             }
             return dynamicMetaObject7;
         }
     }
     else
     {
         DynamicMetaObject dynamicMetaObject8 = errorSuggestion;
         DynamicMetaObject dynamicMetaObject9 = dynamicMetaObject8;
         if (dynamicMetaObject8 == null)
         {
             dynamicMetaObject9 = this.CannotIndexTarget(target, indexes, value);
         }
         return dynamicMetaObject9;
     }
 }

 private DynamicMetaObject CannotIndexTarget(DynamicMetaObject target, DynamicMetaObject[] indexes)
 {
     return new DynamicMetaObject(Expression.Call(CachedReflectionInfo.ArrayOps_GetNonIndexable, target.Expression.Cast(typeof(object)), Expression.NewArrayInit(typeof(object), (IEnumerable<Expression>) (from d in indexes select d.Expression.Cast(typeof(object))))), target.CombineRestrictions(indexes).Merge(BinderUtils.GetVersionCheck(this, this._version)).Merge(BinderUtils.GetLanguageModeCheckIfHasEverUsedConstrainedLanguage()));
 }

 private DynamicMetaObject InvokeIndexer(DynamicMetaObject target, DynamicMetaObject[] indexes, DynamicMetaObject errorSuggestion, string methodName)
 {
     Func<Expression, Expression, Expression> generateIndexOperation = null;
     MethodInfo getter = PSInvokeMemberBinder.FindBestMethod(target, indexes, "get_" + methodName, false, this._constraints);
     if (getter == null)
     {
         return (this.CheckForSlicing(target, indexes) ?? (errorSuggestion ?? this.CannotIndexTarget(target, indexes)));
     }
     ParameterInfo[] parameters = getter.GetParameters();
     if (parameters.Length != indexes.Length)
     {
         if ((parameters.Length == 1) && this._allowSlicing)
         {
             return this.InvokeSlicingIndexer(target, indexes);
         }
         return (errorSuggestion ?? this.CannotIndexTarget(target, indexes));
     }
     if (parameters.Length == 1)
     {
         DynamicMetaObject obj2 = this.CheckForSlicing(target, indexes);
         if (obj2 != null)
         {
             return obj2;
         }
     }
     Expression[] arguments = new Expression[parameters.Length];
     for (int j = 0; j < parameters.Length; j++)
     {
         Type parameterType = parameters[j].ParameterType;
         arguments[j] = ConvertIndex(indexes[j], parameterType);
         if (arguments[j] == null)
         {
             return (errorSuggestion ?? PSConvertBinder.ThrowNoConversion(target, parameterType, this, this._version, indexes));
         }
     }
     if (((parameters.Length == 1) && parameters[0].ParameterType.Equals(typeof(int))) && CanIndexFromEndWithNegativeIndex(target))
     {
         PropertyInfo lengthProperty = target.LimitType.GetProperty("Count") ?? target.LimitType.GetProperty("Length");
         if (lengthProperty != null)
         {
             if (generateIndexOperation == null)
             {
                 generateIndexOperation = (t, i) => Expression.Call(t, getter, new Expression[] { i }).Cast(typeof(object));
             }
             return this.IndexWithNegativeChecks(new DynamicMetaObject(target.Expression.Cast(target.LimitType), target.PSGetTypeRestriction()), new DynamicMetaObject(arguments[0], indexes[0].PSGetTypeRestriction()), lengthProperty, generateIndexOperation);
         }
     }
     return new DynamicMetaObject(this.SafeIndexResult(Expression.Call(target.Expression.Cast(target.LimitType), getter, arguments)), target.CombineRestrictions(indexes).Merge(BinderUtils.GetVersionCheck(this, this._version)).Merge(BinderUtils.GetLanguageModeCheckIfHasEverUsedConstrainedLanguage()));
 }

 private DynamicMetaObject GetIndexMultiDimensionArray(DynamicMetaObject target, DynamicMetaObject[] indexes, DynamicMetaObject errorSuggestion)
 {
     Array array = (Array) target.Value;
     if (indexes.Length == 1)
     {
         if (PSEnumerableBinder.IsEnumerable(indexes[0]) == null)
         {
             return target.ThrowRuntimeError(indexes, BindingRestrictions.Empty, "NeedMultidimensionalIndex", ParserStrings.NeedMultidimensionalIndex, new Expression[] { ExpressionCache.Constant(array.Rank), Expression.Dynamic(PSToStringBinder.Get(), typeof(string), indexes[0].Expression, ExpressionCache.GetExecutionContextFromTLS) });
         }
         return new DynamicMetaObject(Expression.Call(CachedReflectionInfo.ArrayOps_GetMDArrayValueOrSlice, Expression.Convert(target.Expression, typeof(Array)), indexes[0].Expression.Cast(typeof(object))), target.CombineRestrictions(indexes));
     }
     IEnumerable<Expression> source = from index in indexes
         select ConvertIndex(index, typeof(int)) into i
         where i != null
         select i;
     if (source.Count<Expression>() == indexes.Length)
     {
         return new DynamicMetaObject(Expression.Call(CachedReflectionInfo.ArrayOps_GetMDArrayValue, Expression.Convert(target.Expression, typeof(Array)), Expression.NewArrayInit(typeof(int), source), ExpressionCache.Constant(!this._allowSlicing)), target.CombineRestrictions(indexes));
     }
     if (this._allowSlicing)
     {
         return this.InvokeSlicingIndexer(target, indexes);
     }
     return (errorSuggestion ?? this.CannotIndexTarget(target, indexes));
 }

 public override DynamicMetaObject FallbackSetMember(DynamicMetaObject target, DynamicMetaObject value, DynamicMetaObject errorSuggestion)
 {
     PSMemberInfo info;
     BindingRestrictions restrictions2;
     bool flag3;
     Type type4;
     if (!target.HasValue || !value.HasValue)
     {
         return base.Defer(target, new DynamicMetaObject[] { value });
     }
     object obj2 = PSObject.Base(target.Value);
     if (obj2 == null)
     {
         return target.ThrowRuntimeError(new DynamicMetaObject[] { value }, BindingRestrictions.Empty, "PropertyNotFound", ParserStrings.PropertyNotFound, new Expression[] { Expression.Constant(base.Name) }).WriteToDebugLog(this);
     }
     if (value.Value == AutomationNull.Value)
     {
         value = new DynamicMetaObject(ExpressionCache.NullConstant, value.PSGetTypeRestriction(), null);
     }
     if (this._getMemberBinder.HasInstanceMember && PSGetMemberBinder.TryGetInstanceMember(target.Value, base.Name, out info))
     {
         ParameterExpression expression = Expression.Variable(typeof(PSMemberInfo));
         ParameterExpression expression2 = Expression.Variable(typeof(object));
         ConditionalExpression expression3 = Expression.Condition(Expression.Call(CachedReflectionInfo.PSGetMemberBinder_TryGetInstanceMember, target.Expression.Cast(typeof(object)), Expression.Constant(base.Name), expression), Expression.Assign(Expression.Property(expression, "Value"), value.Expression.Cast(typeof(object))), base.GetUpdateExpression(typeof(object)));
         BindingRestrictions restrictions = BinderUtils.GetVersionCheck(this._getMemberBinder, this._getMemberBinder._version).Merge(value.PSGetTypeRestriction());
         return new DynamicMetaObject(Expression.Block(new ParameterExpression[] { expression, expression2 }, new Expression[] { expression3 }), restrictions).WriteToDebugLog(this);
     }
     if (obj2 is IDictionary)
     {
         Type genericTypeArg = null;
         bool flag = PSGetMemberBinder.IsGenericDictionary(obj2, ref genericTypeArg);
         if (!flag || (genericTypeArg != null))
         {
             bool flag2;
             Type type = flag ? typeof(IDictionary<,>).MakeGenericType(new Type[] { typeof(string), genericTypeArg }) : typeof(IDictionary);
             MethodInfo method = type.GetMethod("set_Item");
             ParameterExpression left = Expression.Variable(genericTypeArg ?? typeof(object));
             Type resultType = left.Type;
             LanguagePrimitives.ConversionData conversion = LanguagePrimitives.FigureConversion(value.Value, resultType, out flag2);
             if (conversion.Rank != ConversionRank.None)
             {
                 Expression right = PSConvertBinder.InvokeConverter(conversion, value.Expression, resultType, flag2, ExpressionCache.InvariantCulture);
                 return new DynamicMetaObject(Expression.Block(new ParameterExpression[] { left }, new Expression[] { Expression.Assign(left, right), Expression.Call(PSGetMemberBinder.GetTargetExpr(target).Cast(type), method, Expression.Constant(base.Name), right), right.Cast(typeof(object)) }), target.CombineRestrictions(new DynamicMetaObject[] { value })).WriteToDebugLog(this);
             }
         }
     }
     info = this._getMemberBinder.GetPSMemberInfo(target, out restrictions2, out flag3, out type4, null, null);
     restrictions2 = restrictions2.Merge(value.PSGetTypeRestriction());
     if (ExecutionContext.HasEverUsedConstrainedLanguage)
     {
         restrictions2 = restrictions2.Merge(BinderUtils.GetLanguageModeCheckIfHasEverUsedConstrainedLanguage());
         DynamicMetaObject obj3 = PSGetMemberBinder.EnsureAllowedInLanguageMode(LocalPipeline.GetExecutionContextFromTLS().LanguageMode, target, obj2, base.Name, this._static, new DynamicMetaObject[] { value }, restrictions2, "PropertySetterNotSupportedInConstrainedLanguage", ParserStrings.PropertySetConstrainedLanguage);
         if (obj3 != null)
         {
             return obj3.WriteToDebugLog(this);
         }
     }
     if (flag3)
     {
         if (info == null)
         {
             return (errorSuggestion ?? new DynamicMetaObject(Compiler.ThrowRuntimeError("PropertyAssignmentException", ParserStrings.PropertyNotFound, this.ReturnType, new Expression[] { Expression.Constant(base.Name) }), restrictions2)).WriteToDebugLog(this);
         }
         PSPropertyInfo info3 = info as PSPropertyInfo;
         if (info3 != null)
         {
             if (!info3.IsSettable)
             {
                 Expression innerException = Expression.New(CachedReflectionInfo.SetValueException_ctor, new Expression[] { Expression.Constant("PropertyAssignmentException"), Expression.Constant(null, typeof(Exception)), Expression.Constant(ParserStrings.PropertyIsReadOnly), Expression.NewArrayInit(typeof(object), new Expression[] { Expression.Constant(base.Name) }) });
                 return new DynamicMetaObject(Compiler.ThrowRuntimeErrorWithInnerException("PropertyAssignmentException", Expression.Constant(ParserStrings.PropertyIsReadOnly), innerException, this.ReturnType, new Expression[] { Expression.Constant(base.Name) }), restrictions2).WriteToDebugLog(this);
             }
             PSProperty property = info3 as PSProperty;
             if (property != null)
             {
                 DotNetAdapter.PropertyCacheEntry adapterData = property.adapterData as DotNetAdapter.PropertyCacheEntry;
                 if (adapterData != null)
                 {
                     Expression expression10;
                     Type propertyType;
                     if (adapterData.member.DeclaringType.IsGenericTypeDefinition)
                     {
                         Expression expression9 = Expression.New(CachedReflectionInfo.SetValueException_ctor, new Expression[] { Expression.Constant("PropertyAssignmentException"), Expression.Constant(null, typeof(Exception)), Expression.Constant(ExtendedTypeSystem.CannotInvokeStaticMethodOnUninstantiatedGenericType), Expression.NewArrayInit(typeof(object), new Expression[] { Expression.Constant(adapterData.member.DeclaringType.FullName) }) });
                         return new DynamicMetaObject(Compiler.ThrowRuntimeErrorWithInnerException("PropertyAssignmentException", Expression.Constant(ExtendedTypeSystem.CannotInvokeStaticMethodOnUninstantiatedGenericType), expression9, this.ReturnType, new Expression[] { Expression.Constant(adapterData.member.DeclaringType.FullName) }), restrictions2).WriteToDebugLog(this);
                     }
                     PropertyInfo member = adapterData.member as PropertyInfo;
                     if (member != null)
                     {
                         propertyType = member.PropertyType;
                         Expression expression11 = this._static ? null : PSGetMemberBinder.GetTargetExpr(target);
                         expression10 = Expression.Property(expression11, member);
                     }
                     else
                     {
                         FieldInfo field = (FieldInfo) adapterData.member;
                         propertyType = field.FieldType;
                         Expression expression12 = this._static ? null : PSGetMemberBinder.GetTargetExpr(target);
                         expression10 = Expression.Field(expression12, field);
                     }
                     Type underlyingType = Nullable.GetUnderlyingType(propertyType);
                     Type type7 = underlyingType ?? propertyType;
//.........这里部分代码省略.........

 private DynamicMetaObject Shift(DynamicMetaObject target, DynamicMetaObject arg, DynamicMetaObject errorSuggestion, string userOp, Func<Expression, Expression, Expression> exprGenerator)
 {
     bool flag = false;
     Type type;
     Type type1;
     byte num;
     if (target.Value != null)
     {
         if (target.LimitType.Equals(typeof(string)) || arg.LimitType.Equals(typeof(string)))
         {
             return this.BinaryNumericStringOp(target, arg);
         }
         else
         {
             TypeCode typeCode = LanguagePrimitives.GetTypeCode(target.LimitType);
             if (target.LimitType.IsNumeric())
             {
                 Type type2 = typeof(int);
                 LanguagePrimitives.ConversionData conversionDatum = LanguagePrimitives.FigureConversion(arg.Value, type2, out flag);
                 if (conversionDatum.Rank != ConversionRank.None)
                 {
                     Expression expression = PSConvertBinder.InvokeConverter(conversionDatum, arg.Expression, type2, flag, ExpressionCache.InvariantCulture);
                     if (typeCode == TypeCode.Decimal || typeCode == TypeCode.Double || typeCode == TypeCode.Single)
                     {
                         if (typeCode == TypeCode.Decimal)
                         {
                             type = typeof(DecimalOps);
                         }
                         else
                         {
                             type = typeof(DoubleOps);
                         }
                         Type type3 = type;
                         if (typeCode == TypeCode.Decimal)
                         {
                             type1 = typeof(decimal);
                         }
                         else
                         {
                             type1 = typeof(double);
                         }
                         Type type4 = type1;
                         string str = userOp.Substring(3);
                         DynamicMetaObject[] dynamicMetaObjectArray = new DynamicMetaObject[1];
                         dynamicMetaObjectArray[0] = arg;
                         return new DynamicMetaObject(Expression.Call(type3.GetMethod(str, BindingFlags.Static | BindingFlags.NonPublic), target.Expression.Cast(type4), expression), target.CombineRestrictions(dynamicMetaObjectArray));
                     }
                     else
                     {
                         Expression expression1 = target.Expression.Cast(target.LimitType);
                         Expression expression2 = expression;
                         if (typeCode < TypeCode.Int64)
                         {
                             num = 31;
                         }
                         else
                         {
                             num = 63;
                         }
                         expression = Expression.And(expression2, Expression.Constant(num, typeof(int)));
                         DynamicMetaObject[] dynamicMetaObjectArray1 = new DynamicMetaObject[1];
                         dynamicMetaObjectArray1[0] = arg;
                         return new DynamicMetaObject(exprGenerator(expression1, expression).Cast(typeof(object)), target.CombineRestrictions(dynamicMetaObjectArray1));
                     }
                 }
                 else
                 {
                     return PSConvertBinder.ThrowNoConversion(arg, typeof(int), this, this._version, new DynamicMetaObject[0]);
                 }
             }
             else
             {
                 return PSBinaryOperationBinder.CallImplicitOp(userOp, target, arg, this.GetOperatorText(), errorSuggestion);
             }
         }
     }
     else
     {
         return new DynamicMetaObject(ExpressionCache.Constant(0).Convert(typeof(object)), target.PSGetTypeRestriction());
     }
 }

 private DynamicMetaObject BinaryBitwiseOp(DynamicMetaObject target, DynamicMetaObject arg, DynamicMetaObject errorSuggestion, Func<Expression, Expression, Expression> exprGenerator, string implicitMethodName, string errorOperatorName, string methodName)
 {
     Type bitwiseOpType;
     Type type;
     Type type1;
     DynamicMetaObject argAsNumericOrPrimitive;
     DynamicMetaObject dynamicMetaObject;
     Type enumUnderlyingType;
     Type limitType;
     TypeCode typeCode;
     TypeCode typeCode1;
     if (target.Value != null || arg.Value != null)
     {
         if (target.LimitType.IsEnum)
         {
             enumUnderlyingType = target.LimitType.GetEnumUnderlyingType();
         }
         else
         {
             enumUnderlyingType = target.LimitType;
         }
         Type type2 = enumUnderlyingType;
         if (arg.LimitType.IsEnum)
         {
             limitType = arg.LimitType.GetEnumUnderlyingType();
         }
         else
         {
             limitType = arg.LimitType;
         }
         Type type3 = limitType;
         if (type2.IsNumericOrPrimitive() || type3.IsNumericOrPrimitive())
         {
             TypeCode typeCode2 = LanguagePrimitives.GetTypeCode(type2);
             TypeCode typeCode3 = LanguagePrimitives.GetTypeCode(type3);
             if (typeCode2 >= typeCode3)
             {
                 typeCode = typeCode2;
             }
             else
             {
                 typeCode = typeCode3;
             }
             TypeCode typeCode4 = typeCode;
             if (type2.IsNumericOrPrimitive())
             {
                 if (type3.IsNumericOrPrimitive())
                 {
                     argAsNumericOrPrimitive = target;
                     dynamicMetaObject = arg;
                 }
                 else
                 {
                     bitwiseOpType = PSBinaryOperationBinder.GetBitwiseOpType(typeCode2);
                     argAsNumericOrPrimitive = target;
                     dynamicMetaObject = PSBinaryOperationBinder.GetArgAsNumericOrPrimitive(arg, bitwiseOpType);
                 }
             }
             else
             {
                 bitwiseOpType = PSBinaryOperationBinder.GetBitwiseOpType(typeCode3);
                 argAsNumericOrPrimitive = PSBinaryOperationBinder.GetArgAsNumericOrPrimitive(target, bitwiseOpType);
                 dynamicMetaObject = arg;
             }
             if (typeCode4 != TypeCode.Decimal)
             {
                 if (typeCode4 == TypeCode.Double || typeCode4 == TypeCode.Single)
                 {
                     type = typeof(DoubleOps);
                     type1 = typeof(double);
                     DynamicMetaObject[] dynamicMetaObjectArray = new DynamicMetaObject[1];
                     dynamicMetaObjectArray[0] = dynamicMetaObject;
                     return new DynamicMetaObject(Expression.Call(type.GetMethod(methodName, BindingFlags.Static | BindingFlags.NonPublic), argAsNumericOrPrimitive.Expression.Cast(argAsNumericOrPrimitive.LimitType).Convert(type1), dynamicMetaObject.Expression.Cast(dynamicMetaObject.LimitType).Convert(type1)), argAsNumericOrPrimitive.CombineRestrictions(dynamicMetaObjectArray));
                 }
                 else
                 {
                     if (typeCode2 >= typeCode3)
                     {
                         typeCode1 = typeCode2;
                     }
                     else
                     {
                         typeCode1 = typeCode3;
                     }
                     bitwiseOpType = PSBinaryOperationBinder.GetBitwiseOpType(typeCode1);
                     if (argAsNumericOrPrimitive != null && dynamicMetaObject != null)
                     {
                         DynamicMetaObject[] dynamicMetaObjectArray1 = new DynamicMetaObject[1];
                         dynamicMetaObjectArray1[0] = dynamicMetaObject;
                         return new DynamicMetaObject(exprGenerator(argAsNumericOrPrimitive.Expression.Cast(target.LimitType).Cast(bitwiseOpType), dynamicMetaObject.Expression.Cast(dynamicMetaObject.LimitType).Cast(bitwiseOpType)).Cast(typeof(object)), argAsNumericOrPrimitive.CombineRestrictions(dynamicMetaObjectArray1));
                     }
                 }
             }
             else
             {
                 type = typeof(DecimalOps);
                 type1 = typeof(decimal);
                 DynamicMetaObject[] dynamicMetaObjectArray2 = new DynamicMetaObject[1];
                 dynamicMetaObjectArray2[0] = dynamicMetaObject;
                 return new DynamicMetaObject(Expression.Call(type.GetMethod(methodName, BindingFlags.Static | BindingFlags.NonPublic), argAsNumericOrPrimitive.Expression.Cast(argAsNumericOrPrimitive.LimitType).Convert(type1), dynamicMetaObject.Expression.Cast(dynamicMetaObject.LimitType).Convert(type1)), argAsNumericOrPrimitive.CombineRestrictions(dynamicMetaObjectArray2));
//.........这里部分代码省略.........

 public override DynamicMetaObject FallbackBinaryOperation(DynamicMetaObject target, DynamicMetaObject arg, DynamicMetaObject errorSuggestion)
 {
     object[] objArray;
     DynamicMetaObject[] dynamicMetaObjectArray;
     DynamicMetaObject dynamicMetaObject;
     DynamicMetaObject dynamicMetaObject1;
     if (!target.HasValue || !arg.HasValue)
     {
         DynamicMetaObject[] dynamicMetaObjectArray1 = new DynamicMetaObject[1];
         dynamicMetaObjectArray1[0] = arg;
         return base.Defer(target, dynamicMetaObjectArray1).WriteToDebugLog(this);
     }
     else
     {
         if ((target.Value as PSObject == null || PSObject.Base(target.Value) == target.Value) && (arg.Value as PSObject == null || PSObject.Base(arg.Value) == arg.Value) || base.Operation == ExpressionType.Add && PSEnumerableBinder.IsEnumerable(target) != null)
         {
             ExpressionType operation = base.Operation;
             if (operation > ExpressionType.Multiply)
             {
                 if (operation == ExpressionType.NotEqual)
                 {
                     return this.CompareNE(target, arg, errorSuggestion).WriteToDebugLog(this);
                 }
                 else if (operation == ExpressionType.Or)
                 {
                     return this.BinaryBitwiseOr(target, arg, errorSuggestion).WriteToDebugLog(this);
                 }
                 if (operation == ExpressionType.RightShift)
                 {
                     return this.RightShift(target, arg, errorSuggestion).WriteToDebugLog(this);
                 }
                 else if (operation == ExpressionType.Subtract)
                 {
                     return this.BinarySub(target, arg, errorSuggestion).WriteToDebugLog(this);
                 }
             }
             else
             {
                 if (operation == ExpressionType.Add)
                 {
                     return this.BinaryAdd(target, arg, errorSuggestion).WriteToDebugLog(this);
                 }
                 else if (operation == ExpressionType.AddChecked)
                 {
                     dynamicMetaObject = errorSuggestion;
                     dynamicMetaObject1 = dynamicMetaObject;
                     if (dynamicMetaObject == null)
                     {
                         objArray = new object[1];
                         objArray[0] = "Unimplemented operaton";
                         dynamicMetaObjectArray = new DynamicMetaObject[1];
                         dynamicMetaObjectArray[0] = arg;
                         dynamicMetaObject1 = new DynamicMetaObject(Compiler.CreateThrow(typeof(object), typeof(PSNotImplementedException), objArray), target.CombineRestrictions(dynamicMetaObjectArray));
                     }
                     return dynamicMetaObject1.WriteToDebugLog(this);
                 }
                 else if (operation == ExpressionType.And)
                 {
                     return this.BinaryBitwiseAnd(target, arg, errorSuggestion).WriteToDebugLog(this);
                 }
                 if (operation == ExpressionType.Divide)
                 {
                     return this.BinaryDivide(target, arg, errorSuggestion).WriteToDebugLog(this);
                 }
                 else if (operation == ExpressionType.Equal)
                 {
                     return this.CompareEQ(target, arg, errorSuggestion).WriteToDebugLog(this);
                 }
                 else if (operation == ExpressionType.ExclusiveOr)
                 {
                     return this.BinaryBitwiseXor(target, arg, errorSuggestion).WriteToDebugLog(this);
                 }
                 else if (operation == ExpressionType.GreaterThan)
                 {
                     return this.CompareGT(target, arg, errorSuggestion).WriteToDebugLog(this);
                 }
                 else if (operation == ExpressionType.GreaterThanOrEqual)
                 {
                     return this.CompareGE(target, arg, errorSuggestion).WriteToDebugLog(this);
                 }
                 else if (operation == ExpressionType.Invoke || operation == ExpressionType.Lambda || operation == ExpressionType.ListInit || operation == ExpressionType.MemberAccess || operation == ExpressionType.MemberInit)
                 {
                     dynamicMetaObject = errorSuggestion;
                     dynamicMetaObject1 = dynamicMetaObject;
                     if (dynamicMetaObject == null)
                     {
                         objArray = new object[1];
                         objArray[0] = "Unimplemented operaton";
                         dynamicMetaObjectArray = new DynamicMetaObject[1];
                         dynamicMetaObjectArray[0] = arg;
                         dynamicMetaObject1 = new DynamicMetaObject(Compiler.CreateThrow(typeof(object), typeof(PSNotImplementedException), objArray), target.CombineRestrictions(dynamicMetaObjectArray));
                     }
                     return dynamicMetaObject1.WriteToDebugLog(this);
                 }
                 else if (operation == ExpressionType.LeftShift)
                 {
                     return this.LeftShift(target, arg, errorSuggestion).WriteToDebugLog(this);
                 }
                 else if (operation == ExpressionType.LessThan)
                 {
//.........这里部分代码省略.........

 public override DynamicMetaObject FallbackCreateInstance(DynamicMetaObject target, DynamicMetaObject[] args, DynamicMetaObject errorSuggestion)
 {
     bool flag;
     Type type = (Type) target.Value;
     MethodInformation[] methodInformationArray = DotNetAdapter.GetMethodInformationArray(type.GetConstructors());
     target = new DynamicMetaObject(target.Expression, BindingRestrictions.GetInstanceRestriction(target.Expression, target.Value), target.Value);
     string errorId = null;
     string errorMsg = null;
     int count = base.CallInfo.ArgumentCount - base.CallInfo.ArgumentNames.Count;
     MethodInformation information = Adapter.FindBestMethod(methodInformationArray, null, (from arg in args.Take<DynamicMetaObject>(count) select arg.Value).ToArray<object>(), ref errorId, ref errorMsg, out flag);
     if (information == null)
     {
         if (errorSuggestion == null)
         {
         }
         return new DynamicMetaObject(Expression.Throw(Expression.New(CachedReflectionInfo.MethodException_ctor, new Expression[] { Expression.Constant(errorId), Expression.Constant(null, typeof(Exception)), Expression.Constant(errorMsg), Expression.NewArrayInit(typeof(object), new Expression[] { Expression.Constant(".ctor").Cast(typeof(object)), ExpressionCache.Constant(count).Cast(typeof(object)) }) }), this.ReturnType), target.CombineRestrictions(args));
     }
     ConstructorInfo method = (ConstructorInfo) information.method;
     ParameterInfo[] parameters = method.GetParameters();
     Expression[] arguments = new Expression[parameters.Length];
     int index = 0;
     while (index < parameters.Length)
     {
         bool flag3;
         Type parameterType = parameters[index].ParameterType;
         if (parameters[index].GetCustomAttributes(typeof(ParamArrayAttribute), true).Any<object>() && flag)
         {
             Type elementType = parameters[index].ParameterType.GetElementType();
             List<Expression> initializers = new List<Expression>();
             int num3 = index;
             int num4 = index;
             while (num4 < count)
             {
                 bool flag2;
                 LanguagePrimitives.ConversionData data = LanguagePrimitives.FigureConversion(args[index].Value, elementType, out flag2);
                 initializers.Add(PSConvertBinder.InvokeConverter(data, args[num4].Expression, elementType, flag2, ExpressionCache.InvariantCulture));
                 num4++;
                 index++;
             }
             arguments[num3] = Expression.NewArrayInit(elementType, initializers);
             break;
         }
         LanguagePrimitives.ConversionData conversion = LanguagePrimitives.FigureConversion(args[index].Value, parameterType, out flag3);
         arguments[index] = PSConvertBinder.InvokeConverter(conversion, args[index].Expression, parameterType, flag3, ExpressionCache.InvariantCulture);
         index++;
     }
     Expression right = Expression.New(method, arguments);
     if (base.CallInfo.ArgumentNames.Any<string>())
     {
         ParameterExpression expr = Expression.Parameter(right.Type);
         List<Expression> expressions = new List<Expression>();
         foreach (string str3 in base.CallInfo.ArgumentNames)
         {
             Expression expression3;
             Type propertyType;
             bool flag4;
             MemberInfo[] infoArray3 = type.GetMember(str3, MemberTypes.Property | MemberTypes.Field, BindingFlags.FlattenHierarchy | BindingFlags.Public | BindingFlags.Instance | BindingFlags.IgnoreCase);
             if ((infoArray3.Length != 1) || (!(infoArray3[0] is PropertyInfo) && !(infoArray3[0] is FieldInfo)))
             {
                 return target.ThrowRuntimeError(args, BindingRestrictions.Empty, "PropertyNotFoundForType", ParserStrings.PropertyNotFoundForType, new Expression[] { Expression.Constant(str3), Expression.Constant(type) });
             }
             MemberInfo info2 = infoArray3[0];
             if (info2 is PropertyInfo)
             {
                 PropertyInfo property = (PropertyInfo) info2;
                 if (property.GetSetMethod() == null)
                 {
                     return target.ThrowRuntimeError(args, BindingRestrictions.Empty, "PropertyIsReadOnly", ParserStrings.PropertyIsReadOnly, new Expression[] { Expression.Constant(str3) });
                 }
                 propertyType = property.PropertyType;
                 expression3 = Expression.Property(expr.Cast(info2.DeclaringType), property);
             }
             else
             {
                 propertyType = ((FieldInfo) info2).FieldType;
                 expression3 = Expression.Field(expr.Cast(info2.DeclaringType), (FieldInfo) info2);
             }
             LanguagePrimitives.ConversionData data3 = LanguagePrimitives.FigureConversion(args[index].Value, propertyType, out flag4);
             if (data3.Rank == ConversionRank.None)
             {
                 return PSConvertBinder.ThrowNoConversion(args[index], propertyType, this, -1, args.Except<DynamicMetaObject>(new DynamicMetaObject[] { args[index] }).Prepend<DynamicMetaObject>(target).ToArray<DynamicMetaObject>());
             }
             expressions.Add(Expression.Assign(expression3, PSConvertBinder.InvokeConverter(data3, args[index].Expression, propertyType, flag4, ExpressionCache.InvariantCulture)));
             index++;
         }
         ParameterExpression variable = Expression.Parameter(typeof(Exception));
         BlockExpression expression5 = Expression.Block(Expression.Assign(expr, right), Expression.TryCatch(Expression.Block(typeof(void), expressions), new CatchBlock[] { Expression.Catch(variable, Expression.Block(Expression.Call(CachedReflectionInfo.CommandProcessorBase_CheckForSevereException, variable), Compiler.ThrowRuntimeErrorWithInnerException("PropertyAssignmentException", Expression.Property(variable, "Message"), variable, typeof(void), new Expression[0]))) }), expr);
         right = Expression.Block(new ParameterExpression[] { expr }, new Expression[] { expression5 });
     }
     return new DynamicMetaObject(right, target.CombineRestrictions(args));
 }

 internal static DynamicMetaObject ThrowNoConversion(DynamicMetaObject target, Type toType, DynamicMetaObjectBinder binder, int currentVersion, params DynamicMetaObject[] args)
 {
     Expression expression = Expression.Call(CachedReflectionInfo.LanguagePrimitives_ThrowInvalidCastException, target.Expression.Cast(typeof(object)), Expression.Constant(toType));
     if (!binder.ReturnType.Equals(typeof(void)))
     {
         expression = Expression.Block(expression, Expression.Default(binder.ReturnType));
     }
     return new DynamicMetaObject(expression, target.CombineRestrictions(args).Merge(BinderUtils.GetOptionalVersionAndLanguageCheckForType(binder, toType, currentVersion)));
 }

 private DynamicMetaObject SetIndexMultiDimensionArray(DynamicMetaObject target, DynamicMetaObject[] indexes, DynamicMetaObject value, DynamicMetaObject errorSuggestion)
 {
     Type elementType = target.LimitType.GetElementType();
     Expression expression = PSGetIndexBinder.ConvertIndex(value, elementType);
     if (expression != null)
     {
         if ((int)indexes.Length != 1)
         {
             Array arrays = (Array)target.Value;
             if ((int)indexes.Length == arrays.Rank)
             {
                 Expression[] expressionArray = new Expression[(int)indexes.Length];
                 int num = 0;
                 while (num < (int)indexes.Length)
                 {
                     expressionArray[num] = PSGetIndexBinder.ConvertIndex(indexes[num], typeof(int));
                     if (expressionArray[num] != null)
                     {
                         num++;
                     }
                     else
                     {
                         DynamicMetaObject[] dynamicMetaObjectArray = new DynamicMetaObject[1];
                         dynamicMetaObjectArray[0] = indexes[num];
                         return PSConvertBinder.ThrowNoConversion(indexes[num], typeof(int), this, this._version, indexes.Except<DynamicMetaObject>(dynamicMetaObjectArray).Append<DynamicMetaObject>(target).Append<DynamicMetaObject>(value).ToArray<DynamicMetaObject>());
                     }
                 }
                 return new DynamicMetaObject(Expression.Call(CachedReflectionInfo.ArrayOps_SetMDArrayValue, target.Expression.Cast(typeof(Array)), Expression.NewArrayInit(typeof(int), expressionArray), expression.Cast(typeof(object))), target.CombineRestrictions(indexes).Merge(value.PSGetTypeRestriction()));
             }
             else
             {
                 DynamicMetaObject dynamicMetaObject = errorSuggestion;
                 DynamicMetaObject dynamicMetaObject1 = dynamicMetaObject;
                 if (dynamicMetaObject == null)
                 {
                     DynamicMetaObject dynamicMetaObject2 = target;
                     DynamicMetaObject[] dynamicMetaObjectArray1 = indexes;
                     BindingRestrictions bindingRestriction = value.PSGetTypeRestriction();
                     string str = "NeedMultidimensionalIndex";
                     string needMultidimensionalIndex = ParserStrings.NeedMultidimensionalIndex;
                     Expression[] expressionArray1 = new Expression[2];
                     expressionArray1[0] = ExpressionCache.Constant(arrays.Rank);
                     Expression[] expressionArray2 = expressionArray1;
                     int num1 = 1;
                     MethodInfo arrayOpsIndexStringMessage = CachedReflectionInfo.ArrayOps_IndexStringMessage;
                     Type type = typeof(object);
                     DynamicMetaObject[] dynamicMetaObjectArray2 = indexes;
                     expressionArray2[num1] = Expression.Call(arrayOpsIndexStringMessage, Expression.NewArrayInit(type, dynamicMetaObjectArray2.Select<DynamicMetaObject, Expression>((DynamicMetaObject i) => i.Expression.Cast(typeof(object)))));
                     dynamicMetaObject1 = dynamicMetaObject2.ThrowRuntimeError(dynamicMetaObjectArray1, bindingRestriction, str, needMultidimensionalIndex, expressionArray1);
                 }
                 return dynamicMetaObject1;
             }
         }
         else
         {
             Expression expression1 = PSGetIndexBinder.ConvertIndex(indexes[0], typeof(int[]));
             if (expression1 != null)
             {
                 return new DynamicMetaObject(Expression.Call(CachedReflectionInfo.ArrayOps_SetMDArrayValue, target.Expression.Cast(typeof(Array)), expression1, expression.Cast(typeof(object))), target.CombineRestrictions(indexes).Merge(value.PSGetTypeRestriction()));
             }
             else
             {
                 DynamicMetaObject dynamicMetaObject3 = errorSuggestion;
                 DynamicMetaObject dynamicMetaObject4 = dynamicMetaObject3;
                 if (dynamicMetaObject3 == null)
                 {
                     DynamicMetaObject[] dynamicMetaObjectArray3 = new DynamicMetaObject[2];
                     dynamicMetaObjectArray3[0] = target;
                     dynamicMetaObjectArray3[1] = value;
                     dynamicMetaObject4 = PSConvertBinder.ThrowNoConversion(indexes[0], typeof(int[]), this, this._version, dynamicMetaObjectArray3);
                 }
                 return dynamicMetaObject4;
             }
         }
     }
     else
     {
         DynamicMetaObject dynamicMetaObject5 = errorSuggestion;
         DynamicMetaObject dynamicMetaObject6 = dynamicMetaObject5;
         if (dynamicMetaObject5 == null)
         {
             dynamicMetaObject6 = PSConvertBinder.ThrowNoConversion(value, elementType, this, this._version, indexes.Prepend<DynamicMetaObject>(target).ToArray<DynamicMetaObject>());
         }
         return dynamicMetaObject6;
     }
 }

 private DynamicMetaObject CompareEQ(DynamicMetaObject target, DynamicMetaObject arg, DynamicMetaObject errorSuggestion)
 {
     Expression boxedTrue;
     if (target.Value != null)
     {
         DynamicMetaObject dynamicMetaObject = PSEnumerableBinder.IsEnumerable(target);
         if (dynamicMetaObject != null || arg.Value != null)
         {
             DynamicMetaObject dynamicMetaObject1 = this.BinaryComparisonCommon(dynamicMetaObject, target, arg);
             DynamicMetaObject dynamicMetaObject2 = dynamicMetaObject1;
             if (dynamicMetaObject1 == null)
             {
                 dynamicMetaObject2 = this.BinaryEqualityComparison(target, arg);
             }
             return dynamicMetaObject2;
         }
         else
         {
             DynamicMetaObject[] dynamicMetaObjectArray = new DynamicMetaObject[1];
             dynamicMetaObjectArray[0] = arg;
             return new DynamicMetaObject(ExpressionCache.BoxedFalse, target.CombineRestrictions(dynamicMetaObjectArray));
         }
     }
     else
     {
         if (arg.Value == null)
         {
             boxedTrue = ExpressionCache.BoxedTrue;
         }
         else
         {
             boxedTrue = ExpressionCache.BoxedFalse;
         }
         DynamicMetaObject[] dynamicMetaObjectArray1 = new DynamicMetaObject[1];
         dynamicMetaObjectArray1[0] = arg;
         return new DynamicMetaObject(boxedTrue, target.CombineRestrictions(dynamicMetaObjectArray1));
     }
 }