初识gRPC还是一位做JAVA的同事在项目中用到了它，为了C#的客户端程序和java的服务器程序进行通信和数据交换，当时还是对方编译成C#，我直接调用。

　　后来，自己下来做了C#版本gRPC编写，搜了很多资料，但许多都是从入门开始？调用说“Say Hi!”这种官方标准的入门示例，然后遇到各种问题……

　　关于gRPC和Protobuf介绍，就不介绍了，网络上一搜一大把，随便一抓都是标准的官方，所以直接从使用说起。

　　gPRC源代码：https://github.com/grpc/grpc；

　　protobuf的代码仓库：github仓库地址：https://github.com/google/protobuf ；Google下载protobuff下载地址：https://developers.google.com/protocol-buffers/docs/downloads 。

　　分别在VS中新建解决方案：GrpcTest；再在解决方案中新建三个项目：GrpcClient、GrpcServer、GrpcService，对应的分别是客户端（wpf窗体程序）、服务端（控制台程序）、gRPC服务者（控制台程序）。在GrpcClient和GrpcServer项目中添加对GrpcService的引用。

　　在VS中对3个项目添加工具包引用：右键点击“解决方案gRPCDemo”，点击“管理解决方案的NuGet程序包”，在浏览中分别搜索”Grpc”、”Grpc.Tools”、”Google.Protobuf”，然后点击右面项目，全选，再点击安装（也可以用视图 -> 窗口 ->  程序包管理器控制台 中的”Install-Package Grpc”进行这一步，这里不提供这种方法，有兴趣自己百度）。

　　对于使用gRPC的通信框架，需要使用到对应的通信文件。在gRPC中，使用到的是proto格式的文件，对应的自然有其相应的语法。本文不详细阐述该文件的语法，感兴趣可以去官网看标准的语法，这儿有一个链接，中文翻译比较全的https://www.codercto.com/a/45372.html。需要对其文章内的1.3进行补充下：

  • required：一个格式良好的消息一定要含有1个这种字段。表示该值是必须要设置的。
  • optional：消息格式中该字段可以有0个或1个值（不超过1个）。
  • repeated：在一个格式良好的消息中，这种字段可以重复任意多次（包括0次）。重复的值的顺序会被保留。表示该值可以重复，相当于java中的List。

　　本示例项目实现文件传输，因此在项目GrpcService中添加一个FileTransfer.proto文件，文件内容如下：

  1. syntax = "proto3";
  2. package GrpcService;
  4. service FileTransfer{
  5.     rpc FileDownload (FileRequest) returns (stream FileReply);
  6.     rpc FileUpload (stream FileReply) returns(stream FileReturn);
  7. }
  9. //请求下载文件时，所需下载文件的文件名称集合
  10. message FileRequest{
  11.     repeated string FileNames=1;//文件名集合
  12.     //repeated重复字段  类似链表；optional可有可无的字段；required必要设置字段
  13.     string Mark = 2;//携带的包
  14. }
  16. //下载和上传文件时的应答数据
  17. message FileReply{
  18.     string FileName=1;//文件名
  19.     int32 Block = 2;//标记---第几个数据
  20.     bytes Content = 3;//数据
  21.     string Mark = 4;//携带的包
  22.  }
  24. //数据上传时的返回值
  25. message FileReturn{
  26.     string FileName=1;//文件名
  27.     string Mark = 2;//携带的包
  28. }

　　proto文件仅仅只是定义了相关的数据，如果需要在代码中使用该格式，就需要将它编译成C#代码文件。

　　　　PS：网上可以找到的编译，需要下载相关的代码，见博文。其他的也较为繁琐，所以按照自己理解的来写了。注意，我的项目是放在D盘根目录下的。

　　首先打开cmd窗口，然后在窗口中输入：D:\GrpcTest\packages\Grpc.Tools.2.32.0\tools\windows_x86\protoc.exe -ID:\GrpcTest\GrpcService –csharp_out D:\GrpcTest\GrpcService D:\GrpcTest\GrpcService\FileTransfer.proto –grpc_out D:\GrpcTest\GrpcService –plugin=protoc-gen-grpc=D:\GrpcTest\packages\Grpc.Tools.2.32.0\tools\windows_x86\grpc_csharp_plugin.exe

　　输入上文后，按enter键，回车编译。

