.Net Core基于Emit动态代理从零实现RPC 初级实现

最新推荐文章于 2024-04-30 21:37:37 发布
最新推荐文章于 2024-04-30 21:37:37 发布
阅读量291 收藏
点赞数 1
分类专栏： NET Core跨平台+CoreCLR+C# 文章标签： .netcore rpc
原文链接：https://blog.csdn.net/WuLex
版权

上篇文章，我们已经能从零实现动态代理了，其实就是类的代理，这节课，我们就基于动态代理技术，实现RPC功能。

概念之类的上节文章，也讲了。如果有不懂的，可以看上节文章。

废话不多说，开搞。

这节文章，代码偏多，就看代码就成了。

内容还是偏多，这节也算是代码级简单实现，后面还会有一节，搞完整案例的。

实现RPC的原理

描述一下，RPC的实现过程。

假设服务端 有一个服务，对外提供一个地址，假设是 127.0.0.1:80

然后，客户端要调用服务端的方法，那么，连接服务端，这是必须的，但是，服务端有什么方法呢。

服务端要公开它自己的类接口信息。

如下：

public interface IDemo
{
    void Say();
}

那么，客户端要调用服务端，直接一个接口，客户端，也不会用啊。

就需要客户端自己new一个代理服务类的对象出来。

/// <summary>
/// 实现服务端的类接口
/// </summary>
public class Demo : IDemo
{
    public void Say()
    {
    }
}

那么，如何调用服务端的方法呢或者说，如何与服务端通信呢。

这里就需要一个代理对象了。这个对象把客户端需要调用的类，方法，参数，传给服务端，服务端处理后，返回客户端，然后，客户端就收到了相关信息。

方法就变成了下面这个样子

/// <summary>
/// 具体的类
/// </summary>
public class Demo : IDemo
{
    ServerProxy serverProxy = new ServerProxy();
    public void Say()
    {
        var result = serverProxy.Invok(nameof(Demo), nameof(Demo.Say), null);
        return;
    }
}
public class ServerProxy
{
    public object Invok(string classname, string method, string args)
    {
        return null;
    }
}

所以，RPC的实现，就是构造一个服务端的接口的实现，并发送相应接口方法的参数信息，通过，一个内置的代理服务对象通讯。

基于上述原理的实现

服务端接口

尽量类型包含足够多，但是，没有包含泛型，有想法的同学可以多尝试一下。

public interface IDemo
{
    void Say();
    string Say(string msg);
    int Say(string a, int b, List<string> c, Kind kind);
    string Say(int b, List<string> c, Kind kind);
 
    List<string> Test { get; set; }
}
public enum Kind
{
    a,
    b
}

DnamicInterfaceProxy.cs

核心代理类的实现

public class DnamicInterfaceProxy
{
    private static readonly string DllName;
    private static ModuleBuilder ModuleBuilder = null;
    private static AssemblyBuilder AssemblyBuilder = null;

