拥有活跃的社区支持和丰富的相关工具及库。
gRPC 是怎么传输的？
服务端 Stub 接收客户端请求,处理请求中的 Protobuf 数据并进行反序列化，然后将请求对象传入服务器并实现业务逻辑处理。最终再将响应序列化后返回给客户端，从而形成一次完整的接口调用过程。
以上概念以及相关知识点来自apifox 。
NET Core实现Grpc调用
话不多说，以下内容详细介绍一元调用的过程，贴代码。
-----------------服务端代码 Start-----------------
步骤一：
在Grpc服务端(Server)先创建一个.potos文件。文件名（IBook_Service.proto）文件路径（Protos/IBook_Service.proto）
//表明使用protobuf的编译器版本为v2,目前最新的版本为v3。
syntax = "proto3";
//定义命名空间
option csharp_namespace = "ZP_BookService_Grpc.Application.Book_Service";
//包名：多个 .proto 文件生成代码时，可避免命名冲突。
package Book_Service;
//1、定义接口名称，用于后期实现
service IBook_Service{
// 1.1 根据商品主键，获取商品
rpc GetBook (BookFrom) returns (BookDto);
}
// 2、定义入参(类)Form：顺序要写，且不能重复
message BookFrom{
string BookName = 1;
}
// 3、定义出参Dto(类)：顺序要写，且不能重复
message BookDto{
string ID = 1;
string CreateTime = 2;
string BookName = 3;
string BookPrice =4;
string PublicationDate = 5;
string Type = 6;
string Publisher = 7;
int32 Residue = 8;
}步骤二：
文件建立好后需要在项目的csproj文件中Project内加上文件的目录（Protos\IBook_Service.prot） GrpcServices意思是服务端，一定要加上<Protobuf Include="Protos\IBook_Service.proto" GrpcServices="Server" />
引用包（Google.Protobuf、Grpc.AspNetCore、Grpc.Tools）
完成以上步骤，右键项目选择 “重新生成”。生成以后可以在项目的obj文件夹（~\Application_Grpc\obj\Debug\net7.0\Protos）看到一个自动生成的Protos文件夹
<ItemGroup>
<PackageReference Include="Google.Protobuf" Version="3.26.0" />
<PackageReference Include="Grpc.AspNetCore" Version="2.61.0" />
<PackageReference Include="Grpc.Tools" Version="2.62.0" />
</ItemGroup>
<ItemGroup>
<Protobuf Include="Protos\IBook_Service.proto" GrpcServices="Server" />
</ItemGroup>步骤三：
创建一个实现类（Book_Service）用于实现protos文件夹内自动生成的接口（IBook_Service.IBook_ServiceBase）。注：实现带有Base的接口。接口名称是定义proto文件的时候自定义的。
namespace Application_Grpc.Application.BusinessServices
{
//注入作用域生命周期
[Service(ServiceLifetime.Scoped)]
public class Book_Service : IBook_Service.IBook_ServiceBase
{
private IBook_Repository _bookRepository { get; }
private IMapper _mapper { get; }
public Book_Service(IBook_Repository book_Repository, IMapper mapper)
{
_bookRepository = book_Repository;
_mapper = mapper;
}
public override async Task<BookDto> GetBook(BookFrom request, ServerCallContext context)
{
BookDto data=new BookDto();
data.ID = Guid.NewGuid().ToString();
data.CreateTime = DateTime.Now.ToString();
data.BookName = request.BookName;
data.BookPrice = "29.99";
data.PublicationDate = "1999-03-21";
data.Type = "经典";
data.Publisher = "清华大学出版社";
data.Residue = 5;
return data;
}
}
}至此，服务端的Grpc就完成了。剩下的就是把项目进行服务依赖注入操作，本实例代码通过贴特征方式注入。可以在 Program.cs 以常规方式注入自己的服务。
如：builder.Services.AddSingleton<Book_Service>();
-----------------服务端代码 END-----------------
-----------------客户端代码 Start-----------------
步骤一：
步骤一：
在Grpc服务端(Client)先创建一个.potos文件。文件名（IBook_Service.proto）文件路径（Protos/IBook_Service.proto）。其实就是复制服务端的 proto 修改下 命名空间
//表明使用protobuf的编译器版本为v2,目前最新的版本为v3。
syntax = "proto3";
//定义命名空间
option csharp_namespace = "ZP_ProjectEntrance.MicroService.Book_Service";
//包名：多个 .proto 文件生成代码时，可避免命名冲突。
package Book_Service;
//1、定义接口名称，用于后期实现
service IBook_Service{
// 1.1 根据商品主键，获取商品
rpc GetBook (BookFrom) returns (BookDto);
}
// 2、定义入参(类)Form：顺序要写，且不能重复
message BookFrom{
string BookName = 1;
}
// 3、定义出参Dto(类)：顺序要写，且不能重复
message BookDto{
string ID = 1;
string CreateTime = 2;
string BookName = 3;
string BookPrice =4;
string PublicationDate = 5;
string Type = 6;
string Publisher = 7;
int32 Residue = 8;
}步骤二：
文件建立好后需要在项目的csproj文件中加上文件的目录（Protos\IBook_Service.prot） GrpcServices意思是客户端（Client），一定要加上 <Protobuf Include="Protos\IBook_Service.proto" GrpcServices="Client" />
引用包（Google.Protobuf、Grpc.AspNetCore、Grpc.Tools）
完成以上步骤，右键项目选择 “重新生成”。生成以后可以在项目的obj文件夹（~\ZP_ProjectEntrance\obj\Debug\net7.0\Protos）看到一个自动生成的Protos文件夹
<ItemGroup>
<PackageReference Include="Google.Protobuf" Version="3.26.0" />
<PackageReference Include="Grpc.AspNetCore" Version="2.61.0" />
<PackageReference Include="Grpc.Tools" Version="2.62.0" />
</ItemGroup>
<ItemGroup>
<Protobuf Include="Protos\IBook_Service.proto" GrpcServices="Client" />
</ItemGroup>步骤三：重点、重点、重点~
创建一个客户端类（ClientHelper）用于对接到Grpc的服务端，通过Func型委托形式构建，做成公共的请求服务端入口。
public static class GrpcClientHelper
{
/// <summary>
/// 一元rpc调用
/// </summary>
/// <typeparam name="TClient">客户端类型</typeparam>
/// <typeparam name="TRequest">请求类型 </typeparam>
/// <typeparam name="TResponse">服务端响应返回类型</typeparam>
/// <typeparam name="TResult">方法返回类型 </typeparam>
/// <param name="serverAddress">请求服务端地址</param>
/// <param name="callFunc">异步调用 gRPC方法的委托 </param>
/// <param name="request">封装请求对象(数据)</param>
/// <param name="clientFactory">创建 gRPC 客户端的委托工厂方法 </param>
/// <returns></returns>
public static async Task<TResult> CallGrpcServiceAsync<TClient, TRequest, TResponse, TResult>(
string serverAddress, Func<TClient, TRequest, Task<TResponse>> callFunc, TRequest request, Func<GrpcChannel, TClient> clientFactory)
where TClient : class
where TRequest : class
where TResponse : class
{
using var channel = GrpcChannel.ForAddress(serverAddress);
var client = clientFactory(channel);
try
{
var response = await callFunc(client, request);
// 这里添加转换逻辑，如果 TResponse 不是 TResult,强制类型转换，需要确保类型兼容
return (TResult)(object)response;
}
catch (RpcException)
{
// 处理异常
throw;
}
}
/// <summary>
/// 获取某个字段的值
/// </summary>
/// <typeparam name="Source"></typeparam>
/// <param name="source"></param>
/// <param name="field"></param>
/// <returns></returns>
public static object GetFieldValue<Source>(Source source, string field)
{
var fieldProperty = source.GetType().GetProperty(field);
if (fieldProperty != null)
return fieldProperty.GetValue(source);
else
return null;
}
} 步骤四：
通过Controllers定义的方法，以请求方法形式进行调用到GrpcClientHelper
namespace ZP_ProjectEntrance.Controllers
{
[Route("api/[controller]")]
[ApiController]
public class BooKController : ControllerBase
{
private readonly ILogger<BooKController> _logger;
public BooKController(ILogger<BooKController> logger)
{
_logger = logger;
}
/// <summary>
/// 获取书籍信息
/// </summary>
/// <returns></returns>
[HttpGet(Name = "GetBook")]
public async Task<BookDto> GetBookAsync()
{
// 服务端地址，可以扩展为请求分布式集群
string serverAddress = "http://localhost:5031";
// 使用 GrpcClientHelper 来调用 gRPC 服务 ,
BookDto bookDto = await GrpcClientHelper.CallGrpcServiceAsync<IBook_Service.IBook_ServiceClient, BookFrom, BookDto, BookDto>(
serverAddress,
async (client, request) => await client.GetBookAsync(request), // 异步调用 gRPC 方法的委托
new BookFrom { BookName = "三国演义" }, // 封装请求对象(值)
(channel) => new IBook_Service.IBook_ServiceClient(channel) // 实现 gRPC 客户端的委托方法
);
_logger.LogInformation(JsonConvert.SerializeObject(bookDto));
return bookDto;
}
}
}至此，客户端的Grpc就完成了。
-----------------客户端代码 END-----------------
项目的结构
附： 贴特征形式实现依赖注入的代码，通过反射机制实现。
注：业务层和仓储层必须是独立层项目，或相同形式进行隔离(要么统一接口I_BLL、I_DLL，要么单纯的BLL、DLL)，否则自行对自动注册类进行改造。
代码可以写在公共层 ExternalService 项目中，作为基础服务进行引用。
using Microsoft.Extensions.DependencyInjection;
using System.Reflection;
namespace ExternalService.RegisterServices
{
/// <summary>
/// 通过反射机制自动化进行依赖注入服务
/// </summary>
public static class ServiceCollectionExtension
{
/// <summary>
/// 注册接口类型服务，继承接口（贴特征）
/// </summary>
/// <param name="services">this服务</param>
/// <param name="assembly">程序集</param>
/// <returns></returns>
public static IServiceCollection RegisterIntfaceTypeService(this IServiceCollection services, Assembly assembly)
{
var interfaces = assembly.GetTypes().Where(t => t.IsInterface).ToList();
var types = assembly.GetTypes().Where(t => t.IsClass).ToList();
foreach (var interf in interfaces)
{
if (interf == null)
continue;
var type = types.FirstOrDefault(interf.IsAssignableFrom);
if (type == null)
continue;
var liftTime = ServiceLifetime.Scoped;
var attr = type.GetCustomAttribute<ServiceAttribute>();
if (attr != null)
liftTime = attr.LifeTime;
else
continue;
switch (liftTime)
{
default:
case ServiceLifetime.Scoped:
{
//作用生命周期：同一请求之间状态共享，跟随HTTP请求生命周期
services.AddScoped(interf, type);
break;
}
case ServiceLifetime.Transient:
{
//瞬时生命周期：无状态化，每次使用是 new ()
services.AddTransient(interf, type);
break;
}
case ServiceLifetime.Singleton:
{
//单例生命周期：整个程序所有请求状态共享，整个程序只有一个实例
services.AddSingleton(interf, type);
break;
}
}
}
return services;
}
/// <summary>
/// 注册普通类服务，非接口类型（贴特征）
/// </summary>
/// <param name="services">this服务</param>
/// <param name="assembly">程序集</param>
/// <param name="NamespaceKeyWord">命名空间关键字</param>
/// <returns></returns>
public static IServiceCollection RegisterClassService(this IServiceCollection services, Assembly assembly, string NamespaceKeyWord = "")
{
var ClassTypes = assembly.GetTypes().Where(t => t.IsClass && !t.IsAbstract).ToList();
if (!string.IsNullOrEmpty(NamespaceKeyWord))
ClassTypes = assembly.GetTypes().Where(t => t.Name.Contains(NamespaceKeyWord)).ToList();
foreach (var types in ClassTypes)
{
if (types == null)
continue;
var liftTime = ServiceLifetime.Scoped;
var attr = types.GetCustomAttribute<ServiceAttribute>();
if (attr != null)
liftTime = attr.LifeTime;
else
continue;
switch (liftTime)
{
default:
case ServiceLifetime.Scoped:
{
//作用生命周期：同一请求之间状态共享，跟随HTTP请求生命周期
services.AddScoped(types);
break;
}
case ServiceLifetime.Transient:
{
//瞬时生命周期：无状态化，每次使用是 new ()
services.AddTransient(types);
break;
}
case ServiceLifetime.Singleton:
{
//单例生命周期：整个程序所有请求状态共享，整个程序只有一个实例
services.AddSingleton(types);
break;
}
}
}
return services;
}
}
/// <summary>
/// 生命周期特征
/// </summary>
[AttributeUsage(AttributeTargets.Class)]
public class ServiceAttribute : Attribute
{
internal ServiceLifetime LifeTime { get; set; }
public ServiceAttribute(ServiceLifetime lifeTime) => LifeTime = lifeTime;
}
}在使用的项目程序集内创建一个扩展服务 AddApplication_Register。然后调用注册类扩展服务services.RegisterClassService(Assembly.GetExecutingAssembly());
using System.Reflection;
using ExternalService.RegisterServices;
using Microsoft.Extensions.DependencyInjection;
namespace Application_Grpc
{
public static class Application_GrpcExtension
{
public static IServiceCollection AddApplication_Register(this IServiceCollection services)
{
services.RegisterClassService(Assembly.GetExecutingAssembly());
return services;
}
}
}在Program.cs内注册添加项目程序集的扩展服务，把上面Application_GrpcExtension类的AddApplication_Register进行调用：builder.Services.AddApplication_Register();
交互图
