IT评测·应用市场-qidao123.com

标题: .NET8中gRPC的使用 [打印本页]
作者: 吴旭华    时间: 2025-3-19 12:04
标题: .NET8中gRPC的使用
在当代分布式体系中，服务之间的通信是一个非常重要的环节。随着微服务架构的盛行，服务之间的通信方式也在不停演进。gRPC作为一种高性能、跨语言的RPC框架，渐渐成为了我们的首选。
一、简介

gRPC 是一种高性能、开源的远程过程调用（RPC）框架，基于 HTTP/2 协议，支持双向流、头部压缩等特性。它默认使用 Protocol Buffers（Protobuf）作为接口界说语言（IDL）和数据序列化格式，适用于微服务、及时通信等场景。
在 .NET Core（.NET 8）中，gRPC 提供了原生的支持，我们可以轻松创建 gRPC 服务端和客户端，并将其集成到 Web API 或其他应用中。
本文将围绕以下几个方面介绍如何在 .NET Core (.NET 8) 中使用 gRPC：
二、创建 gRPC 服务端

1. 创建 gRPC 项目

起首，使用 .NET CLI 创建一个 gRPC 服务端项目。也可以通过VS2022直接举行创建。
  1. dotnet new grpc -o GrpcDemo.Service
  2. cd GrpcDemo.Service
复制代码

这将创建一个包含 gRPC 模板的项目，此中包含一个示例的 gRPC 服务。

2. 编写本身的服务

在 Protos 文件夹中，默认会生成一个 greet.proto 文件。我们可以修改或创建新的 .proto 文件来界说本身的服务。
比方，创建一个 order.proto 文件：
  1. syntax = "proto3";
  3. option csharp_namespace = "GrpcDemo.Service";
  5. package order;
  7. // 订单服务定义
  8. service Order {
  9.   // 创建订单
  10. rpc CreateOrder (CreateRequest) returns (CreateResult);
  11.   //查询订单
  12. rpc QueryOrder (QueryRequest) returns (QueryResult);
  13. }
  15. //创建订单请求参数
  16. message CreateRequest {
  17.   string OrderNo = 1;
  18.   string OrderName=2;
  19.   double Price=3;
  20. }
  22. //创建订单返回结果
  23. message CreateResult {
  24.   bool IsSuccess = 1; // 是否成功
  25.   string Message = 2; // 错误信息
  26. }
  28. //查询订单请求参数
  29. message QueryRequest{
  30.   int32 Id=1;
  31. }
  32. //查询订单返回结果
  33. message QueryResult{
  34.   int32 Id=1;
  35.   string OrderNo=2;
  36.   string OrderName=3;
  37.   double Price=4;
  38. }
复制代码
接下来，在 Services 文件夹中实现服务逻辑。创建一个 OrderService.cs 文件：
  1. using Grpc.Core;
  3. namespace GrpcDemo.Service.Services
  4. {
  5.     public class OrderService : Order.OrderBase
  6.     {
  7.         private readonly ILogger<OrderService> _logger;
  8.         public OrderService(ILogger<OrderService> logger)
  9.         {
  10.             _logger = logger;
  11.         }
  12.         /// <summary>
  13.         /// 创建订单
  14.         /// </summary>
  15.         /// <param name="request"></param>
  16.         /// <param name="context"></param>
  17.         /// <returns></returns>
  18.         public override Task<CreateResult> CreateOrder(CreateRequest request, ServerCallContext context)
  19.         {
  20.             //报存数据库 todo
  22.             return Task.FromResult(new CreateResult
  23.             {
  24.                 IsSuccess = true,
  25.                 Message = "订单创建成功"
  26.             });
  27.         }
  28.         /// <summary>
  29.         /// 查询订单
  30.         /// </summary>
  31.         /// <param name="request"></param>
  32.         /// <param name="context"></param>
  33.         /// <returns></returns>
  34.         public override Task<QueryResult> QueryOrder(QueryRequest request, ServerCallContext context)
  35.         {
  36.             //查询数据库 //todo
  38.             return Task.FromResult(new QueryResult
  39.             {
  40.                     Id = request.Id,
  41.                     OrderNo = DateTime.Now.ToString("yyyyMMddHHmmss"),
  42.                     OrderName = "年货大礼包",
  43.                     Price = 699
  44.             });
  45.         }
  46.     }
  47. }
复制代码
在 Program.cs 中注册服务：
  1. using GrpcDemo.Service.Services;
  3. var builder = WebApplication.CreateBuilder(args);
  5. // 添加 gRPC 服务
  6. builder.Services.AddGrpc();
  8. var app = builder.Build();
  10. // 映射 gRPC 服务
  11. app.MapGrpcService<OrderService>();
  13. app.Run();
复制代码
运行项目后，gRPC 服务端将启动并监听指定的端口。
三、创建 gRPC 客户端

1. 创建客户端项目

