C# DynamicMetaObject.BindSetIndex方法代码示例

 public override DynamicMetaObject FallbackSetIndex(
     DynamicMetaObject target,
     DynamicMetaObject[] indexes,
     DynamicMetaObject value,
     DynamicMetaObject errorSuggestion)
 {
     return target.BindSetIndex(this, indexes, value);
 }

 public sealed override DynamicMetaObject Bind(DynamicMetaObject target, DynamicMetaObject[] args)
 {
     ContractUtils.RequiresNotNull(target, "target");
     ContractUtils.RequiresNotNull(args, "args");
     ContractUtils.Requires(args.Length >= 2, "args");
     DynamicMetaObject obj2 = args[args.Length - 1];
     DynamicMetaObject[] array = args.RemoveLast<DynamicMetaObject>();
     ContractUtils.RequiresNotNull(obj2, "args");
     ContractUtils.RequiresNotNullItems<DynamicMetaObject>(array, "args");
     return target.BindSetIndex(this, array, obj2);
 }

        /// <summary>
        /// Performs the binding of the dynamic set index operation.
        /// </summary>
        /// <param name="target">The target of the dynamic set index operation.</param>
        /// <param name="args">An array of arguments of the dynamic set index operation.</param>
        /// <returns>The <see cref="DynamicMetaObject"/> representing the result of the binding.</returns>
        public sealed override DynamicMetaObject Bind(DynamicMetaObject target, DynamicMetaObject[] args) {
            ContractUtils.RequiresNotNull(target, "target");
            ContractUtils.RequiresNotNull(args, "args");
            ContractUtils.Requires(args.Length >= 2, "args");

            DynamicMetaObject value = args[args.Length - 1];
            DynamicMetaObject[] indexes = args.RemoveLast();

            ContractUtils.RequiresNotNull(value, "args");
            ContractUtils.RequiresNotNullItems(indexes, "args");

            return target.BindSetIndex(this, indexes, value);
        }

 public override DynamicMetaObject/*!*/ FallbackOperation(DynamicMetaObject target, DynamicMetaObject/*!*/[]/*!*/ args, DynamicMetaObject onBindingError) {
     // TODO: until we use the real GetIndex and SetIndex binders, we
     // need to do this for COM interop
     if (Operation == "GetItem") {
         return target.BindGetIndex(new GetIndexAdapter(this), args);
     }            
     if (Operation == "SetItem") {
         DynamicMetaObject[] indexes = ArrayUtils.RemoveLast(args);
         DynamicMetaObject value = args[args.Length - 1];
         return target.BindSetIndex(new SetIndexAdapter(this), indexes, value);
     }
     return PythonProtocol.Operation(this, ArrayUtils.Insert(target, args));
 }

        public static bool TryBindSetIndex(SetIndexBinder binder, DynamicMetaObject instance, DynamicMetaObject[] args, DynamicMetaObject value, out DynamicMetaObject result) {
            ContractUtils.RequiresNotNull(binder, "binder");
            ContractUtils.RequiresNotNull(instance, "instance");
            ContractUtils.RequiresNotNull(args, "args");
            ContractUtils.RequiresNotNull(value, "value");

            if (TryGetMetaObject(ref instance)) {
                //
                // Demand Full Trust to proceed with the binding.
                //

                new PermissionSet(PermissionState.Unrestricted).Demand();

                result = instance.BindSetIndex(binder, args, value);
                return true;
            } else {
                result = null;
                return false;
            }
        }

            public static void TestMetaObject(DynamicMetaObject target, int index, JsonValue jsonValue, bool isValid = true)
            {
                string expectedMethodSignature = "System.Json.JsonValue SetValue(Int32, System.Object)";

                SetIndexBinder binder = new TestSetIndexBinder();
                DynamicMetaObject[] indexes = { new DynamicMetaObject(Expression.Parameter(typeof(int)), BindingRestrictions.Empty, index) };
                DynamicMetaObject value = new DynamicMetaObject(Expression.Parameter(jsonValue.GetType()), BindingRestrictions.Empty, jsonValue);
                DynamicMetaObject result = target.BindSetIndex(binder, indexes, value);
                Assert.IsNotNull(result);

                MethodCallExpression expression = result.Expression as MethodCallExpression;
                Assert.IsNotNull(expression);
                Assert.AreEqual<string>(expectedMethodSignature, expression.Method.ToString());
            }

            public static void TestBindParams(DynamicMetaObject target)
            {
                SetIndexBinder binder = new TestSetIndexBinder();
                Expression typeExpression = Expression.Parameter(typeof(int));
                DynamicMetaObject[] indexes = new DynamicMetaObject[] { new DynamicMetaObject(typeExpression, BindingRestrictions.Empty, 0) };
                DynamicMetaObject value = new DynamicMetaObject(typeExpression, BindingRestrictions.Empty, (JsonValue)10);

                ExceptionTestHelper.ExpectException<ArgumentNullException>(() => { var result = target.BindSetIndex(null, indexes, value); });
                ExceptionTestHelper.ExpectException<ArgumentNullException>(() => { var result = target.BindSetIndex(binder, null, value); });
                ExceptionTestHelper.ExpectException<ArgumentNullException>(() => { var result = target.BindSetIndex(binder, indexes, null); });

                DynamicMetaObject[][] invalidIndexesParam =
                {
                    new DynamicMetaObject[]
                    {
                        new DynamicMetaObject(typeExpression, BindingRestrictions.Empty, 0),
                        new DynamicMetaObject(typeExpression, BindingRestrictions.Empty, 1),
                        new DynamicMetaObject(typeExpression, BindingRestrictions.Empty, 2)
                    },

                    new DynamicMetaObject[]
                    {
                        new DynamicMetaObject(typeExpression, BindingRestrictions.Empty, null)
                    },

                    new DynamicMetaObject[]
                    {
                    }
                };

                foreach (DynamicMetaObject[] indexesParam in invalidIndexesParam)
                {
                    DynamicMetaObject metaObj = target.BindSetIndex(binder, indexesParam, value);

                    Expression<Action> expression = Expression.Lambda<Action>(Expression.Block(metaObj.Expression), new ParameterExpression[] { });
                    ExceptionTestHelper.ExpectException<ArgumentException>(() => { expression.Compile().Invoke(); }, NonSingleNonNullIndexNotSupported);
                }
            }

        /// <summary>
        /// Tries to perform binding of the dynamic set index operation.
        /// </summary>
        /// <param name="binder">An instance of the <see cref="SetIndexBinder"/> that represents the details of the dynamic operation.</param>
        /// <param name="instance">The target of the dynamic operation. </param>
        /// <param name="args">An array of <see cref="DynamicMetaObject"/> instances - arguments to the invoke member operation.</param>
        /// <param name="value">The <see cref="DynamicMetaObject"/> representing the value for the set index operation.</param>
        /// <param name="result">The new <see cref="DynamicMetaObject"/> representing the result of the binding.</param>
        /// <returns>true if operation was bound successfully; otherwise, false.</returns>
        public static bool TryBindSetIndex(SetIndexBinder binder, DynamicMetaObject instance, DynamicMetaObject[] args, DynamicMetaObject value, out DynamicMetaObject result) {
            ContractUtils.RequiresNotNull(binder, "binder");
            ContractUtils.RequiresNotNull(instance, "instance");
            ContractUtils.RequiresNotNull(args, "args");
            ContractUtils.RequiresNotNull(value, "value");

            if (TryGetMetaObjectInvoke(ref instance)) {
                result = instance.BindSetIndex(binder, args, value);
                return true;
            } else {
                result = null;
                return false;
            }
        }

 /// <summary>
 /// Tries to perform binding of the dynamic set index operation.
 /// </summary>
 /// <param name="binder">An instance of the <see cref="SetIndexBinder"/> that represents the details of the dynamic operation.</param>
 /// <param name="instance">The target of the dynamic operation. </param>
 /// <param name="args">An array of <see cref="DynamicMetaObject"/> instances - arguments to the invoke member operation.</param>
 /// <param name="value">The <see cref="DynamicMetaObject"/> representing the value for the set index operation.</param>
 /// <param name="result">The new <see cref="DynamicMetaObject"/> representing the result of the binding.</param>
 /// <returns>true if operation was bound successfully; otherwise, false.</returns>
 public static bool TryBindSetIndex(SetIndexBinder binder, DynamicMetaObject instance, DynamicMetaObject[] args, DynamicMetaObject value, out DynamicMetaObject result) {
     if (TryGetMetaObject(ref instance)) {
         result = instance.BindSetIndex(binder, args, value);
         return true;
     } else {
         result = null;
         return false;
     }
 }

        /// <summary>
        /// Tries to perform binding of the dynamic set index operation.
        /// </summary>
        /// <param name="binder">An instance of the <see cref="SetIndexBinder"/> that represents the details of the dynamic operation.</param>
        /// <param name="instance">The target of the dynamic operation. </param>
        /// <param name="args">An array of <see cref="DynamicMetaObject"/> instances - arguments to the invoke member operation.</param>
        /// <param name="value">The <see cref="DynamicMetaObject"/> representing the value for the set index operation.</param>
        /// <param name="result">The new <see cref="DynamicMetaObject"/> representing the result of the binding.</param>
        /// <returns>true if operation was bound successfully; otherwise, false.</returns>
        public static bool TryBindSetIndex(SetIndexBinder binder, DynamicMetaObject instance, DynamicMetaObject[] args, DynamicMetaObject value, out DynamicMetaObject result)
        {
            if (TryGetMetaObjectInvoke(ref instance))
            {
                result = instance.BindSetIndex(binder, args, value);
                result = new DynamicMetaObject(result.Expression, result.Restrictions.Merge(value.PSGetMethodArgumentRestriction()));

                return true;
            }
            else
            {
                result = null;
                return false;
            }
        }