　　命令解读：

  • D:\GrpcTest\packages\Grpc.Tools.2.32.0\tools\windows_x86\protoc.exe ：调用的编译程序路径，注意版本不同路径稍有不一样。
  • -ID:\GrpcTest\GrpcService ：-I 指定一个或者多个目录，用来搜索.proto文件的。所以上面那行的D:\GrpcTest\GrpcService\FileTransfer.proto 已经可以换成FileTransfer.proto了，因为-I已经指定了。注意：如果不指定，那就是当前目录。
  •  –csharp_out D:\GrpcTest\GrpcService D:\GrpcTest\GrpcService\FileTransfer.proto ：（–csharp_out）生成C#代码、存放路径、文件。当然还能cpp_out、java_out、javanano_out、js_out、objc_out、php_out、python_out、ruby_out 这时候你就应该知道，可以支持多语言的，才用的，生成一些文件，然后给各个语言平台调用。参数1（D:\GrpcTest\GrpcService）是输出路径，参数2（D:\GrpcTest\GrpcService\FileTransfer.proto）是proto的文件名或者路径。
  •  –grpc_out D:\GrpcTest\GrpcService ：grpc_out是跟服务相关，创建，调用，绑定，实现相关。生成的玩意叫xxxGrpc.cs。与前面的区别是csharp_out是输出类似于咱们平时写的实体类，接口，定义之类的。生成的文件叫xxx.cs
  • –plugin=protoc-gen-grpc=D:\GrpcTest\packages\Grpc.Tools.2.32.0\tools\windows_x86\grpc_csharp_plugin.exe ：这个就是csharp的插件，python有python的，java有java的。

　　编译后，会在新增两个文件（文件位置与你的输出位置有关），并将两个文件加入到GrpcService项目中去：

　　　　

 

