c# RPC框架的使用简介

￡神魔★判官ぃ 2022-10-29 01:46 163阅读 0赞

写在前面：  
　　RPC，听过很有段时间了，但是一直都不太清楚是干嘛的，今天我们来捋一捋。

解释：  
　　【Remote Procedure Call Protocol】远程过程调用（就是说，A程序要调用一个b方法，然而这个b方法的实现在B程序内部，B程序还可能和A不在一个电脑上面，怎么调用？http可以调用/rpc也可以，让他像调用本地方法一样调用）

使用初探：  
　　用了一下市面上的，rpc框架，步骤如下：

1、写一个基本的代码，告诉有哪些方法。

2、然后服务端集成，

3、客户端集成，

4、OK调用生效了。

感觉有点像TCP在传输数据，从A服务器传递，传递类名，方法名，参数，值，然后B服务器拿到数据，计算结果，然后把数据在回传给A。。。这样理解一下的话，就很简单了。

下面动手写一个吧。

自己动手：  
　　服务端：

既然服务端是实现的地方，我们写一个算是实现类的方法试试：写了一个接口和一个实现，为了演示效果，写了两个方法。

1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
20  
21  
22  
23  
24  
public interface IMyTestService  
\{  
int calc(int x, int y);  
  
bool login(string name, string pwd);  
\}  
  
public class MyTestServiceImpl : IMyTestService  
\{  
public int calc(int x, int y)  
\{  
return x + y;  
\}  
  
public bool login(string name, string pwd)  
\{  
if (name == "test" && pwd == "123456")  
\{  
return true;  
\}  
  
return false;  
\}  
\}  
　　OK，服务端的大部分完成了。

然后就是TCP服务器，TCP服务器对大家来说，就太简单不过了，不就是创建一个Socket对象，绑定一个端口，获取客户端请求的Socket对象，然后和他交互么。没啥多说的。

1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
20  
21  
22  
23  
24  
25  
26  
27  
28  
29  
30  
31  
32  
33  
34  
35  
36  
37  
38  
39  
40  
41  
42  
43  
44  
45  
class Program  
\{  
static void Main(string\[\] args)  
\{  
Socket server = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);  
server.Bind(new IPEndPoint(IPAddress.Any, 10000));  
server.Listen(1000);  
  
Thread t = new Thread(Execute);  
t.IsBackground = true;  
t.Start(server);  
  
Console.WriteLine("rpc服务器已启动");  
Console.ReadLine();  
\}  
  
private static void Execute(Object obj)  
\{  
Socket server = obj as Socket;  
while (true)  
\{  
Socket client = server.Accept();  
  
Thread t = new Thread(SingleExecute);  
t.IsBackground = true;  
t.Start(client);  
\}  
\}  
  
private static void SingleExecute(object obj)  
\{  
// 读取  
Socket client = obj as Socket;  
  
byte\[\] buffer = new byte\[8192\];  
int count = client.Receive(buffer);  
if (count > 0)  
\{  
var data = ServiceHelpercs.Handle(buffer);  
client.Send(data);  
\}  
  
client.Shutdown(SocketShutdown.Both);  
\}  
\}  
　　我们假定，所有的客户端数据，可以在一个请求包里面解析掉，因为如果一次的数据接收不能解析，那就还要添加一个大小了，客户端要告诉我你给我了多少消息，然后我再读取指定数据，拿到所有的内容

这里创建，一个ServiceHelpers来帮助对，真实算法的调用。如下：

