gRPC in .NET Core：高性能服务间通信实践

// 在 .csproj 中添加 proto 文件引用
// <Protobuf Include="Protos\order_service.proto" GrpcServices="Server" />

// 实现服务
public class OrderGrpcService : OrderService.OrderServiceBase
{
    private readonly IOrderService _orderService;
    private readonly ILogger<OrderGrpcService> _logger;

    public OrderGrpcService(IOrderService orderService,
                             ILogger<OrderGrpcService> logger)
    {
        _orderService = orderService;
        _logger = logger;
    }

    public override async Task<CreateOrderResponse> CreateOrder(
        CreateOrderRequest request,
        ServerCallContext context)
    {
        // 从 gRPC metadata 中获取认证信息（类似 HTTP Header）
        var userId = context.RequestHeaders.GetValue("x-user-id");
        _logger.LogInformation("CreateOrder called by user {UserId}", userId);

        var order = await _orderService.CreateAsync(new CreateOrderDto
        {
            UserId = request.UserId,
            Items = request.Items.Select(i => new OrderItemDto
            {
                ProductId = i.ProductId,
                Quantity = i.Quantity,
                UnitPrice = (decimal)i.UnitPrice
            }).ToList()
        }, context.CancellationToken);

        return new CreateOrderResponse
        {
            OrderId = order.Id,
            OrderNo = order.OrderNo
        };
    }

    // 服务端流：实时推送订单状态更新
    public override async Task WatchOrderStatus(
        WatchOrderRequest request,
        IServerStreamWriter<OrderStatusUpdate> responseStream,
        ServerCallContext context)
    {
        while (!context.CancellationToken.IsCancellationRequested)
        {
            var status = await _orderService.GetStatusAsync(request.OrderId);

            await responseStream.WriteAsync(new OrderStatusUpdate
            {
                OrderId = request.OrderId,
                Status = status.ToString()
            });

            await Task.Delay(TimeSpan.FromSeconds(2), context.CancellationToken);
        }
    }
}

// Startup.cs 注册
public void ConfigureServices(IServiceCollection services)
{
    services.AddGrpc(options =>
    {
        options.EnableDetailedErrors = env.IsDevelopment();
        options.MaxReceiveMessageSize = 16 * 1024 * 1024; // 16MB
    });
}

public void Configure(IApplicationBuilder app)
{
    app.UseRouting();
    app.UseEndpoints(endpoints =>
    {
        endpoints.MapGrpcService<OrderGrpcService>();
    });
}

// 在 .csproj 中添加
// <Protobuf Include="Protos\order_service.proto" GrpcServices="Client" />

// 注册 gRPC 客户端（利用 IHttpClientFactory 管理连接）
services.AddGrpcClient<OrderService.OrderServiceClient>(options =>
{
    options.Address = new Uri("https://order-service:5001");
})
.ConfigureChannel(options =>
{
    options.Credentials = ChannelCredentials.SecureSsl;
})
.AddCallCredentials((context, metadata) =>
{
    // 自动注入认证 Token
    metadata.Add("Authorization", $"Bearer {GetToken()}");
    return Task.CompletedTask;
});

// 使用
public class ApiController : ControllerBase
{
    private readonly OrderService.OrderServiceClient _orderClient;

    public ApiController(OrderService.OrderServiceClient orderClient)
    {
        _orderClient = orderClient;
    }

    [HttpPost("orders")]
    public async Task<IActionResult> CreateOrder([FromBody] CreateOrderApiRequest request)
    {
        var grpcResponse = await _orderClient.CreateOrderAsync(
            new CreateOrderRequest
            {
                UserId = request.UserId,
                Items = { request.Items.Select(i => new OrderItem
                {
                    ProductId = i.ProductId,
                    Quantity = i.Quantity
                })}
            },
            deadline: DateTime.UtcNow.AddSeconds(5)); // 超时设置

        return Ok(new { orderId = grpcResponse.OrderId });
    }
}

// 服务端抛出 gRPC 异常
public override async Task<OrderDto> GetOrder(
    GetOrderRequest request,
    ServerCallContext context)
{
    var order = await _orderService.FindAsync(request.OrderId);

    if (order == null)
    {
        throw new RpcException(new Status(
            StatusCode.NotFound,
            $"订单 {request.OrderId} 不存在"));
    }

    return MapToDto(order);
}

// 客户端捕获
try
{
    var order = await _client.GetOrderAsync(new GetOrderRequest { OrderId = 999 });
}
catch (RpcException ex) when (ex.StatusCode == StatusCode.NotFound)
{
    Console.WriteLine($"订单不存在：{ex.Status.Detail}");
}
catch (RpcException ex) when (ex.StatusCode == StatusCode.DeadlineExceeded)
{
    Console.WriteLine("请求超时");
}