    private static readonly ConcurrentDictionary<Type, Type> Maps = new ConcurrentDictionary<Type, Type>();
    static DnamicInterfaceProxy()
    {
        var assemblyName = new AssemblyName(nameof(DnamicInterfaceProxy));
        DllName = assemblyName.Name + ".dll";
        AssemblyBuilder = AssemblyBuilder.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.Run);
        ModuleBuilder = AssemblyBuilder.DefineDynamicModule(DllName);
    }
    public static T Resolve<T>() where T : class
    {
        var hanlder = new DefaultInvocationHandler<T>();
        var interfaceType = typeof(T);
        if (interfaceType?.IsInterface != true)
        {
            throw new ArgumentException("interfaceType");
        }
        Maps.TryGetValue(interfaceType, out Type newType);
        if (newType == null)
        {
            newType = CreateType(interfaceType);
            Maps.TryAdd(interfaceType, newType);
        }
        return (T)Activator.CreateInstance(newType, hanlder);
    }
    public static void Save()
    {
        AssemblyBuilder.Save(DllName);
    }
    private static Type CreateType(Type interfaceType)
    {
        var tb = ModuleBuilder.DefineType(string.Format("{0}.{1}", typeof(DnamicInterfaceProxy).FullName, interfaceType.Name));
        tb.AddInterfaceImplementation(interfaceType);

        var fb = tb.DefineField("_handler", typeof(InvocationHandler), FieldAttributes.Private);

        CreateConstructor(tb, fb);
        CreateMethods(interfaceType, tb, fb);
        CreateProperties(interfaceType, tb, fb);

        return tb.CreateType();
    }
    private static void CreateConstructor(TypeBuilder tb, FieldBuilder fb)
    {
        var ctor = tb.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, new Type[] { typeof(InvocationHandler) });
        var il = ctor.GetILGenerator();

        il.Emit(OpCodes.Ldarg_0);
        il.Emit(OpCodes.Ldarg_1);
        il.Emit(OpCodes.Stfld, fb);
        il.Emit(OpCodes.Ret);
    }

    private static void CreateMethods(Type interfaceType, TypeBuilder tb, FieldBuilder fb)
    {
        foreach (MethodInfo met in interfaceType.GetMethods())
        {
            CreateMethod(met, tb, fb);
        }
    }
    private static MethodBuilder CreateMethod(MethodInfo met, TypeBuilder tb, FieldBuilder fb)
    {
        var args = met.GetParameters();
        var mb = tb.DefineMethod(met.Name, MethodAttributes.Public | MethodAttributes.NewSlot | MethodAttributes.Virtual | MethodAttributes.Final | MethodAttributes.HideBySig,
            met.CallingConvention, met.ReturnType, args.Select(t => t.ParameterType).ToArray());
        var il = mb.GetILGenerator();
        il.DeclareLocal(typeof(object[]));

        if (met.ReturnType != typeof(void))
        {
            il.DeclareLocal(met.ReturnType);
        }

        il.Emit(OpCodes.Nop);
        il.Emit(OpCodes.Ldc_I4, args.Length);
        il.Emit(OpCodes.Newarr, typeof(object));
        il.Emit(OpCodes.Stloc_0);

        for (int i = 0; i < args.Length; i++)
        {
            il.Emit(OpCodes.Ldloc_0);
            il.Emit(OpCodes.Ldc_I4, i);
            il.Emit(OpCodes.Ldarg, 1 + i);
            var type = args[i].ParameterType;
            if (type.IsValueType)
            {
                il.Emit(OpCodes.Box, type);
            }
            il.Emit(OpCodes.Stelem_Ref);
        }

        il.Emit(OpCodes.Ldarg_0);
        il.Emit(OpCodes.Ldfld, fb);

        il.Emit(OpCodes.Ldarg_0);
        il.Emit(OpCodes.Ldc_I4, met.MetadataToken);
        il.Emit(OpCodes.Ldstr, met.DeclaringType?.FullName + "+" + met.Name);
        il.Emit(OpCodes.Ldloc_0);
        il.Emit(OpCodes.Call, typeof(InvocationHandler).GetMethod(nameof(InvocationHandler.InvokeMember), BindingFlags.Instance | BindingFlags.Public));

        if (met.ReturnType == typeof(void))
        {
            il.Emit(OpCodes.Pop);
        }
        else
        {
            il.Emit(met.ReturnType.IsValueType ? OpCodes.Unbox_Any : OpCodes.Castclass, met.ReturnType);
            il.Emit(OpCodes.Stloc_1);
            il.Emit(OpCodes.Ldloc_1);
        }
        il.Emit(OpCodes.Ret);

        return mb;
    }
    private static void CreateProperties(Type interfaceType, TypeBuilder tb, FieldBuilder fb)
    {
        foreach (var prop in interfaceType.GetProperties())
        {
            var pb = tb.DefineProperty(prop.Name, PropertyAttributes.SpecialName, prop.PropertyType, Type.EmptyTypes);
            var met = prop.GetGetMethod();
            if (met != null)
            {
                var mb = CreateMethod(met, tb, fb);
                pb.SetGetMethod(mb);
            }
            met = prop.GetSetMethod();
            if (met != null)
            {
                var mb = CreateMethod(met, tb, fb);
                pb.SetSetMethod(mb);
            }
        }
    }
}

代理对象 InvocationHandler.cs

