C# DynamicMetaObject.Any方法代码示例

 public override DynamicMetaObject FallbackCreateInstance(DynamicMetaObject target, DynamicMetaObject[] args, DynamicMetaObject errorSuggestion)
 {
     // Defer if any object has no value so that we evaulate their
     // Expressions and nest a CallSite for the InvokeMember.
     if (!target.HasValue || args.Any((a) => !a.HasValue))
     {
         var deferArgs = new DynamicMetaObject[args.Length + 1];
         for (int i = 0; i < args.Length; i++)
         {
             deferArgs[i + 1] = args[i];
         }
         deferArgs[0] = target;
         return Defer(deferArgs);
     }
     // Make sure target actually contains a Type.
     if (!typeof(Type).IsAssignableFrom(target.LimitType))
     {
         return errorSuggestion ??
                RuntimeHelpers.CreateBindingThrow(
                    target, args, BindingRestrictions.Empty,
                    typeof(InvalidOperationException),
                    "Type object must be used when creating instance -- " +
                    args);
     }
     var type = target.Value as Type;
     Debug.Assert(type != null);
     ConstructorInfo[] constructors = type.GetConstructors();
     // Get constructors with right arg counts.
     IEnumerable<ConstructorInfo> ctors = constructors.
         Where(c => c.GetParameters().Length == args.Length);
     var res = new List<ConstructorInfo>();
     foreach (ConstructorInfo c in ctors)
     {
         if (RuntimeHelpers.ParametersMatchArguments(c.GetParameters(),
                                                     args))
         {
             res.Add(c);
         }
     }
     // We generate an instance restriction on the target since it is a
     // Type and the constructor is associate with the actual Type instance.
     BindingRestrictions restrictions =
         RuntimeHelpers.GetTargetArgsRestrictions(
             target, args, true);
     if (res.Count == 0)
     {
         return errorSuggestion ??
                RuntimeHelpers.CreateBindingThrow(
                    target, args, restrictions,
                    typeof(MissingMemberException),
                    "Can't bind create instance -- " + args);
     }
     Expression[] ctorArgs =
         RuntimeHelpers.ConvertArguments(
             args, res[0].GetParameters());
     return new DynamicMetaObject(
         // Creating an object, so don't need EnsureObjectResult.
         Expression.New(res[0], ctorArgs),
         restrictions);
 }

        public override DynamicMetaObject BindInvoke(InvokeBinder binder, DynamicMetaObject[] args) {
            ContractUtils.RequiresNotNull(binder, "binder");

            if (args.Any(arg => ComBinderHelpers.IsStrongBoxArg(arg))) {
                return ComBinderHelpers.RewriteStrongBoxAsRef(binder, this, args, false);
            }

            ComMethodDesc method;
            if (_self.TryGetGetItem(out method)){
                return BindComInvoke(args, method, binder.Arguments);
            }

            return base.BindInvoke(binder, args);
        }

 public override DynamicMetaObject FallbackInvoke(
     DynamicMetaObject targetMO, DynamicMetaObject[] argMOs,
     DynamicMetaObject errorSuggestion)
 {
     // First try COM binding.
     DynamicMetaObject result;
     if (ComBinder.TryBindInvoke(this, targetMO, argMOs, out result))
     {
         return result;
     }
     // Defer if any object has no value so that we evaulate their
     // Expressions and nest a CallSite for the InvokeMember.
     if (!targetMO.HasValue || argMOs.Any((a) => !a.HasValue))
     {
         var deferArgs = new DynamicMetaObject[argMOs.Length + 1];
         for (int i = 0; i < argMOs.Length; i++)
         {
             deferArgs[i + 1] = argMOs[i];
         }
         deferArgs[0] = targetMO;
         return Defer(deferArgs);
     }
      //Find our own binding.
     if (targetMO.LimitType.IsSubclassOf(typeof(Delegate)))
     {
         var parms = targetMO.LimitType.GetMethod("Invoke").GetParameters();
         if (parms.Length == argMOs.Length)
         {
             // Don't need to check if argument types match parameters.
             // If they don't, users get an argument conversion error.
             var callArgs = RuntimeHelpers.ConvertArguments(argMOs, parms);
             var expression = Expression.Invoke(
                 Expression.Convert(targetMO.Expression, targetMO.LimitType),
                 callArgs);
             return new DynamicMetaObject(
                 RuntimeHelpers.EnsureObjectResult(expression),
                 BindingRestrictions.GetTypeRestriction(targetMO.Expression,
                     targetMO.LimitType));
         }
     }
     return errorSuggestion ??
         RuntimeHelpers.CreateThrow(
             targetMO, argMOs,
             BindingRestrictions.GetTypeRestriction(targetMO.Expression,
                 targetMO.LimitType),
             typeof(InvalidOperationException),
             "Wrong number of arguments for function -- " +
                 targetMO.LimitType.ToString() + " got " + argMOs.ToString());
 }

        private DynamicMetaObject BindGetOrInvoke(CallSiteBinder binder, DynamicMetaObject[] args, IList<ArgumentInfo> argInfos) {
            if (args.Any(arg => ComBinderHelpers.IsStrongBoxArg(arg))) {
                return ComBinderHelpers.RewriteStrongBoxAsRef(binder, this, args, false);
            }

            ComMethodDesc method;
            var target = _callable.DispatchComObject;
            var name = _callable.MemberName;
            
            if (target.TryGetMemberMethod(name, out method) ||
                target.TryGetMemberMethodExplicit(name, out method)) {

                return BindComInvoke(method, args, argInfos);
            }
            return null;
        }

        public override DynamicMetaObject BindSetIndex(SetIndexBinder binder, DynamicMetaObject[] indexes, DynamicMetaObject value) {
            if (indexes.Any(arg => ComBinderHelpers.IsStrongBoxArg(arg))) {
                return ComBinderHelpers.RewriteStrongBoxAsRef(binder, this, indexes.AddLast(value), true);
            }

            ComMethodDesc method;
            var target = _callable.DispatchComObject;
            var name = _callable.MemberName;

            if (target.TryGetPropertySetter(name, out method, value.LimitType) ||
                target.TryGetPropertySetterExplicit(name, out method, value.LimitType)) {

                return BindComInvoke(method, indexes.AddLast(value), binder.Arguments);
            }

            return base.BindSetIndex(binder, indexes, value);
        }

 public override DynamicMetaObject FallbackGetIndex(
     DynamicMetaObject target, DynamicMetaObject[] indexes,
     DynamicMetaObject errorSuggestion)
 {
     // First try COM binding.
     DynamicMetaObject result;
     if (ComBinder.TryBindGetIndex(this, target, indexes, out result))
     {
         return result;
     }
     // Defer if any object has no value so that we evaulate their
     // Expressions and nest a CallSite for the InvokeMember.
     if (!target.HasValue || indexes.Any((a) => !a.HasValue))
     {
         var deferArgs = new DynamicMetaObject[indexes.Length + 1];
         for (int i = 0; i < indexes.Length; i++)
         {
             deferArgs[i + 1] = indexes[i];
         }
         deferArgs[0] = target;
         return Defer(deferArgs);
     }
     // Give good error for Cons.
     //if (target.LimitType == typeof(Cons))
     //{
     //    if (indexes.Length != 1)
     //        return errorSuggestion ??
     //            RuntimeHelpers.CreateThrow(
     //                 target, indexes, BindingRestrictions.Empty,
     //                 typeof(InvalidOperationException),
     //                 "Indexing list takes single index.  " + "Got " +
     //                 indexes.Length.ToString());
     //}
     // Find our own binding.
     //
     // Conversions created in GetIndexExpression must be consistent with
     // restrictions made in GetTargetArgsRestrictions.
     var indexingExpr = RuntimeHelpers.EnsureObjectResult(
         RuntimeHelpers.GetIndexingExpression(target,
             indexes));
     var restrictions = RuntimeHelpers.GetTargetArgsRestrictions(
         target, indexes, false);
     return new DynamicMetaObject(indexingExpr, restrictions);
 }

        public override DynamicMetaObject FallbackInvoke(DynamicMetaObject target, DynamicMetaObject[] args, DynamicMetaObject errorSuggestion)
        {
            if (!target.HasValue || args.Any(a => !a.HasValue))
                return Defer(target, args);

            var restrictions = RuntimeHelpers.MergeTypeRestrictions(target);

            if (target.Value == null)
                throw LuaRuntimeException.Create(context, "Attempt to invoke a nil object (" + context.CurrentVariableIdentifier + ")");

            if (!target.LimitType.IsSubclassOf(typeof(Delegate)) && target.LimitType != typeof(Varargs))
                return new DynamicMetaObject(
                    MetamethodFallbacks.WrapStackTrace(MetamethodFallbacks.Call(context, target, args), context,
                    new FunctionStack(context.CurrentVariableIdentifier + "." + Constant.CALL_METAMETHOD)), restrictions);

            restrictions = restrictions.Merge(
                RuntimeHelpers.MergeTypeRestrictions(args).Merge(
                    RuntimeHelpers.MergeInstanceRestrictions(target)));

            Delegate function = null;
            DynamicMetaObject actualTarget = null;
            if (target.LimitType.IsSubclassOf(typeof(Delegate)))
            {
                function = (Delegate)target.Value;
                actualTarget = target;
            }
            else if (target.LimitType == typeof(Varargs))
            {
                function = ((Varargs)target.Value).First() as Delegate;
                actualTarget = new DynamicMetaObject(Expression.Constant(((Varargs)target.Value).First()), BindingRestrictions.Empty, ((Varargs)target.Value).First());
            }

            if (function == null)
                return new DynamicMetaObject(MetamethodFallbacks.Call(context,
                    actualTarget,
                    args),
                    restrictions);

            var methodInfo = function.Method;

            bool toss = false;
            return GetInvoker(actualTarget, args, methodInfo, out toss, ref restrictions);
        }

        public override DynamicMetaObject FallbackInvoke(DynamicMetaObject target, DynamicMetaObject[] args, DynamicMetaObject errorSuggestion)
        {
            if (!target.HasValue || args.Any(a => !a.HasValue))
                return Defer(target, args);

            var restrictions = RuntimeHelpers.MergeTypeRestrictions(target);

            if (!target.LimitType.IsSubclassOf(typeof(Delegate)))
                return new DynamicMetaObject(MetamethodFallbacks.Call(context, target, args), restrictions);

            restrictions = restrictions.Merge(
                RuntimeHelpers.MergeTypeRestrictions(args).Merge(
                    RuntimeHelpers.MergeInstanceRestrictions(target)));

            List<Expr> sideEffects;
            Expr failExpr;
            var function = (Delegate)target.Value;
            var methodInfo = function.Method;
            var mappedArgs = MapArguments(args, methodInfo, ref restrictions, out sideEffects, out failExpr);

            if (failExpr != null)
                return new DynamicMetaObject(Expr.Block(failExpr, Expr.Default(typeof(object))), restrictions);

            var invokeExpr = InvokeExpression(target, mappedArgs, methodInfo);

            // Execute overflowing arguments for side effects
            Expr expr;
            if (sideEffects.Count == 0)
            {
                expr = invokeExpr;
            }
            else
            {
                var tempVar = Expr.Variable(typeof(object));
                var assign = Expr.Assign(tempVar, invokeExpr);
                sideEffects.Insert(0, assign);
                sideEffects.Add(tempVar);
                expr = Expr.Block(new[] {tempVar}, sideEffects);
            }

            return new DynamicMetaObject(expr, restrictions);
        }

        public override DynamicMetaObject FallbackSetIndex(
            DynamicMetaObject target, DynamicMetaObject[] indexes,
            DynamicMetaObject value, DynamicMetaObject errorSuggestion)
        {
            // First try COM binding.
            DynamicMetaObject result;
            if (ComBinder.TryBindSetIndex(this, target, indexes, value, out result))
            {
                return result;
            }
            // Defer if any object has no value so that we evaulate their
            // Expressions and nest a CallSite for the InvokeMember.
            if (!target.HasValue || indexes.Any((a) => !a.HasValue) || !value.HasValue)
            {
                var deferArgs = new DynamicMetaObject[indexes.Length + 2];
                for (int i = 0; i < indexes.Length; i++)
                {
                    deferArgs[i + 1] = indexes[i];
                }
                deferArgs[0] = target;
                deferArgs[indexes.Length + 1] = value;
                return Defer(deferArgs);
            }
            // Find our own binding.
            Expression valueExpr = value.Expression;
            ////we convert a value of TypeModel to Type.
            //if (value.LimitType == typeof(TypeModel))
            //{
            //    valueExpr = RuntimeHelpers.GetRuntimeTypeMoFromModel(value).Expression;
            //}
            //Debug.Assert(target.HasValue && target.LimitType != typeof(Array));
            Expression setIndexExpr;
            //if (target.LimitType == typeof(Cons))
            //{
            //    if (indexes.Length != 1)
            //    {
            //        return errorSuggestion ??
            //            RuntimeHelpers.CreateThrow(
            //                 target, indexes, BindingRestrictions.Empty,
            //                 typeof(InvalidOperationException),
            //                 "Indexing list takes single index.  " + "Got " + indexes);
            //    }
            //    // Call RuntimeHelper.SetConsElt
            //    List<Expression> args = new List<Expression>();
            //    // The first argument is the list
            //    args.Add(
            //        Expression.Convert(
            //            target.Expression,
            //            target.LimitType)
            //    );
            //    // The second argument is the index.
            //    args.Add(Expression.Convert(indexes[0].Expression,
            //                                indexes[0].LimitType));
            //    // The last argument is the value
            //    args.Add(Expression.Convert(valueExpr, typeof(object)));
            //    // BinderFactory helper returns value stored.
            //    setIndexExpr = Expression.Call(
            //        typeof(RuntimeHelpers),
            //        "SetConsElt",
            //        null,
            //        args.ToArray());
            //}
            //else
            {
                Expression indexingExpr = RuntimeHelpers.GetIndexingExpression(
                    target, indexes);
                // Assign returns the stored value, so we're good for BinderFactory.
                setIndexExpr = Expression.Assign(indexingExpr, valueExpr);
            }

            BindingRestrictions restrictions =
                RuntimeHelpers.GetTargetArgsRestrictions(target, indexes, false);
            return new DynamicMetaObject(
                RuntimeHelpers.EnsureObjectResult(setIndexExpr),
                restrictions);
        }

        public override DynamicMetaObject FallbackInvokeMember(DynamicMetaObject targetMO, DynamicMetaObject[] args, DynamicMetaObject errorSuggestion)
        {
            // Defer if any object has no value so that we evaulate their
            // Expressions and nest a CallSite for the InvokeMember.
            if (!targetMO.HasValue || args.Any((a) => !a.HasValue))
            {
                var deferArgs = new DynamicMetaObject[args.Length + 1];
                for (int i = 0; i < args.Length; i++)
                {
                    deferArgs[i + 1] = args[i];
                }
                deferArgs[0] = targetMO;
                return Defer(deferArgs);
            }
            // Find our own binding.
            // Could consider allowing invoking static members from an instance.
            BindingFlags flags = BindingFlags.Instance | BindingFlags.Public;
            MemberInfo[] members = targetMO.LimitType.GetMember(Name, flags);
            if ((members.Length == 1) && (members[0] is PropertyInfo ||
                                          members[0] is FieldInfo))
            {
                // NEED TO TEST, should check for delegate value too
                MemberInfo mem = members[0];
                throw new NotImplementedException();
                //return new DynamicMetaObject(
                //    Expression.Dynamic(
                //        new SymplInvokeBinder(new CallInfo(args.Length)),
                //        typeof(object),
                //        args.Select(a => a.Expression).AddFirst(
                //               Expression.MakeMemberAccess(this.Expression, mem)));

                // Don't test for eventinfos since we do nothing with them now.
            }
            else
            {
                // Get MethodInfos with right arg counts.
                IEnumerable<MethodInfo> mi_mems = members.
                    Select(m => m as MethodInfo).
                    Where(m => m.GetParameters().Length == args.Length);
                // Get MethodInfos with param types that work for args.  This works
                // except for value args that need to pass to reftype params.
                // We could detect that to be smarter and then explicitly StrongBox
                // the args.
                var res = mi_mems.Where(mem => RuntimeHelpers.ParametersMatchArguments(mem.GetParameters(), args)).ToList();
                // False below means generate a type restriction on the MO.
                // We are looking at the members targetMO's Type.
                BindingRestrictions restrictions = RuntimeHelpers.GetTargetArgsRestrictions(targetMO, args, false);
                if (res.Count == 0)
                {
                    return errorSuggestion ?? RuntimeHelpers.CreateBindingThrow(targetMO, args, restrictions, typeof(MissingMemberException), "Can't bind member invoke -- " + args);
                }
                // restrictions and conversion must be done consistently.
                Expression[] callArgs = RuntimeHelpers.ConvertArguments(args, res[0].GetParameters());
                return new DynamicMetaObject(
                    RuntimeHelpers.EnsureObjectResult(
                        Expression.Call(
                            Expression.Convert(targetMO.Expression, targetMO.LimitType),
                            res[0],
                            callArgs)),
                    restrictions);
                // Could hve tried just letting Expr.Call factory do the work,
                // but if there is more than one applicable method using just
                // assignablefrom, Expr.Call throws.  It does not pick a "most
                // applicable" method or any method.
            }
        }

 internal static bool NeedsDeferal(DynamicMetaObject[] args)
 {
     return args.Any(MetaObjectExtensions.NeedsDeferral);
 }

        public override DynamicMetaObject FallbackInvokeMember(
            DynamicMetaObject target, DynamicMetaObject[] args,
            DynamicMetaObject errorSuggestion)
        {
            // First try COM binding.
            DynamicMetaObject result;
            if (ComBinder.TryBindInvokeMember(this, target, args, out result))
                return result;

            // Defer if any object has no value so that we evaulate their
            // Expressions and nest a CallSite for the InvokeMember.
            if (!target.HasValue || args.Any((a) => !a.HasValue))
            {
                var deferArgs = new DynamicMetaObject[args.Length + 1];
                for (int i = 0; i < args.Length; i++)
                {
                    deferArgs[i + 1] = args[i];
                }
                deferArgs[0] = target;
                return Defer(deferArgs);
            }

            Func<DynamicMetaObject> getMethodNotFoundDMO = () => errorSuggestion ?? RuntimeHelpers.CreateThrow(target, args, RuntimeHelpers.GetTargetArgsRestrictions(target, args, false),
                    typeof(MissingMethodException), String.Format(RuntimeMessages.PublicMethodDoesNotExist_Method_Type, this.Name, target.Value.GetType()));

            if (target.Value is HappyTypeTracker)
            {
                HappyTypeTracker typeTracker = (HappyTypeTracker) target.Value;
                IHappyTracker found;

                if (typeTracker.FindMemberTracker(this.Name, out found))
                {
                    HappyMethodTracker tracker = found as HappyMethodTracker;
                    if(tracker == null)
                    {
                        return errorSuggestion ??
                                    RuntimeHelpers.CreateThrow(
                                        target, args, RuntimeHelpers.GetTargetArgsRestrictions(target, args, false),
                                        typeof(MissingMemberException),
                                        String.Format(RuntimeMessages.MemberIsNotInvokable_MemberNameTypeName, found.Name, typeTracker.Name), args.ToString());
                    }
                    return ResolveOverload(null, args, tracker.Methods, BindingRestrictions.GetInstanceRestriction(target.Expression, typeTracker));
                }

                return getMethodNotFoundDMO();
            }

            MethodInfo[] methods = target.Value.GetType().GetMethods(BindingFlags.Instance | BindingFlags.Public).Where(m => m.Name == Name).ToArray();

            if(methods.Length != 0)
                return this.ResolveOverload(target, args, methods);

            return getMethodNotFoundDMO();
        }

        public override DynamicMetaObject BindSetIndex(SetIndexBinder binder, DynamicMetaObject[] indexes, DynamicMetaObject value) {
            ContractUtils.RequiresNotNull(binder, "binder");

            if (indexes.Any(arg => ComBinderHelpers.IsStrongBoxArg(arg))) {
                return ComBinderHelpers.RewriteStrongBoxAsRef(binder, this, indexes.AddLast(value), true);
            }

            ComMethodDesc setItem;
            if (_self.TryGetSetItem(out setItem)) {
                return BindComInvoke(indexes.AddLast(value), setItem, binder.Arguments);
            }

            return base.BindSetIndex(binder, indexes, value);
        }