.Net kRpc 自己实现代码

AOP 动态代理可以参考此项目  : https://blog.csdn.net/i2blue/article/details/115569790

Netty 高性能服务IO可以参考此项目 : https://blog.csdn.net/i2blue/article/details/106149261

 

实现的效果如下 
客户端 代码

        static void Main(string[] args)
        {
            var client = RpcClientFactory.GetClient("127.0.0.1", 999);
            client.Start();
            Console.WriteLine("客户端开始连接!");


            var demo = client.Resolve<IDemo>();
            demo.Say();
            Console.WriteLine(demo.Say("123"));
            Console.WriteLine(demo.Say("demo", 6, new List<string>() { "6" }, Kind.b));
            demo.Test = new List<string>() { "11", "12" };
            Console.WriteLine(string.Join(",", demo.Test));
            Console.WriteLine("不错，完成了任务!");

            while (Console.ReadLine().StartsWith("Exit", StringComparison.InvariantCultureIgnoreCase))
            {
                break;
            }
            Console.ReadLine();
        }

服务端 代码:

        static void Main(string[] args)
        {
            var server = new NettyRpcServer(999);
            server.RegisterService<IDemo, Demo>();
            server.Start();


            Console.WriteLine("服务启动");
            Console.ReadLine();
        }

以下是具体的效果

单个客户端

多个客户端

效果也很明显，

新增一个服务端容器类

    public static class RpcConatiner
    {
        private static ConcurrentDictionary<string, object> ServiceContainer = new ConcurrentDictionary<string, object>();
        private static ConcurrentDictionary<string, Type> ServiceTypeContainer = new ConcurrentDictionary<string, Type>();
        static RpcConatiner()
        {
            Initialize();
        }

        private static void Initialize()
        {
            try
            {
                foreach (var assembly in  AppDomain.CurrentDomain.GetAssemblies())
                {
                    foreach (var type in assembly.GetTypes())
                    {
                        RpcServiceAttribute attribute = type.GetCustomAttribute<RpcServiceAttribute>();
                        if (attribute != null)
                        {
                            var obj = Activator.CreateInstance(type);
                            foreach (var iInterface in type.GetInterfaces())
                            {
                                ServiceContainer.AddOrUpdate(iInterface.FullName, obj, (k, v) => obj);
                            }
                        }
                    }
                }
            }
            catch
            {
                throw;
            }
        }
        public static void RegisterService<IService, Service>() where Service : class, IService where IService : class
        {
            ServiceTypeContainer.AddOrUpdate(typeof(IService).FullName, typeof(Service), (k, v) => typeof(Service));
        }
        public static RpcResponse Invoke(RpcRequest request)
        {
            var rpcResponse = new RpcResponse() { Code = 1, Message = "未知错误", Request = request };
            rpcResponse.SetState($"{request.NameSpace} 命名空间未存在!");
            if (ServiceContainer.TryGetValue(request.NameSpace, out object obj))
            {
                rpcResponse.SetState($"{request.Method} 方法未存在!");
                try
                {
                    var Types = request.GetTypes();
                    var method = obj.GetType().GetMethod(request.Method, Types);
                    if (method != null)
                    {
                        rpcResponse.SetState($"执行结果异常!");
                        rpcResponse.Response = JsonConvert.SerializeObject(method.Invoke(obj, request.GetParameters(Types)));
                        rpcResponse.SetState(0, "成功");
                    }
                }
                catch (Exception ex)
                {
                    rpcResponse.SetState(-1, ex.Message);
                }
            }
            return rpcResponse;
        }
        private static Type[] GetTypes(this RpcRequest request)
        {
            var types = new List<Type>();
            foreach (var paramType in request.ParameterTypes)
            {
                Type type = GetType(paramType);
                if (type == null)
                {
                    return Type.EmptyTypes;
                }
                types.Add(type);
            }
            if (types.Any())
            {
                return types.ToArray();
            }
            return Type.EmptyTypes;
        }
        private static object[] GetParameters(this RpcRequest request, Type[] Types)
        {
            var list = new List<object>();
            if (Types == null || !Types.Any())
            {
                var types = request.GetTypes();
                if (types == null || !types.Any())
                {
                    return null;
                }
            }

            for (int i = 0; i < Types.Length; i++)
            {
                list.Add(JsonConvert.DeserializeObject(request.Parameters[i], Types[i]));
            }
            return list.ToArray();
        }
        private static Type GetType(string typeFullName)
        {
            if (ServiceTypeContainer.TryGetValue(typeFullName, out Type Type))
            {
                return Type;
            }
            foreach (Assembly ass in AppDomain.CurrentDomain.GetAssemblies())
            {
                Type type = ass.GetType(typeFullName);
                if (type != null)
                {
                    ServiceTypeContainer.TryAdd(type.FullName, type);
                    return type;
                }
            }
            return null;
        }
    }

流程就是，客户端获取接口的方法参数信息，传给服务器，服务器解析这些方法参数，调用 RpcConatiner.Invoke 方法，执行对象的方法，获取结果，并返回给客户端。

这样的流程。