一个简单的实现，只做打印内容。实际业务中，它会发送给服务端执行后，并返回到客户端来。
其实，就是套壳。如果能理解的话。

/// <summary>
/// 内置代理对象
/// </summary>
public interface InvocationHandler
{
    object InvokeMember(object obj, int rid, string name, params object[] args);
}
public class DefaultInvocationHandler<T> : InvocationHandler
{
    public object InvokeMember(object sender, int methodId, string name, params object[] args)
    {
        //服务端调用的时候会用
        var met = (MethodInfo)typeof(T).Module.ResolveMethod(methodId);
        string[] names = name.Split('+');
        var NameSpace = names[0];
        var Method = names[1];
        var Parameters = new List<object>(args);
        Console.WriteLine($"{NameSpace}.{Method}({string.Join(",", Parameters)})");
        return null;
    }
}

测试端

这是基于.Net Fw写的，好处是能保存dll到本地，有助于查看结构信息。

static void Main(string[] args)
{
    var demo = DnamicInterfaceProxy.Resolve<IDemo>();
    demo.Say();
    demo.Say("123");
    demo.Say(5, new List<string>() { "1", "2", "3" }, Kind.a);
    demo.Say("demo", 6, new List<string>() { "6" }, Kind.b);
    demo.Test = new List<string>() { "11", "12" };
    var b = demo.Test;
    DnamicInterfaceProxy.Save();
    Console.ReadLine();
}

结果如下

在这里插入图片描述

从结果看，我们把相应的信息都获取到了。

我们可以先看反射生成的是不是我们需要的DLL结构

反射DLL


// Token: 0x02000002 RID: 2
	internal class IDemo : IDemo
	{
		// Token: 0x06000001 RID: 1 RVA: 0x00002050 File Offset: 0x00000250
		public IDemo(InvocationHandler A_1)
		{
		}

		// Token: 0x06000002 RID: 2 RVA: 0x00002064 File Offset: 0x00000264
		public void Say()
		{
			object[] args = new object[0];
			this._handler.InvokeMember(this, 100663311, "RPCDemo.IDemo+Say", args);
		}

		// Token: 0x06000003 RID: 3 RVA: 0x00002098 File Offset: 0x00000298
		public string Say(string A_1)
		{
			object[] args = new object[]
			{
				A_1
			};
			return (string)this._handler.InvokeMember(this, 100663312, "RPCDemo.IDemo+Say", args);
		}

		// Token: 0x06000004 RID: 4 RVA: 0x000020DC File Offset: 0x000002DC
		public int Say(string A_1, int A_2, List<string> A_3, Kind A_4)
		{
			object[] args = new object[]
			{
				A_1,
				A_2,
				A_3,
				A_4
			};
			return (int)this._handler.InvokeMember(this, 100663313, "RPCDemo.IDemo+Say", args);
		}

		// Token: 0x06000005 RID: 5 RVA: 0x00002154 File Offset: 0x00000354
		public string Say(int A_1, List<string> A_2, Kind A_3)
		{
			object[] args = new object[]
			{
				A_1,
				A_2,
				A_3
			};
			return (string)this._handler.InvokeMember(this, 100663314, "RPCDemo.IDemo+Say", args);
		}

		// Token: 0x17000001 RID: 1
		// (get) Token: 0x06000006 RID: 6 RVA: 0x000021BC File Offset: 0x000003BC
		// (set) Token: 0x06000007 RID: 7 RVA: 0x000021F4 File Offset: 0x000003F4
		public List<string> Test
		{
			get
			{
				object[] args = new object[0];
				return (List<string>)this._handler.InvokeMember(this, 100663315, "RPCDemo.IDemo+get_Test", args);
			}
			set
			{
				object[] args = new object[]
				{
					value
				};
				this._handler.InvokeMember(this, 100663316, "RPCDemo.IDemo+set_Test", args);
			}
		}

		// Token: 0x06000008 RID: 8 RVA: 0x00002234 File Offset: 0x00000434
		public List<string> get_Test()
		{
			object[] args = new object[0];
			return (List<string>)this._handler.InvokeMember(this, 100663315, "RPCDemo.IDemo+get_Test", args);
		}

		// Token: 0x06000009 RID: 9 RVA: 0x0000226C File Offset: 0x0000046C
		public void set_Test(List<string> A_1)
		{
			object[] args = new object[]
			{
				A_1
			};
			this._handler.InvokeMember(this, 100663316, "RPCDemo.IDemo+set_Test", args);
		}

		// Token: 0x04000001 RID: 1
		private InvocationHandler _handler = A_1;
	}