　　在GrpcServer项目中，新建一个FileImpl并继承自GrpcService.FileTransfer.FileTransferBase，然后复写其方法FileDownload和FileUpload方法，以供客户端进行调用。

  1. /// <summary>
  2. /// 文件传输类
  3. /// </summary>
  4. class FileImpl:GrpcService.FileTransfer.FileTransferBase
  5. {
  6.     /// <summary>
  7.     /// 文件下载
  8.     /// </summary>
  9.     /// <param name="request">下载请求</param>
  10.     /// <param name="responseStream">文件写入流</param>
  11.     /// <param name="context">站点上下文</param>
  12.     /// <returns></returns>
  13.     public override async Task FileDownload(FileRequest request, global::Grpc.Core.IServerStreamWriter<FileReply> responseStream, global::Grpc.Core.ServerCallContext context)
  14.     {
  15.         List<string> lstSuccFiles = new List<string>();//传输成功的文件
  16.         DateTime startTime = DateTime.Now;//传输文件的起始时间
  17.         int chunkSize = 1024 * 1024;//每次读取的数据
  18.         var buffer = new byte[chunkSize];//数据缓冲区
  19.         FileStream fs = null;//文件流
  20.         try
  21.         {
  22.             //reply.Block数字的含义是服务器和客户端约定的
  23.             for (int i = 0; i < request.FileNames.Count; i++)
  24.             {
  25.                 string fileName = request.FileNames[i];//文件名
  26.                 string filePath = Path.GetFullPath($".//Files\\{fileName}");//文件路径
  27.                 FileReply reply = new FileReply
  28.                 {
  29.                     FileName = fileName,
  30.                     Mark = request.Mark
  31.                 };//应答数据
  32.                 Console.WriteLine($"{request.Mark}，下载文件：{filePath}");//写入日志，下载文件
  33.                 if (File.Exists(filePath))
  34.                 {
  35.                     fs = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.Read, chunkSize, useAsync: true);
  37.                     //fs.Length  可以告诉客户端所传文件大小
  38.                     int readTimes = 0;//读取次数
  39.                     while (true)
  40.                     {
  41.                         int readSise = fs.Read(buffer, 0, buffer.Length);//读取数据
  42.                         if (readSise > 0)//读取到了数据，有数据需要发送
  43.                         {
  44.                             reply.Block = ++readTimes;
  45.                             reply.Content = Google.Protobuf.ByteString.CopyFrom(buffer, 0, readSise);
  46.                             await responseStream.WriteAsync(reply);
  47.                         }
  48.                         else//没有数据了，就告诉对方，读取完了
  49.                         {
  50.                             reply.Block = 0;
  51.                             reply.Content = Google.Protobuf.ByteString.Empty;
  52.                             await responseStream.WriteAsync(reply);
  53.                             lstSuccFiles.Add(fileName);
  54.                             Console.WriteLine($"{request.Mark}，完成发送文件：{filePath}");//日志，记录发送成功
  55.                             break;//跳出去
  56.                         }
  57.                     }
  58.                     fs?.Close();
  59.                 }
  60.                 else
  61.                 {
  62.                     Console.WriteLine($"文件【{filePath}】不存在。");//写入日志，文件不存在
  63.                     reply.Block = -1;//-1的标记为文件不存在
  64.                     await responseStream.WriteAsync(reply);//告诉客户端，文件状态
  65.                 }
  66.             }
  67.             //告诉客户端，文件传输完成
  68.             await responseStream.WriteAsync(new FileReply
  69.             {
  70.                 FileName = string.Empty,
  71.                 Block = -2,//告诉客户端，文件已经传输完成
  72.                 Content = Google.Protobuf.ByteString.Empty,
  73.                 Mark = request.Mark
  74.             });
  75.         }
  76.         catch(Exception ex)
  77.         {
  78.             Console.WriteLine($"{request.Mark}，发生异常({ex.GetType()})：{ex.Message}");
  79.         }
  80.         finally
  81.         {
  82.             fs?.Dispose();
  83.         }
  84.         Console.WriteLine($"{request.Mark}，文件传输完成。共计【{lstSuccFiles.Count / request.FileNames.Count}】，耗时：{DateTime.Now - startTime}");
  85.     }
  88.     /// <summary>
  89.     /// 上传文件
  90.     /// </summary>
  91.     /// <param name="requestStream">请求流</param>
  92.     /// <param name="responseStream">响应流</param>
  93.     /// <param name="context">站点上下文</param>
  94.     /// <returns></returns>
  95.     public override async Task FileUpload(global::Grpc.Core.IAsyncStreamReader<FileReply> requestStream, global::Grpc.Core.IServerStreamWriter<FileReturn> responseStream, global::Grpc.Core.ServerCallContext context)
  96.     {
  97.         List<string> lstFilesName = new List<string>();//文件名
  98.         List<FileReply> lstContents = new List<FileReply>();//数据集合
  100.         FileStream fs = null;
  101.         DateTime startTime = DateTime.Now;//开始时间
  102.         string mark = string.Empty;
  103.         string savePath = string.Empty;
  104.         try
  105.         {
  106.             //reply.Block数字的含义是服务器和客户端约定的
  107.             while (await requestStream.MoveNext())//读取数据
  108.             {
  109.                 var reply = requestStream.Current;
  110.                 mark = reply.Mark;
  111.                 if (reply.Block == -2)//传输完成
  112.                 {
  113.                     Console.WriteLine($"{mark}，完成上传文件。共计【{lstFilesName.Count}】个，耗时：{DateTime.Now-startTime}");
  114.                     break;
  115.                 }
  116.                 else if (reply.Block == -1)//取消了传输
  117.                 {
  118.                     Console.WriteLine($"文件【{reply.FileName}】取消传输！");//写入日志
  119.                     lstContents.Clear();
  120.                     fs?.Close();//释放文件流
  121.                     if (!string.IsNullOrEmpty(savePath) && File.Exists(savePath))//如果传输不成功，删除该文件
  122.                     {
  123.                         File.Delete(savePath);
  124.                     }
  125.                     savePath = string.Empty;
  126.                     break;
  127.                 }
  128.                 else if(reply.Block==0)//文件传输完成
  129.                 {
  130.                     if (lstContents.Any())//如果还有数据，就写入文件
  131.                     {
  132.                         lstContents.OrderBy(c => c.Block).ToList().ForEach(c => c.Content.WriteTo(fs));
  133.                         lstContents.Clear();
  134.                     }
  135.                     lstFilesName.Add(savePath);//传输成功的文件
  136.                     fs?.Close();//释放文件流
  137.                     savePath = string.Empty;
  139.                     //告知客户端，已经完成传输
  140.                     await responseStream.WriteAsync(new FileReturn
  141.                     {
  142.                         FileName= reply.FileName,
  143.                         Mark=mark
  144.                     });
  145.                 }
  146.                 else
  147.                 {
  148.                     if(string.IsNullOrEmpty(savePath))//有新文件来了
  149.                     {
  150.                         savePath = Path.GetFullPath($".//Files\\{reply.FileName}");//文件路径
  151.                         fs = new FileStream(savePath, FileMode.Create, FileAccess.ReadWrite);
  152.                         Console.WriteLine($"{mark}，上传文件：{savePath}，{DateTime.UtcNow.ToString("HH:mm:ss:ffff")}");
  153.                     }
  154.                     lstContents.Add(reply);//加入链表
  155.                     if (lstContents.Count() >= 20)//每个包1M，20M为一个集合，一起写入数据。
  156.                     {
  157.                         lstContents.OrderBy(c => c.Block).ToList().ForEach(c => c.Content.WriteTo(fs));
  158.                         lstContents.Clear();
  159.                     }
  160.                 }
  161.             }
  162.         }
  163.         catch(Exception ex)
  164.         {
  165.             Console.WriteLine($"{mark}，发生异常({ex.GetType()})：{ex.Message}");
  166.         }
  167.         finally
  168.         {
  169.             fs?.Dispose();
  170.         }
  171.     }
  172. }

