BindConvert() публичный Метод

Performs the binding of the dynamic conversion operation.
public BindConvert ( ConvertBinder binder ) : DynamicMetaObject
binder ConvertBinder An instance of the that represents the details of the dynamic operation.
Результат DynamicMetaObject
Пример #1
0
        /// <inheritdoc />
        /// <summary>
        ///     Performs the binding of the dynamic convert operation.
        /// </summary>
        /// <param name="target">The target of the dynamic convert operation.</param>
        /// <param name="args">An array of arguments of the dynamic convert 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, nameof(target));
            ContractUtils.Requires(args == null || args.Length == 0, nameof(args));

            return(target.BindConvert(this));
        }
Пример #2
0
        /// <summary>
        /// Performs the binding of the dynamic convert operation.
        /// </summary>
        /// <param name="target">The target of the dynamic convert operation.</param>
        /// <param name="args">An array of arguments of the dynamic convert 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, nameof(target));
            ContractUtils.Requires(args == null || args.Length == 0, nameof(args));

            return target.BindConvert(this);
        }
Пример #3
0
        /// <summary>
        /// Performs the binding of the dynamic convert operation.
        /// </summary>
        /// <param name="target">The target of the dynamic convert operation.</param>
        /// <param name="args">An array of arguments of the dynamic convert operation.</param>
        /// <returns>The <see cref="DynamicMetaObject"/> representing the result of the binding.</returns>
        public sealed override DynamicMetaObject Bind(DynamicMetaObject target, DynamicMetaObject[]?args)
        {
            ArgumentNullException.ThrowIfNull(target);
            ContractUtils.Requires(args == null || args.Length == 0, nameof(args));

            return(target.BindConvert(this));
        }
Пример #4
0
        protected static bool TryConvert( ConvertBinder binder, DynamicMetaObject instance, out DynamicMetaObject result )
        {
            if ( instance.HasValue &&
                 instance.RuntimeType.IsValueType )
            {
                result = instance.BindConvert( binder );
                return true;
            }

            if ( binder.Type.IsInterface )
            {
                Expression expression = Convert( instance.Expression, binder.Type );
                result = new DynamicMetaObject( expression, BindingRestrictions.Empty, instance.Value );
                result = result.BindConvert( binder );
                return true;
            }

            if ( typeof (IDynamicMetaObjectProvider).IsAssignableFrom( instance.RuntimeType ) )
            {
                result = instance.BindConvert( binder );
                return true;
            }

            result = null;
            return false;
        }
            public static void TestMetaObject(DynamicMetaObject target, Type type, bool isValid = true)
            {
                ConvertBinder binder = new TestConvertBinder(type);
                DynamicMetaObject result = target.BindConvert(binder);
                Assert.IsNotNull(result);

                // Convert expression
                UnaryExpression expression = result.Expression as UnaryExpression;
                Assert.IsNotNull(expression);
                Assert.AreEqual<Type>(binder.Type, expression.Type);

                if (isValid)
                {
                    MethodCallExpression methodCallExp = expression.Operand as MethodCallExpression;

                    if (methodCallExp != null)
                    {
                        Assert.IsTrue(methodCallExp.Method.ToString().Contains("CastValue"));
                    }
                    else
                    {
                        ParameterExpression paramExpression = expression.Operand as ParameterExpression;
                        Assert.IsNotNull(paramExpression);
                    }
                }
                else
                {
                    Expression<Action> throwExp = Expression.Lambda<Action>(Expression.Block(expression), new ParameterExpression[] { });
                    ExceptionTestHelper.ExpectException<InvalidCastException>(() => throwExp.Compile().Invoke());
                }
            }
 public static void TestBindParams(DynamicMetaObject target)
 {
     ConvertBinder binder = new TestConvertBinder(typeof(int));
     ExceptionTestHelper.ExpectException<ArgumentNullException>(() => { var result = target.BindConvert(null); });
 }
 public sealed override DynamicMetaObject Bind(DynamicMetaObject target, DynamicMetaObject[] args)
 {
     ContractUtils.RequiresNotNull(target, "target");
     ContractUtils.Requires((args == null) || (args.Length == 0), "args");
     return(target.BindConvert(this));
 }
 public sealed override DynamicMetaObject Bind(DynamicMetaObject target, DynamicMetaObject[] args)
 {
     ContractUtils.RequiresNotNull(target, "target");
     ContractUtils.Requires((args == null) || (args.Length == 0), "args");
     return target.BindConvert(this);
 }