1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
20  
21  
22  
23  
24  
25  
26  
27  
28  
29  
30  
31  
32  
33  
34  
35  
36  
37  
38  
39  
40  
41  
42  
43  
44  
45  
46  
47  
48  
49  
50  
51  
52  
53  
54  
55  
56  
57  
58  
59  
60  
61  
62  
63  
64  
65  
66  
67  
68  
69  
70  
71  
72  
73  
74  
75  
76  
77  
78  
79  
80  
81  
82  
83  
84  
85  
86  
87  
88  
89  
90  
91  
92  
93  
94  
95  
96  
97  
98  
99  
100  
101  
102  
103  
104  
105  
106  
107  
108  
109  
110  
111  
112  
113  
114  
115  
116  
117  
118  
119  
public class ServiceHelpercs  
\{  
public static byte\[\] Handle(byte\[\] buffer)  
\{  
MemoryStream ms = new MemoryStream(buffer);  
BinaryReader br = new BinaryReader(ms);  
  
int inter\_len = br.ReadByte();  
string inter\_name = Encoding.UTF8.GetString(br.ReadBytes(inter\_len));  
  
int method\_len = br.ReadByte();  
string method\_name = Encoding.UTF8.GetString(br.ReadBytes(method\_len));  
  
int args\_length = br.ReadByte();  
int return\_type = br.ReadByte();  
  
List<object> list = new List<object>();  
for (int i = 0; i < args\_length; i++)  
\{　　　　　　　　 // 0:void 忽略 1:int 2:bool 3:string  
int arg\_type = br.ReadByte();  
if (arg\_type == 1)  
\{  
byte\[\] values = br.ReadBytes(4);  
list.Add(bytes2int(values));  
\}  
else if (arg\_type == 2)  
\{  
bool value = br.ReadByte() == 1;  
list.Add(value);  
\}  
else if (arg\_type == 3)  
\{  
int str\_len = bytes2int(br.ReadBytes(4));  
string str = Encoding.UTF8.GetString(br.ReadBytes(str\_len));  
list.Add(str);  
\}  
\}  
  
Type inter\_type = null;  
var types = Assembly.GetExecutingAssembly().GetTypes();  
foreach (var type in types)  
\{  
var ts = type.GetInterfaces();  
foreach (var t in ts)  
\{  
if (t.Name == inter\_name)  
\{  
inter\_type = type;  
break;  
\}  
\}  
\}  
  
MethodInfo invokeMethod = null;  
if (inter\_type != null)  
\{  
var methods = inter\_type.GetMethods();  
foreach (var method in methods)  
\{  
if (method.Name == method\_name)  
\{  
invokeMethod = method;  
break;  
\}  
\}  
\}  
  
if (invokeMethod != null)  
\{  
Object thisObj = Activator.CreateInstance(inter\_type);  
object result = invokeMethod.Invoke(thisObj, list.ToArray());  
if (return\_type == 1)  
\{  
int value = Convert.ToInt32(result);  
  
return int2bytes(value);  
\}  
else if (return\_type == 2)  
\{  
return new byte\[1\] \{ Convert.ToBoolean(result) ? (byte)1 : (byte)0 \};  
\}  
else if (return\_type == 2)  
\{  
List<byte> result\_data = new List<byte>();  
var str = (result == null ? "" : result.ToString());  
var data = Encoding.UTF8.GetBytes(str);  
  
result\_data.AddRange(int2bytes(data.Length));  
result\_data.AddRange(data);  
  
return result\_data.ToArray();  
\}  
\}  
  
return new byte\[1\] \{ 0xFF \};  
\}  
  
public static byte\[\] int2bytes(int len)  
\{  
byte\[\] data\_len = new byte\[4\];  
data\_len\[0\] = (byte)((len >> 8 \* 3) & 0xFF);  
data\_len\[1\] = (byte)((len >> 8 \* 2) & 0xFF);  
data\_len\[2\] = (byte)((len >> 8 \* 1) & 0xFF);  
data\_len\[3\] = (byte)(len & 0xFF);  
  
return data\_len;  
\}  
  
public static int bytes2int(byte\[\] buffer)  
\{  
int value = 0;  
value += (int)(buffer\[0\] << (8 \* 3));  
value += (int)(buffer\[1\] << (8 \* 2));  
value += (int)(buffer\[2\] << (8 \* 1));  
value += (int)(buffer\[3\]);  
  
return value;  
\}  
\}  
　　解析的类很简单，因为这里创建的数据结构很简单。

按照我们的约定，这里，对数据按照我定义的方式来进行解包即可。

服务器就完成了，是不是很简单。当然客户端也需要按照一样的方式处理打包即可

客户端：

客户端就很简单了，只需要连接到服务器，通过我们自动生成的代码（这里没有写自动生成，就手动了），然后就直接可以返回结果了

1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
class Program  
\{  
static void Main(string\[\] args)  
\{  
IMyService service = new MyServiceProxy();  
DateTime startTime = DateTime.Now;  
int result = service.add(123, 321);  
  
int min\_seconds = (int)(DateTime.Now - startTime).TotalMilliseconds;  
  
Console.WriteLine(result + " 耗时 " + min\_seconds);  
Console.ReadLine();  
\}  
\}  
　　上面直接调用了，接口，至于接口的实现，这里的步骤就三个：1、构造需要请求的数据，2、连接服务器并发送数据，3、接收返回内容，并解析结果。