View Code

　　在main函数中添加服务：

  1. class Program
  2. {
  3.     static void Main(string[] args)
  4.     {
  5.         //提供服务
  6.         Server server = new Server()
  7.         {
  8.             Services = {GrpcService.FileTransfer.BindService(new FileImpl())},
  9.             Ports = {new ServerPort("127.0.0.1",50000,ServerCredentials.Insecure)}
  10.         };
  11.         //服务开始
  12.         server.Start();
  14.         while(Console.ReadLine().Trim().ToLower()!="exit")
  15.         {
  17.         }
  18.         //结束服务
  19.         server.ShutdownAsync();
  20.     }
  21. }

　　首先定义一个文件传输结果类TransferResult<T>，用于存放文件的传输结果。

  1. /// <summary>
  2. /// 传输结果
  3. /// </summary>
  4. /// <typeparam name="T"></typeparam>
  5. class TransferResult<T>
  6. {
  7.     /// <summary>
  8.     /// 传输是否成功
  9.     /// </summary>
  10.     public bool IsSuccessful { get; set; }
  11.     /// <summary>
  12.     /// 消息
  13.     /// </summary>
  14.     public string Message { get; set; }
  16.     /// <summary>
  17.     /// 标记类型
  18.     /// </summary>
  19.     public T Tag { get; set; } = default;
  20. }