使用 .NET CLI 创建一个控制台项目作为 gRPC 客户端：
  1. dotnet new console -o GrpcDemo.Client
  2. cd GrpcDemo.Client
复制代码
2. 添加 gRPC 客户端依赖

在客户端项目中，添加 Grpc.Net.Client 和 Google.Protobuf 包：
  1. dotnet add package Grpc.Net.Client
  2. dotnet add package Google.Protobuf
  3. dotnet add package Grpc.Tools
复制代码
将服务端的 order.proto 文件复制到客户端项目的 Protos 文件夹中，并在 .csproj 文件中添加以下内容以生成 C# 代码：

3. 编写客户端代码

在 Program.cs 中编写 gRPC服务HTTPS调用的代码：
  1. static void Main(string[] args)
  2. {
  3.     Console.WriteLine("Hello, World!");
  4.     //常规使用，https
  5.     string url = "https://localhost:7231";
  6.     using (var channel = GrpcChannel.ForAddress(url))
  7.     {
  8.         var client = new Order.OrderClient(channel);
  9.         var reply = client.CreateOrder(new CreateRequest()
  10.         {
  11.             OrderNo = DateTime.Now.ToString("yyyyMMddHHmmssfff"),
  12.             OrderName = "年货大礼包",
  13.             Price = 699
  14.         });
  16.         Console.WriteLine($"Grpc服务https的调用结果:{reply.IsSuccess},message:{reply.Message}");
  17.     }
  18.     Console.ReadKey();
  20. }
复制代码
结果：

如果 gRPC 服务端使用 HTTP（非 HTTPS），可以在客户端中直接使用 HTTP 地址：
  1. //使用http
  2. AppContext.SetSwitch("System.Net.Http.SocketsHttpHandler.Http2UnencryptedSupport", true);
  3. string url = "http://localhost:5147";
  5. using (var channel = GrpcChannel.ForAddress(url))
  6. {
  7.      var client = new Order.OrderClient(channel);
  8.      var reply = client.CreateOrder(new CreateRequest()
  9.      {
  10.          OrderNo = DateTime.Now.ToString("yyyyMMddHHmmssfff"),
  11.          OrderName = "年货大礼包",
  12.          Price = 699
  13.      });
  15.      Console.WriteLine($"gGrpc内网http调用结果:{reply.IsSuccess},message:{reply.Message}");
  16. }
  17. Console.ReadKey();
复制代码
结果：

四、Web API 中加入 gRPC

在 Web API 项目中，可以同时提供 RESTful API 和 gRPC 服务。以下是如何在 Web API 中集成 gRPC 的步骤：
1. 添加 gRPC 服务

在 Program.cs 中注册 gRPC 服务：
  1. var builder = WebApplication.CreateBuilder(args);
  3. // 添加 gRPC 服务
  4. builder.Services.AddGrpc();
  6. var app = builder.Build();
  8. // 映射 gRPC 服务
  9. app.MapGrpcService<OrderService>();
  11. app.Run();
复制代码
2. 提供 RESTful API

在 Web API 中，可以通过控制器提供 RESTful API，并在内部调用 gRPC 服务：
  1. using Microsoft.AspNetCore.Mvc;
  3. namespace GrpcDemo.API.Controllers
  4. {
  5.     [ApiController]
  6.     [Route("api/[controller]")]
  7.     public class OrderController : ControllerBase
  8.     {
  9.         private readonly Order.OrderClient _client;
  11.         public OrderController(Order.OrderClient client)
  12.         {
  13.             _client = client;
  14.         }
  16.         [HttpGet("create")]
  17.         public async Task<IActionResult> CreateOrder()
  18.         {
  19.             var response = await _client.CreateOrderAsync(
  20.                 new CreateRequest {
  21.                     OrderNo = DateTime.Now.ToString("yyyyMMddHHmmssfff"),
  22.                     OrderName = "年货大礼包",
  23.                     Price = 699
  24.                 });
  25.             return Ok(response);
  26.         }
  28.     }
  29. }
复制代码
3. 配置 gRPC 客户端

在 Program.cs 中注册 gRPC 客户端：
  1. builder.Services.AddGrpcClient<Order.OrderClient>(options =>
  2. {
  3.      options.Address = new Uri("http://localhost:5147");
  4. });
复制代码
结果：

总结

在 .NET Core 中，gRPC 提供了高性能的通信方式，适用于微服务、及时通信等场景。我们可以轻松创建 gRPC 服务端和客户端，并将其集成到 Web API 中。
关键点：
通过以上步骤，我们就可以在 .NET Core 项目中充分利用 gRPC 的优势，构建高效的分布式体系。
源码地址：https://github.com/liyongqiang-cc/GrpcDemo


免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。



欢迎光临 IT评测·应用市场-qidao123.com (https://dis.qidao123.com/) Powered by Discuz! X3.4