Пример #1
0
        public override IMessage Invoke(IMessage reqMsg)
        {
            IMethodCallMessage ctorMsg = reqMsg as IMethodCallMessage;

            if (Call != null)
            {
                List <RPCArgument> arglist = new List <RPCArgument>();

                Type[]   types = ctorMsg.MethodSignature as Type[];
                object[] args  = ctorMsg.Args;

                for (int i = 0; i < ctorMsg.ArgCount; i++)
                {
                    RPCArgument tmp = new RPCArgument();
                    tmp.RefType = types[i];
                    tmp.type    = args[i].GetType();
                    tmp.Value   = Serialization.PackSingleObject(tmp.type, args[i]);
                    arglist.Add(tmp);
                }

                ReturnValue returnval = Call(ModuleName, ctorMsg.MethodName, arglist);


                return(new ReturnMessage(returnval.returnVal, returnval.Args, returnval.Args == null ? 0 : returnval.Args.Length, null, ctorMsg));
            }


            throw new Exception("event not register");
        }
Пример #2
0
        public override IMessage Invoke(IMessage reqMsg)
        {
            IMethodCallMessage ctorMsg = reqMsg as IMethodCallMessage;

            if (Call != null)
            {
                List <byte[]> arglist = new List <byte[]>();

                Type[] types = ctorMsg.MethodSignature as Type[];

                List <Type> argsType = new List <Type>(ctorMsg.ArgCount);

                object[] args = ctorMsg.Args;

                for (int i = 0; i < ctorMsg.ArgCount; i++)
                {
                    argsType.Add(args[i].GetType());
                    arglist.Add(Serialization.PackSingleObject(argsType[i], args[i]));
                }


                ReturnValue returnval = Call(ModuleName, MakeID.MakeMethodName(ctorMsg.MethodName, types), argsType, arglist, (ctorMsg.MethodBase as MethodInfo).ReturnType);

                if (returnval.Args == null)
                {
                    returnval.Args = args;
                }

                return(new ReturnMessage(returnval.returnVal, returnval.Args, returnval.Args == null ? 0 : returnval.Args.Length, null, ctorMsg));
            }


            throw new Exception("event not register");
        }
Пример #3
0
        /// <summary>
        /// 同步调用返回
        /// </summary>
        /// <typeparam name="Mode"></typeparam>
        /// <typeparam name="Result"></typeparam>
        /// <param name="action"></param>
        /// <returns></returns>
        public Result Call <Mode, Result>(Expression <Func <Mode, Result> > action)
        {
            MethodCallExpression body = action.Body as MethodCallExpression;

            List <RPCArgument> argumentlist = new List <RPCArgument>();

            var parameters = body.Method.GetParameters();

            for (int i = 0; i < parameters.Length; i++)
            {
                dynamic p = Expression.Call(FormatValue.GetMethodInfo(body.Arguments[i].Type), body.Arguments[i]);
                dynamic x = Expression.Lambda <Func <dynamic> >(p).Compile()();

                RPCArgument tmp = new RPCArgument();
                tmp.type    = body.Arguments[i].Type;
                tmp.RefType = parameters[i].ParameterType;
                tmp.Value   = Serialization.PackSingleObject(body.Arguments[i].Type, x);
                argumentlist.Add(tmp);
            }

            object[] args;

            Result res = CallMethod <Result>(body.Object.Type.Name, body.Method.Name, argumentlist, out args);

            if (args != null)
            {
                if (args.Length == body.Arguments.Count)
                {
                    for (int i = 0; i < args.Length; i++)
                    {
                        if (body.Arguments[i].NodeType == ExpressionType.MemberAccess)
                        {
                            var set = Expression.Assign(body.Arguments[i], Expression.Constant(args[i]));

                            Expression.Lambda <Action>(set).Compile()();
                        }
                    }
                }
            }

            return(res);
        }