　　然后在GrpcClinet项目中添加一个FileTransfer的类，并实现相关方法：

  1. class FileTransfer
  2. {
  4.     /// <summary>
  5.     /// 获取通信客户端
  6.     /// </summary>
  7.     /// <returns>通信频道、客户端</returns>
  8.     static (Channel, GrpcService.FileTransfer.FileTransferClient) GetClient()
  9.     {
  10.         //侦听IP和端口要和服务器一致
  11.         Channel channel = new Channel("127.0.0.1", 50000, ChannelCredentials.Insecure);
  12.         var client = new GrpcService.FileTransfer.FileTransferClient(channel);
  13.         return (channel, client);
  14.     }
  16.     /// <summary>
  17.     /// 下载文件
  18.     /// </summary>
  19.     /// <param name="fileNames">需要下载的文件集合</param>
  20.     /// <param name="mark">标记</param>
  21.     /// <param name="saveDirectoryPath">保存路径</param>
  22.     /// <param name="cancellationToken">异步取消命令</param>
  23.     /// <returns>下载任务（是否成功、原因、失败文件名）</returns>
  24.     public static async Task<TransferResult<List<string>>> FileDownload(List<string> fileNames, string mark, string saveDirectoryPath, System.Threading.CancellationToken cancellationToken = new System.Threading.CancellationToken())
  25.     {
  26.         var result = new TransferResult<List<string>>() { Message = $"文件保存路径不正确：{saveDirectoryPath}" };
  27.         if (!System.IO.Directory.Exists(saveDirectoryPath))
  28.         {
  29.             return await Task.Run(() => result);//文件路径不存在
  30.         }
  31.         if (fileNames.Count == 0)
  32.         {
  33.             result.Message = "未包含任何文件";
  34.             return await Task.Run(() => result);//文件路径不存在
  35.         }
  36.         result.Message = "未能连接到服务器";
  37.         FileRequest request = new FileRequest() { Mark = mark };//请求数据
  38.         request.FileNames.AddRange(fileNames);//将需要下载的文件名赋值
  39.         var lstSuccFiles = new List<string>();//传输成功的文件
  40.         string savePath = string.Empty;//保存路径
  41.         System.IO.FileStream fs = null;
  42.         Channel channel = null;//申明通信频道
  43.         GrpcService.FileTransfer.FileTransferClient client = null;
  44.         DateTime startTime = DateTime.Now;
  45.         try
  46.         {
  47.             (channel, client) = GetClient();
  48.             using (var call = client.FileDownload(request))
  49.             {
  50.                 List<FileReply> lstContents = new List<FileReply>();//存放接收的数据
  51.                 var reaponseStream = call.ResponseStream;
  52.                 //reaponseStream.Current.Block数字的含义是服务器和客户端约定的
  53.                 while (await reaponseStream.MoveNext(cancellationToken))//开始接收数据
  54.                 {
  55.                     if (cancellationToken.IsCancellationRequested)
  56.                     {
  57.                         break;
  58.                     }
  59.                     if (reaponseStream.Current.Block == -2)//说明文件已经传输完成了
  60.                     {
  61.                         result.Message = $"完成下载任务【{lstSuccFiles.Count}/{fileNames.Count}】，耗时：{DateTime.Now - startTime}";
  62.                         result.IsSuccessful = true;
  63.                         break;
  64.                     }
  65.                     else if (reaponseStream.Current.Block == -1)//当前文件传输错误
  66.                     {
  67.                         Console.WriteLine($"文件【{reaponseStream.Current.FileName}】传输失败！");//写入日志
  68.                         lstContents.Clear();
  69.                         fs?.Close();//释放文件流
  70.                         if (!string.IsNullOrEmpty(savePath) && File.Exists(savePath))//如果传输不成功，删除该文件
  71.                         {
  72.                             File.Delete(savePath);
  73.                         }
  74.                         savePath = string.Empty;
  75.                     }
  76.                     else if (reaponseStream.Current.Block == 0)//当前文件传输完成
  77.                     {
  78.                         if (lstContents.Any())//如果还有数据，就写入文件
  79.                         {
  80.                             lstContents.OrderBy(c => c.Block).ToList().ForEach(c => c.Content.WriteTo(fs));
  81.                             lstContents.Clear();
  82.                         }
  83.                         lstSuccFiles.Add(reaponseStream.Current.FileName);//传输成功的文件
  84.                         fs?.Close();//释放文件流
  85.                         savePath = string.Empty;
  86.                     }
  87.                     else//有文件数据过来
  88.                     {
  89.                         if (string.IsNullOrEmpty(savePath))//如果字节流为空，则说明时新的文件数据来了
  90.                         {
  91.                             savePath = Path.Combine(saveDirectoryPath, reaponseStream.Current.FileName);
  92.                             fs = new FileStream(savePath, FileMode.Create, FileAccess.ReadWrite);
  93.                         }
  94.                         lstContents.Add(reaponseStream.Current);//加入链表
  95.                         if (lstContents.Count() >= 20)//每个包1M，20M为一个集合，一起写入数据。
  96.                         {
  97.                             lstContents.OrderBy(c => c.Block).ToList().ForEach(c => c.Content.WriteTo(fs));
  98.                             lstContents.Clear();
  99.                         }
  100.                     }
  101.                 }
  102.             }
  103.             fs?.Close();//释放文件流
  104.             if (!result.IsSuccessful &&!string.IsNullOrEmpty(savePath)&& File.Exists(savePath))//如果传输不成功，那么久删除该文件
  105.             {
  106.                 File.Delete(savePath);
  107.             }
  108.         }
  109.         catch (Exception ex)
  110.         {
  111.             if (cancellationToken.IsCancellationRequested)
  112.             {
  113.                 fs?.Close();//释放文件流
  114.                 result.IsSuccessful = false;
  115.                 result.Message = $"用户取消下载。已完成下载【{lstSuccFiles.Count}/{fileNames.Count}】，耗时：{DateTime.Now - startTime}";
  116.             }
  117.             else
  118.             {
  119.                 result.Message = $"文件传输发生异常：{ex.Message}";
  120.             }
  121.         }
  122.         finally
  123.         {
  124.             fs?.Dispose();
  125.         }
  126.         result.Tag = fileNames.Except(lstSuccFiles).ToList();//获取失败文件集合
  127.         //关闭通信、并返回结果
  128.         return await channel?.ShutdownAsync().ContinueWith(t => result);
  129.     }
  132.     /// <summary>
  133.     /// 文件上传
  134.     /// </summary>
  135.     /// <param name="filesPath">文件路径</param>
  136.     /// <param name="mark">标记</param>
  137.     /// <param name="cancellationToken">异步取消命令</param>
  138.     /// <returns>下载任务（是否成功、原因、成功的文件名）</returns>
  139.     public static async Task<TransferResult<List<string>>> FileUpload(List<string> filesPath, string mark, System.Threading.CancellationToken cancellationToken=new System.Threading.CancellationToken())
  140.     {
  141.         var result = new TransferResult<List<string>> { Message = "没有文件需要下载" };
  142.         if (filesPath.Count == 0)
  143.         {
  144.             return await Task.Run(() => result);//没有文件需要下载
  145.         }
  146.         result.Message = "未能连接到服务器。";
  147.         var lstSuccFiles = new List<string>();//传输成功的文件
  148.         int chunkSize = 1024 * 1024;
  149.         byte[] buffer = new byte[chunkSize];//每次发送的大小
  150.         FileStream fs = null;//文件流
  151.         Channel channel = null;//申明通信频道
  152.         GrpcService.FileTransfer.FileTransferClient client = null;
  153.         DateTime startTime = DateTime.Now;
  154.         try
  155.         {
  156.             (channel, client) = GetClient();
  157.             using(var stream=client.FileUpload())//连接上传文件的客户端
  158.             {
  159.                 //reply.Block数字的含义是服务器和客户端约定的
  160.                 foreach (var filePath in filesPath)//遍历集合
  161.                 {
  162.                     if(cancellationToken.IsCancellationRequested)
  163.                         break;//取消了传输
  164.                     FileReply reply = new FileReply()
  165.                     {
  166.                         FileName=Path.GetFileName(filePath),
  167.                         Mark=mark
  168.                     };
  169.                     if(!File.Exists(filePath))//文件不存在，继续下一轮的发送
  170.                     {
  171.                         Console.WriteLine($"文件不存在：{filePath}");//写入日志
  172.                         continue;
  173.                     }
  174.                     fs = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.Read, chunkSize, useAsync: true);
  175.                     int readTimes = 0;
  176.                     while(true)
  177.                     {
  178.                         if (cancellationToken.IsCancellationRequested)
  179.                         {
  180.                             reply.Block = -1;//取消了传输
  181.                             reply.Content = Google.Protobuf.ByteString.Empty;
  182.                             await stream.RequestStream.WriteAsync(reply);//发送取消传输的命令
  183.                             break;//取消了传输
  184.                         }
  185.                         int readSize = fs.Read(buffer, 0, buffer.Length);//读取数据
  186.                         if(readSize>0)
  187.                         {
  188.                             reply.Block = ++readTimes;//更新标记，发送数据
  189.                             reply.Content = Google.Protobuf.ByteString.CopyFrom(buffer, 0, readSize);
  190.                             await stream.RequestStream.WriteAsync(reply);
  191.                         }
  192.                         else
  193.                         {
  194.                             Console.WriteLine($"完成文件【{filePath}】的上传。");
  195.                             reply.Block = 0;//传送本次文件发送结束的标记
  196.                             reply.Content = Google.Protobuf.ByteString.Empty;
  197.                             await stream.RequestStream.WriteAsync(reply);//发送结束标记
  198.                             //等待服务器回传
  199.                             await stream.ResponseStream.MoveNext(cancellationToken);
  200.                             if(stream.ResponseStream.Current!=null&&stream.ResponseStream.Current.Mark==mark)
  201.                             {
  202.                                 lstSuccFiles.Add(filePath);//记录成功的文件
  203.                             }
  204.                             break;//发送下一个文件
  205.                         }
  206.                     }
  207.                     fs?.Close();
  208.                 }
  209.                 if (!cancellationToken.IsCancellationRequested)
  210.                 {
  211.                     result.IsSuccessful = true;
  212.                     result.Message = $"完成文件上传。共计【{lstSuccFiles.Count}/{filesPath.Count}】，耗时:{DateTime.Now - startTime}";
  214.                     await stream.RequestStream.WriteAsync(new FileReply
  215.                     {
  216.                         Block = -2,//传输结束
  217.                         Mark = mark
  218.                     }) ;//发送结束标记
  219.                 }
  220.             }
  221.         }
  222.         catch(Exception ex)
  223.         {
  224.             if (cancellationToken.IsCancellationRequested)
  225.             {
  226.                 fs?.Close();//释放文件流
  227.                 result.IsSuccessful = false;
  228.                 result.Message = $"用户取消了上传文件。已完成【{lstSuccFiles.Count}/{filesPath.Count}】，耗时:{DateTime.Now - startTime}";
  229.             }
  230.             else
  231.             {
  232.                 result.Message = $"文件上传发生异常({ex.GetType()})：{ex.Message}";
  233.             }
  234.         }
  235.         finally
  236.         {
  237.             fs?.Dispose();
  238.         }
  239.         Console.WriteLine(result.Message);
  240.         result.Tag = lstSuccFiles;
  241.         //关闭通信、并返回结果
  242.         return await channel?.ShutdownAsync().ContinueWith(t => result);
  243.     }
  244. }

