예제 #1
0
        internal static object InvokeDirectCallSite(object target, object[] args, string[] tArgNames, Type tContext, bool tStaticContext, ref CallSite callSite)
        {
            LazyBinder tBinder     = null;
            Type       tBinderType = null;

            if (callSite == null)
            {
                tBinder = () => {
                    var tList = GetBindingArgumentList(args, tArgNames, tStaticContext);
                    var tFlag = CSharpBinderFlags.None;
                    return(Binder.Invoke(tFlag, tContext, tList));
                };
                tBinderType = typeof(InvokeBinder);
            }

            return(InvokeMember <object>(ref callSite, tBinderType, tBinder, String.Empty, tStaticContext, tContext, tArgNames, target, args));
        }
예제 #2
0
        internal static void InvokeDirectActionCallSite(object target, object[] args, string[] tArgNames, Type tContext, bool tStaticContext, ref CallSite callSite)
        {
            LazyBinder tBinder     = null;
            Type       tBinderType = null;

            if (callSite == null)
            {
                tBinder = () => {
                    IEnumerable <CSharpArgumentInfo> tList;
                    tList = GetBindingArgumentList(args, tArgNames, tStaticContext);

                    var tFlag = CSharpBinderFlags.ResultDiscarded;

                    return(Binder.Invoke(tFlag, tContext, tList));
                };
                tBinderType = typeof(InvokeBinder);
            }

            InvokeMemberAction(ref callSite, tBinderType, tBinder, String.Empty, tStaticContext, tContext, tArgNames, target, args);
        }
예제 #3
0
                //
                // Creates an invoke call on invocable expression
                //
                public override System.Linq.Expressions.Expression MakeExpression(Compiler.BuilderContext ctx)
                {
                    var invokeBinder = invoke.invokeBinder;
                    var binder       = Binder.Invoke(invokeBinder.flags, invokeBinder.callingContext, invokeBinder.argumentInfo);

                    var args      = invoke.Arguments;
                    var args_expr = new SLE.Expression[invokeBinder.argumentInfo.Count];

                    var types = new Type [args_expr.Length + 2];

                    // Required by MakeDynamic
                    types[0] = typeof(System.Runtime.CompilerServices.CallSite);
                    types[1] = expr.Type.GetMetaInfo();

                    args_expr[0] = expr.MakeExpression(ctx);

                    for (int i = 0; i < args.Count; ++i)
                    {
                        args_expr[i + 1] = args[i].Expr.MakeExpression(ctx);

                        int type_index = i + 2;
                        types[type_index] = args[i].Type.GetMetaInfo();
                        if (args[i].IsByRef)
                        {
                            types[type_index] = types[type_index].MakeByRefType();
                        }
                    }

                    // Return type goes last
                    bool void_result = (invokeBinder.flags & CSharpBinderFlags.ResultDiscarded) != 0;

                    types[types.Length - 1] = void_result ? typeof(void) : invokeBinder.ReturnType;

                    //
                    // Much easier to use Expression.Dynamic cannot be used because it ignores ByRef arguments
                    // and it always generates either Func or Action and any value type argument is lost
                    //
                    Type delegateType = SLE.Expression.GetDelegateType(types);

                    return(SLE.Expression.MakeDynamic(delegateType, binder, args_expr));
                }
        internal static object InvokeDirectCallSite(object target, object[] arguments, string[] argumentNames,
                                                    Type context, bool staticContext, ref CallSite callSite)
        {
            LazyBinder binder     = null;
            Type       binderType = null;

            if (callSite == null)
            {
                binder = () =>
                {
                    var bindingArgumentList = GetBindingArgumentList(arguments, argumentNames,
                                                                     staticContext);
                    var flag = CSharpBinderFlags.None;
                    return(Binder.Invoke(flag, context, bindingArgumentList));
                };
                binderType = typeof(InvokeBinder);
            }

            return(InvokeMember <object>(ref callSite, binderType, binder, String.Empty, staticContext, context,
                                         argumentNames, target, arguments));
        }
        internal static void InvokeDirectActionCallSite(object target, object[] arguments, string[] argumentNames,
                                                        Type context, bool staticContext, ref CallSite callSite)
        {
            LazyBinder binder     = null;
            Type       binderType = null;

            if (callSite == null)
            {
                binder = () =>
                {
                    var bindingArgumentList = GetBindingArgumentList(arguments, argumentNames,
                                                                     staticContext);

                    var flag = CSharpBinderFlags.ResultDiscarded;

                    return(Binder.Invoke(flag, context, bindingArgumentList));
                };
                binderType = typeof(InvokeBinder);
            }

            MemberActionInvoke(ref callSite, binderType, binder, String.Empty, staticContext, context, argumentNames,
                               target, arguments);
        }