Пример #4
0
        /// <summary>
        /// 异步调用,返回值后调用 Callback
        /// </summary>
        /// <typeparam name="Mode"></typeparam>
        /// <typeparam name="Result"></typeparam>
        /// <param name="action"></param>
        /// <param name="Callback"></param>
        public void CallAsyn <Mode, Result>(Expression <Func <Mode, Result> > action, Action <AsynReturn> Callback)
        {
            MethodCallExpression body = action.Body as MethodCallExpression;

            List <RPCArgument> argumentlist = new List <RPCArgument>();

            var parameters = body.Method.GetParameters();

            for (int i = 0; i < parameters.Length; i++)
            {
                dynamic p = Expression.Call(FormatValue.GetMethodInfo(body.Arguments[i].Type), body.Arguments[i]);
                dynamic x = Expression.Lambda <Func <dynamic> >(p).Compile()();

                RPCArgument tmp = new RPCArgument();
                tmp.type    = body.Arguments[i].Type;
                tmp.RefType = parameters[i].ParameterType;
                tmp.Value   = Serialization.PackSingleObject(body.Arguments[i].Type, x);
                argumentlist.Add(tmp);
            }



            RPCCallPack call = new RPCCallPack()
            {
                Id           = MakeID.GetID(),
                CallTime     = DateTime.Now,
                CallModule   = body.Object.Type.Name,
                Method       = body.Method.Name,
                Arguments    = argumentlist,
                IsNeedReturn = true,
            };

            byte[] data = BufferFormat.FormatFCA(call);

            if (CallBufferOutSend != null)
            {
                CallBufferOutSend(data);
            }


            AsynRetrunDiy.AddOrUpdate(call.Id, Callback, (a, b) => Callback);
        }
Пример #5
0
        public bool RunModule(RPCCallPack tmp, out object returnValue)
        {
            returnValue = null;

            if (ModuleDiy.ContainsKey(tmp.CallModule))
            {
                object o = ModuleDiy[tmp.CallModule];

                Type _type = o.GetType();

                if (tmp.Arguments == null)
                {
                    tmp.Arguments = new List <RPCArgument>();
                }



                object[] arguments = new object[tmp.Arguments.Count];

                Type[] argumentstype = new Type[tmp.Arguments.Count];

                for (int i = 0; i < tmp.Arguments.Count; i++)
                {
                    argumentstype[i] = tmp.Arguments[i].RefType;
                    arguments[i]     = Serialization.UnpackSingleObject(tmp.Arguments[i].type, tmp.Arguments[i].Value);
                }


                MethodInfo method = null;

                if (argumentstype.Length > 0)
                {
                    method = _type.GetMethod(tmp.Method, argumentstype);
                }
                else
                {
                    method = _type.GetMethod(tmp.Method);
                }

                if (method != null)
                {
                    returnValue = method.Invoke(o, arguments);

                    for (int i = 0; i < arguments.Length; i++)
                    {
                        tmp.Arguments[i].Value = Serialization.PackSingleObject(arguments[i].GetType(), arguments[i]);
                    }

                    return(true);
                }
                else
                {
                    string msg = "Not find " + tmp.CallModule + "-> public " + tmp.Method + "(";
                    int    l   = 0;
                    foreach (var item in argumentstype)
                    {
                        l++;
                        msg += item.Name;
                        if (l < argumentstype.Length)
                        {
                            msg += ",";
                        }
                    }
                    msg += ")";

                    if (ErrMsgOut != null)
                    {
                        ErrMsgOut(msg);
                    }

                    return(false);
                }
            }
            else
            {
                string msg = "Not find " + tmp.CallModule;

                if (ErrMsgOut != null)
                {
                    ErrMsgOut(msg);
                }
            }


            return(false);
        }
Пример #6
0
        public bool RunModule(RPCCallPack tmp, out object returnValue)
        {
            returnValue = null;

            if (ModuleDiy.ContainsKey(tmp.CallModule))
            {
                var module = ModuleDiy[tmp.CallModule];

                if (module.MethodInfoDiy.ContainsKey(tmp.Method))
                {
                    var method = module.MethodInfoDiy[tmp.Method];

                    if (tmp.Arguments != null)
                    {
                        object[] arguments = new object[method.ArgsType.Length];


                        for (int i = 0; i < tmp.Arguments.Count; i++)
                        {
                            arguments[i] = Serialization.UnpackSingleObject(method.ArgsType[i], tmp.Arguments[i]);
                        }


                        returnValue = method.methodInfo.Invoke(module.Token, arguments);

                        if (method.IsOut)
                        {
                            for (int i = 0; i < arguments.Length; i++)
                            {
                                tmp.Arguments[i] = Serialization.PackSingleObject(method.ArgsType[i], arguments[i]);
                            }
                        }
                        else
                        {
                            tmp.Arguments = null;
                        }

                        return(true);
                    }
                    else
                    {
                        returnValue = method.methodInfo.Invoke(module.Token, null);
                        return(true);
                    }
                }
                else
                {
                    string msg = "Not find " + tmp.CallModule + "-> public " + tmp.Method;

                    if (ErrMsgOut != null)
                    {
                        ErrMsgOut(msg);
                    }

                    return(false);
                }
            }
            else
            {
                string msg = "Not find " + tmp.CallModule;

                if (ErrMsgOut != null)
                {
                    ErrMsgOut(msg);
                }
            }


            return(false);
        }