View Code

　　现在可以在客户端窗体内进行调用了：

  1. private string GetFilePath()
  2. {
  3.     // Create OpenFileDialog 
  4.     Microsoft.Win32.OpenFileDialog dlg = new Microsoft.Win32.OpenFileDialog();
  6.     // Set filter for file extension and default file extension 
  7.     dlg.Title = "选择文件";
  8.     dlg.Filter = "所有文件(*.*)|*.*";
  9.     dlg.FileName = "选择文件夹.";
  10.     dlg.FilterIndex = 1;
  11.     dlg.ValidateNames = false;
  12.     dlg.CheckFileExists = false;
  13.     dlg.CheckPathExists = true;
  14.     dlg.Multiselect = false;//允许同时选择多个文件 
  16.     // Display OpenFileDialog by calling ShowDialog method 
  17.     Nullable<bool> result = dlg.ShowDialog();
  19.     // Get the selected file name and display in a TextBox 
  20.     if (result == true)
  21.     {
  22.         // Open document 
  23.         return dlg.FileName;
  24.     }
  26.     return string.Empty;
  27. }
  28. // 打开文件
  29. private void btnOpenUpload_Click(object sender, RoutedEventArgs e)
  30. {
  31.     lblUploadPath.Content = GetFilePath();
  32. }
  33. CancellationTokenSource uploadTokenSource;
  34. //上传
  35. private async void btnUpload_Click(object sender, RoutedEventArgs e)
  36. {
  37.     lblMessage.Content = string.Empty;
  39.     uploadTokenSource = new CancellationTokenSource();
  40.     List<string> fileNames = new List<string>();
  41.     fileNames.Add(lblUploadPath.Content.ToString());
  42.     var result = await ServerNet.FileTransfer.FileUpload(fileNames, "123", uploadTokenSource.Token);
  44.     lblMessage.Content = result.Message;
  46.     uploadTokenSource = null;
  47. }
  48. //取消上传
  49. private void btnCancelUpload_Click(object sender, RoutedEventArgs e)
  50. {
  51.     uploadTokenSource?.Cancel();
  52. }
  55. //打开需要下载的文件
  56. private void btnOpenDownload_Click(object sender, RoutedEventArgs e)
  57. {
  58.     txtDownloadPath.Text = GetFilePath();
  59. }
  60. //下载文件
  61. private async void btnDownload_Click(object sender, RoutedEventArgs e)
  62. {
  63.     lblMessage.Content = string.Empty;
  65.     downloadTokenSource = new CancellationTokenSource();
  66.     List<string> fileNames = new List<string>();
  67.     fileNames.Add(System.IO.Path.GetFileName(txtDownloadPath.Text));
  68.     var result=  await ServerNet.FileTransfer.FileDownload(fileNames, "123", Environment.CurrentDirectory, downloadTokenSource.Token);
  70.     lblMessage.Content = result.Message;
  72.     downloadTokenSource = null;
  73. }
  74. CancellationTokenSource   downloadTokenSource;
  75. //下载取消
  76. private void btnCancelDownload_Click(object sender, RoutedEventArgs e)
  77. {
  78.     downloadTokenSource?.Cancel();
  79. }

　　https://files.cnblogs.com/files/pilgrim/GrpcTest.rar

版权声明：本文为pilgrim原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/pilgrim/p/13855661.html