1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
20  
21  
22  
23  
24  
25  
26  
27  
28  
29  
30  
31  
32  
33  
34  
35  
36  
37  
38  
39  
40  
41  
42  
43  
44  
45  
46  
47  
48  
49  
50  
51  
52  
53  
54  
55  
56  
57  
58  
59  
60  
61  
62  
63  
64  
65  
66  
67  
68  
69  
70  
71  
72  
73  
74  
75  
76  
77  
78  
79  
80  
81  
82  
83  
84  
85  
86  
87  
88  
89  
90  
91  
92  
93  
94  
95  
96  
97  
98  
99  
100  
101  
102  
103  
104  
105  
106  
107  
108  
109  
110  
111  
112  
113  
114  
115  
116  
117  
118  
119  
120  
121  
122  
public class MyServiceProxy : IMyService  
\{  
public int add(int x, int y)  
\{  
List<ArgInfo> argList = new List<ArgInfo>();  
argList.Add(new ArgInfo(TypeEnu.Int, x));  
argList.Add(new ArgInfo(TypeEnu.Int, y));  
  
byte\[\] send\_data = create\_send\_package("IMyService", "add", 2, TypeEnu.Int, argList);  
Socket client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);  
client.Connect(new IPEndPoint(IPAddress.Parse("192.168.0.105"), 10000));  
client.Send(send\_data);  
  
byte\[\] buffer = new byte\[4\];  
int count = client.Receive(buffer);  
if (count > 0)  
\{  
return bytes2int(buffer);  
\}  
  
throw new Exception("系统异常");  
\}  
  
public bool login(string name, string pwd)  
\{  
List<ArgInfo> argList = new List<ArgInfo>();  
argList.Add(new ArgInfo(TypeEnu.String, name));  
argList.Add(new ArgInfo(TypeEnu.String, pwd));  
  
byte\[\] send\_data = create\_send\_package("IMyService", "login", 2, TypeEnu.Bool, argList);  
Socket client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);  
client.Connect(new IPEndPoint(IPAddress.Parse("192.168.0.105"), 10000));  
client.Send(send\_data);  
  
byte\[\] buffer = new byte\[1\];  
int count = client.Receive(buffer);  
if (count > 0)  
\{  
return buffer\[0\] == 1;  
\}  
  
throw new Exception("系统异常");  
\}  
  
private byte\[\] create\_send\_package(string inter\_name, string method\_name, int arg\_length, TypeEnu return\_type, List<ArgInfo> argList)  
\{  
List<byte> list = new List<byte>();  
list.Add((byte)inter\_name.Length);  
list.AddRange(Encoding.UTF8.GetBytes(inter\_name));  
  
list.Add((byte)method\_name.Length);  
list.AddRange(Encoding.UTF8.GetBytes(method\_name));  
  
list.Add((byte)arg\_length);  
list.Add((byte)return\_type);  
  
foreach (var arg in argList)  
\{  
list.Add((byte)arg.type);  
if (arg.type == TypeEnu.Int)  
\{  
list.AddRange(int2bytes(Convert.ToInt32(arg.value)));  
\}  
else if (arg.type == TypeEnu.Bool)  
\{  
bool value = Convert.ToBoolean(arg.value);  
list.Add(value ? (byte)1 : (byte)0);  
\}  
else if (arg.type == TypeEnu.String)  
\{  
string value = arg.value.ToString();  
list.AddRange(int2bytes(value.Length));  
list.AddRange(Encoding.UTF8.GetBytes(value));  
\}  
\}  
  
return list.ToArray();  
\}  
  
public byte\[\] int2bytes(int len)  
\{  
byte\[\] data\_len = new byte\[4\];  
data\_len\[0\] = (byte)((len >> 8 \* 3) & 0xFF);  
data\_len\[1\] = (byte)((len >> 8 \* 2) & 0xFF);  
data\_len\[2\] = (byte)((len >> 8 \* 1) & 0xFF);  
data\_len\[3\] = (byte)(len & 0xFF);  
  
return data\_len;  
\}  
  
public int bytes2int(byte\[\] buffer)  
\{  
int value = 0;  
value += (int)(buffer\[0\] << (8 \* 3));  
value += (int)(buffer\[1\] << (8 \* 2));  
value += (int)(buffer\[2\] << (8 \* 1));  
value += (int)(buffer\[3\]);  
  
return value;  
\}  
\}  
  
public class ArgInfo  
\{  
public TypeEnu type \{ get; set; \}  
  
public object value \{ get; set; \}  
  
public ArgInfo(TypeEnu type, object value)  
\{  
this.type = type;  
this.value = value;  
\}  
\}  
  
public enum TypeEnu  
\{  
Void = 0,  
Int = 1,  
Bool = 2,  
String = 3  
\}  
　　接口的定义沿用服务端的即可。说明一点：MyServiceProxy这个类，这里我是手写的，真实的环境，这个类，应该是由我们定义的某种格式，然后写一个代码生成器，让他自动生成，然后就可以不用费力，兼容所有的调用了，

当然这里只支持了四种类型，我们还可以扩充更多类型，只需要找到传递数据的方式即可。譬如一种对象，我们不知道如何传递，可以直接把对象定义成一个json字符串，或者序列化成二进制，只要两端，都知道了这个类型，就可以了。

相当于设计模式里面的（约定大于配置了）