gRPC в .NET — Protobuf, streaming, отличие от REST?

syntax = "proto3";

option csharp_namespace = "Shop.Orders.Grpc";
package orders.v1;

import "google/protobuf/timestamp.proto";

service OrderService {
  rpc GetOrder (GetOrderRequest) returns (OrderReply);                       // unary
  rpc WatchOrderStatus (WatchRequest) returns (stream OrderStatusEvent);     // server streaming
  rpc UploadItems (stream OrderItem) returns (UploadSummary);                // client streaming
  rpc Chat (stream ChatMessage) returns (stream ChatMessage);                // bidirectional
}

message GetOrderRequest { int32 order_id = 1; }

message OrderReply {
  int32 id = 1;
  string customer_email = 2;
  repeated OrderItem items = 3;
  int64 total_tiyin = 4;                               // деньги — целым числом минимальных единиц
  google.protobuf.Timestamp created_at = 5;
  OrderStatus status = 6;
}

message OrderItem { string sku = 1; int32 qty = 2; }
enum OrderStatus { ORDER_STATUS_UNSPECIFIED = 0; NEW = 1; PAID = 2; SHIPPED = 3; }
message WatchRequest { int32 order_id = 1; }
message OrderStatusEvent { OrderStatus status = 1; google.protobuf.Timestamp at = 2; }
message UploadSummary { int32 count = 1; }
message ChatMessage { string text = 1; }

<ItemGroup>
  <Protobuf Include="Protos\orders.proto" GrpcServices="Server" />   <!-- или Client / Both -->
  <PackageReference Include="Grpc.AspNetCore" Version="2.*" />
</ItemGroup>

public sealed class OrderGrpcService(IOrderRepository repo, IOrderEvents events) : OrderService.OrderServiceBase
{
    public override async Task<OrderReply> GetOrder(GetOrderRequest request, ServerCallContext context)
    {
        var order = await repo.GetAsync(request.OrderId, context.CancellationToken)
            ?? throw new RpcException(new Status(StatusCode.NotFound, $"Order {request.OrderId} not found"));
        return order.ToReply();
    }

    public override async Task WatchOrderStatus(WatchRequest request, IServerStreamWriter<OrderStatusEvent> stream, ServerCallContext context)
    {
        await foreach (var e in events.SubscribeAsync(request.OrderId, context.CancellationToken))
            await stream.WriteAsync(new OrderStatusEvent { Status = e.Status, At = Timestamp.FromDateTime(e.At) });
    }
}

builder.Services.AddGrpc(o => o.Interceptors.Add<LoggingInterceptor>());
app.MapGrpcService<OrderGrpcService>();

builder.Services.AddGrpcClient<OrderService.OrderServiceClient>(o => o.Address = new Uri("https://orders-api"))
    .AddStandardResilienceHandler();          // ретраи, таймауты, circuit breaker (Microsoft.Extensions.Http.Resilience)

public sealed class CheckoutService(OrderService.OrderServiceClient orders)
{
    public async Task<OrderReply> LoadAsync(int id, CancellationToken ct) =>
        await orders.GetOrderAsync(new GetOrderRequest { OrderId = id },
            deadline: DateTime.UtcNow.AddSeconds(3),          // дедлайн распространяется на сервер
            cancellationToken: ct);

    public async Task WatchAsync(int id, CancellationToken ct)
    {
        using var call = orders.WatchOrderStatus(new WatchRequest { OrderId = id }, cancellationToken: ct);
        await foreach (var e in call.ResponseStream.ReadAllAsync(ct))
            Console.WriteLine($"{e.At}: {e.Status}");
    }
}