C# 搭建GRPC，实现双向通信

一、新建项目，定义GRPC服务接口

vs新建dll项目，项目中NuGet程序包添加Grpc相关引用

定义服务，创建.proto文件

创建文件CorrespondService.proto

syntax = "proto3";
package My.Public;
service CorrespondGrpcService {
  rpc SendMsg(GrpcData) returns (GrpcResult);
  rpc ReceiveDataFromServer(GrpcData) returns (stream GrpcData);
}

message GrpcData {
  string Ip = 1;
  int32 Port = 2;
  string DataId = 3;
  int32 DataPriority = 4;
  string DataType = 5;
  string Conntent = 6;
  string NodeName = 7;
}

message GrpcResult{
	bool result = 1;
}

定义两个服务方法：

客户端发送数据到服务端：SendMsg

服务端发送数据到客户端(从服务端接收数据)：ReceiveDataFromServer，因为是服务端主动触发，所以从服务端的返回数据定义成stream形式，流式传输，客户端启动一次该方法，即可等待服务端流式数据发送到客户端。

二、生成代码，添加到项目中

在添加的引用package下找到Grpc.Tool下的文件\tools\windows_x64

使用文件夹中的工具生成文件，到packages的上一层目录框输入cmd回车打开命令提示符窗口

运行命令：packages\Grpc.Tools.2.24.0\tools\windows_x64\protoc.exe -ISystemPublic --csharp_out SystemPublic SystemPublic\PublicClass\Grpc\GrpcService\CorrespondService.proto --grpc_out SystemPublic --plugin=protoc-gen-grpc=packages\Grpc.Tools.2.24.0\tools\windows_x64\grpc_csharp_plugin.exe

 注意自己引用包的版本号和目录路径。 

生成文件后拷贝到相应的目录下，添加到项目中。

三、 服务接口实现：

创建通信服务类CorrespondServiceServer.cs继承CorrespondGrpcService.CorrespondGrpcServiceBase，并实现定义的方法：

    /// <summary>
    /// Grpc服务
    /// </summary>
    public class CorrespondServiceServer : CorrespondGrpcService.CorrespondGrpcServiceBase
    {
        public ConcurrentDictionary<string, TaskInfo> _receiveDataTaskId = new ConcurrentDictionary<string, TaskInfo>();
        public Func<GrpcData, GrpcResult> MessageHandler { get; set; } = null;

        public override Task<GrpcResult> SendMsg(GrpcData request, ServerCallContext context)
        {
            if (MessageHandler == null)
            {
                return Task.FromResult<GrpcResult>(new GrpcResult() { Result = false });
            }
            Tuple<string, int> clientIP = SplitKeyStrGrpcContextPeer(context.Peer);

            if (string.IsNullOrEmpty(request.Ip))
            {
                request.Ip = clientIP.Item1;
                request.Port = clientIP.Item2;
            }
            GrpcResult result = MessageHandler(request);
            return Task.FromResult<GrpcResult>(result);
        }

        public override Task ReceiveDataFromServer(GrpcData request, IServerStreamWriter<GrpcData> responseStream, ServerCallContext context)
        {
            Tuple<string, int> clientIP = SplitKeyStrGrpcContextPeer(context.Peer);
            string IPkeyStr = GetKeyStr(clientIP.Item1, clientIP.Item2);
            if (_receiveDataTaskId.ContainsKey(IPkeyStr))
            {
                // 线程未完成
                if (_receiveDataTaskId[IPkeyStr].IsStarted)
                {
                    bool res = _receiveDataTaskId[IPkeyStr].Stop();
                }

                TaskInfo tmp;
                _receiveDataTaskId.TryRemove(IPkeyStr, out tmp);
            }

            if (!DataQueues.SendDataQueue.ContainsKey(IPkeyStr))