以上概念以及相关知识点来自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();