看不清楚，可以看图
在这里插入图片描述
在这里插入图片描述

也是完全实现了的，当然，也有很多的细节，想研究的朋友可以深入研究一下。

总结

从完整性上来讲，此项目已经非常完整了。可以根据这项目开发基于自己的RPC项目了。

从 DefaultInvocationHandler 来进行实现。

风神.NET
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
.NET动态代理介绍
11-01
.NET有关的代码，简介，及编程示例的具体介绍与分析
.netCore用DispatchProxy实现动态代理
helldoger的博客
10-06 473
然后，通过调用 MyProxy.Create 方法，你可以创建一个代理对象，该对象实现了你指定的接口或类，并且会拦截方法调用并执行你的逻辑。DispatchProxy 允许你在运行时创建一个代理对象，该代理对象可以拦截对其所代理的对象的方法调用，并在方法调用前后执行自定义的逻辑。当你使用动态代理时，你可以创建一个中间对象（代理对象），该对象可以拦截对另一个对象（目标对象）的方法调用，并在方法调用前后执行自定义的逻辑。它的作用是生成一个代理类，该代理类实现了一个接口，并在接口的方法调用时执行自定义的操作。
Emit实现动态代理
07-31
Emit实现动态代理 参照java的动态代理的使用感觉实现C#版
TypeMerger:.NET Core的基于约定的简单对象合并
05-05
TypeMerger-将两个对象合并为一个 TypeMerger是.NET Core的基于约定的简单对象合并。 它允许将任何类型的两个对象合并到一个新的Type 。 使用流利的api可以忽略对象属性，并且可以解决任何冲突。 返回的对象是使用System.Reflection.Emit动态生成和加载的新Type 。 依存关系 没有任何 如何使用？ 使用简单 这将导致一个新对象具有obj1和obj2的所有属性。 var result = TypeMerger.Merge(obj1, obj2); 忽略某些属性 这将导致具有所有从OBJ1和OBJ2的属性除了新对象SomeProperty从OBJ1和AnotherProperty从OBJ 2。 var result = TypeMerger.Ignore(() => obj1.SomeProperty)
gremit：.NET Reflection.Emit扩展
02-05
格罗米特 GrEmit是一个包含不同助手的库，用于使用Reflection.Emit生成代码，主要的是GroboIL- 的智能包装器。 用法 GroboIL替代了ILGenerator。 除了调用ILGenerator.Emit（OpCode，..），还可以调用GroboIL.OpCode（..）。 例 ILGenerator： // .. creating DynamicMethod, MethodBuilder or ConstructorBuilder var il = method.GetILGenerator(); il.Emit(OpCodes.Ldarg_0); il.Emi
.net实现的rpc远程调用原理
08-27
介绍了.net环境下rpc远程调用，包括信道远程对象，注册，激活，代理获取等。通过代码运行更好的理解rpc调用的真个过程。
.Net Core RPC 从零开发到完整 案例版
蓝创精英团队
06-20 1022
谈论到实现RPC，不可避免的就要讨论一个问题，啥是gRpc，gRpc是由谷歌实现的一个PRC，为啥带了个g呢。这就是grpc 存在的优势了。我们自己实现的话，可以通过http实现通讯，也可以通过socket 实现，websocket实现。通讯协议，也可以自定义，也可以用json，也可以用谷歌的ProtoBuf来进行实现。这都不是问题，但是，要向完整实现gRpc那种就难很多了。但是，作为参考也是很不错的选择。下面我就基于之前写过的Netty来作为通讯方式，以json为通讯数据格式，来实现一个完整的RPC案 例
.net下通过GRPC完成RPC通讯
xuwei_net的专栏
10-30 3220
威哥一直琢磨着怎么搭建.net下的微服务，但是要实现微服务，必须要解决进程间的服务接口通讯，总不能做出了微服务体系，结果在一个局域网机制内的分布式服务间的通讯还得走rest的Http请求，这不是明显的资源浪费吗。所以威哥尝试了Google的Grpc。 GRPC是一个开源RPC框架，于2015年3月开源，其由Google主要面向移动应用开发并基于HTTP/2协议标准而设计，基于Protobuf 3...
Web后台快速开发框架
weixin_30845171的博客
09-11 3128
Web后台快速开发框架 Coldairarrow 目录 目录 第1章目录1 第2章简介3 第3章基础准备4 3.1开发环境要求4 3.2基础数据库构建4 3.3运行5 第4章详细教程6 4.1代码架构6 4.1.1总体架构6 ...
.net 动态代理实现
08-23 334
1、先新建一个要被代理的类，必须实现 MarshalByRefObject。3、创建代理类 必须继承 RealProxy类。2、创建类 用于代理类执行方法。
AOP从静态代理到动态代理（Emit实现）详解
01-21
【前言】 AOP（Aspect Orient Programming），我们一般称为面向方面（切面）编程，作为面向对象的一种补充，用于处理系统中分布于各个模块的横切关注点，比如事务管理、日志、缓存等等。AOP实现的关键在于AOP框架自动创建的AOP代理，AOP代理主要分为静态代理和动态代理，静态代理的代表为AspectJ；而动态代理则以Spring AOP为代表。 何为切面？ 一个和业务没有任何耦合相关的代码段，诸如：调用日志，发送邮件，甚至路由分发。一切能为代码所有且能和代码充分解耦的代码都可以作为一个业务代码的切面。 我们为什么要AOP？ 那我们从一个场景举例说起： 如果想要采集用户操作行
net RPC 架构选型
06-13
netcore Rpc框架选型，值得拥有，微服务架构必看书籍。。
.NET(C#):Emit创建异常处理的方法
12-25
Emit异常处理流程 显示Exception对象的Message属性 返回目录 Emit异常处理流程来看这种C#异常处理代码： 代码如下: static void doo(Exception e)  {  try  {  throw e;  }  catch (ApplicationException ex...
Asp .Net Core 系列：国际化多语言配置
程序人生
04-28 1356
全球化 (G11N)：使应用支持不同语言和区域的过程。缩写来自第一个和最后一个字母以及它们之间的字母数。本地化 (L10N)：针对特定语言和区域自定义全球化应用的过程。国际化 (I18N)：包括全球化和本地化。区域性：一种语言和/或区域。非特定区域性：具有指定语言但不具有区域的区域性（例如“en”、“es”）。特定区域性：具有指定语言但和区域的区域性（例如“en-US”、“en-GB”、“es-CL”）。父区域性：包含特定区域性的非特定区域性。
.net core ef 连表查询
最新发布
qq_38188762的博客
04-30 604
在Information.cs实体类新增 public TypeInfo TypeInfo { get;Information和TypeInfo连表查询。先在EfCoreDbContext.cs配置。
开源博客项目Blog .NET Core源码学习（20：App.Hosting项目结构分析-8）
gc_2299的博客
04-29 578
学习并分析App.Hosting项目中后台管理页面的个人资料页面、修改密码页面。
闲话 Asp.Net Core 数据校验（三）EF Core 集成 FluentValidation 校验数据例子
yangshuquan的专栏
04-29 954
一个在实际应用中 EF Core 集成 FluentValidation 进行数据校验的例子
闲话 ASP.NET Core 数据校验（二）：FluentValidation 基本用法
yangshuquan的专栏
04-28 1012
除了使用 ASP.NET Core 内置框架来校验数据，事实上，通过很多第三方框架校验数据，更具优势，比如 FluentValidation
手动实现简易版RPC(三)
Jerrylau213的博客
04-29 984
3-手动造轮子实现rpc之mock
.net core 实现动态api
09-07
总之，通过利用.NET Core的反射和表达树功能，我们可以在运行时动态创建API，从而实现灵活、可扩展和可定制的动态API。 ### 回答3： .NET Core 实现动态 API 的方式有很多，下面我将介绍一种常见的方法。 在.NET ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值