C# Academy · Lektion

Grunderna i gRPC och Protobuf

Definiera tjänstekontrakt i .proto-filer, generera C#-kod med Grpc.Tools och förstå gRPC-transport.

Lektion 1 av 413 steg

Grunderna i gRPC och Protobuf är en gratis lektion i C# Academy på CoddyKit. Detta är lektion 1 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för C# Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i C# Academy innehåller totalt 4 lektioner.

Vad är gRPC?

gRPC är ett högpresterande, språkoberoende RPC-ramverk som utvecklats av Google. Det använder HTTP/2 för transport och Protocol Buffers (Protobuf) som serialiseringsformat – betydligt snabbare och mer kompakt än JSON över HTTP/1.1.

Protocol Buffers: IDL

Tjänstekontraktet definieras i en .proto-fil. Protobuf-IDL (Interface Definition Language) är starkt typat och språkneutralt – samma fil genererar klient- och serverkod i C#, Go, Python med flera språk.

// greet.proto
syntax = "proto3";

option csharp_namespace = "GrpcService";

package greet;

service Greeter {
  rpc SayHello (HelloRequest) returns (HelloReply);
}

message HelloRequest {
  string name = 1;
}

message HelloReply {
  string message = 1;
}

Konfigurera en gRPC-server i .NET

Skapa ett gRPC-projekt med dotnet new grpc. Lägg till .proto-filer i projektet, så genererar Grpc.Tools C#-klasserna automatiskt vid bygget.

// .csproj snippet
<ItemGroup>
  <Protobuf Include="Protos\greet.proto" GrpcServices="Server" />
</ItemGroup>

// Program.cs
builder.Services.AddGrpc();

var app = builder.Build();
app.MapGrpcService<GreeterService>();
app.Run();

Implementera en gRPC-tjänst

Ärv från den genererade basklassen och åsidosätt RPC-metoden. Ramverket hanterar serialisering, HTTP/2-inramning och routning automatiskt.

using Grpc.Core;
using GrpcService;

public class GreeterService : Greeter.GreeterBase
{
    private readonly ILogger<GreeterService> _logger;
    public GreeterService(ILogger<GreeterService> logger) => _logger = logger;

    public override Task<HelloReply> SayHello(
        HelloRequest request,
        ServerCallContext context)
    {
        _logger.LogInformation("Saying hello to {Name}", request.Name);
        return Task.FromResult(new HelloReply
        {
            Message = $"Hello, {request.Name}!"
        });
    }
}

Skapa en gRPC-klient

Protobuf-kompilatorn genererar även en starkt typad klientklass. Använd GrpcChannel för att ansluta och anropa tjänsten som om den vore en lokal metod.

// Client project: add Grpc.Net.Client package
using var channel = GrpcChannel.ForAddress("https://localhost:7042");
var client = new Greeter.GreeterClient(channel);

var reply = await client.SayHelloAsync(
    new HelloRequest { Name = "Alice" });

Console.WriteLine(reply.Message); // Hello, Alice!

Protobuf-typer och fältnummer

Varje fält i ett Protobuf-meddelande har ett unikt fältnummer (1–536870911). Fältnumren kodas i binärformatet – ändra dem aldrig efter distribution, eftersom bakåtkompatibiliteten då bryts.

message Product {
  int32  id          = 1;
  string name        = 2;
  double price       = 3;
  int32  stock       = 4;
  bool   is_active   = 5;
  repeated string tags = 6; // array
}

// Supported scalar types:
// int32, int64, uint32, uint64, float, double
// bool, string, bytes, enum

Uppräkningar och kapslade meddelanden

Protobuf stöder uppräkningar och kapslade meddelandetyper. Använd dem för att modellera komplexa domänobjekt i tjänstekontraktet.

enum OrderStatus {
  ORDER_STATUS_UNSPECIFIED = 0;
  ORDER_STATUS_PENDING     = 1;
  ORDER_STATUS_SHIPPED     = 2;
  ORDER_STATUS_CANCELLED   = 3;
}

message Order {
  int32       id       = 1;
  OrderStatus status   = 2;
  repeated OrderLine lines = 3;
}

message OrderLine {
  int32  product_id = 1;
  int32  quantity   = 2;
  double price      = 3;
}

HTTP/2 och gRPC-transport

gRPC använder HTTP/2, som stöder multiplexering – flera samtidiga RPC-anrop över en enda TCP-anslutning – vilket minskar fördröjning och anslutningsöverhead jämfört med HTTP/1.1.

// gRPC requires HTTP/2
// For local dev with HTTP (not HTTPS), enable HTTP/2 cleartext:
builder.WebHost.ConfigureKestrel(opt =>
    opt.ListenLocalhost(5000, o => o.Protocols = HttpProtocols.Http2));

// Client for cleartext (dev only)
AppContext.SetSwitch("System.Net.Http.SocketsHttpHandler.Http2UnencryptedSupport", true);
using var channel = GrpcChannel.ForAddress("http://localhost:5000");

Felhantering med StatusCode

gRPC använder egna statuskoder som skiljer sig från HTTP:s. Kasta RpcException med en Status för att skicka typade felsvar till klienterna.

public override Task<ProductReply> GetProduct(
    ProductRequest request,
    ServerCallContext context)
{
    var product = _repo.FindById(request.Id);
    if (product is null)
        throw new RpcException(
            new Status(StatusCode.NotFound, $"Product {request.Id} not found"));

    return Task.FromResult(MapToReply(product));
}

gRPC-reflektion för utveckling

Aktivera gRPC-reflektion så att verktyg som grpcurl och Postman kan upptäcka era tjänster utan direkt åtkomst till .proto-filen.

// dotnet add package Grpc.AspNetCore.Server.Reflection

builder.Services.AddGrpcReflection();

if (app.Environment.IsDevelopment())
    app.MapGrpcReflectionService();

// Now use grpcurl:
// grpcurl -plaintext localhost:5000 list
// grpcurl -plaintext localhost:5000 greet.Greeter/SayHello

I praktiken: Produktuppslagning med mikrotjänst

En produkttjänst som exponerar en gRPC-endpoint och används internt av en ordertjänst – ett klassiskt mönster för kommunikation mellan tjänster.

// product.proto
service ProductService {
  rpc GetProduct (GetProductRequest) returns (ProductResponse);
  rpc ListProducts (ListProductsRequest) returns (ListProductsResponse);
}

// Order service calls it:
public class OrderService
{
    private readonly ProductService.ProductServiceClient _products;
    public OrderService(ProductService.ProductServiceClient p) => _products = p;

    public async Task<Order> PlaceOrderAsync(int productId, int qty)
    {
        var product = await _products.GetProductAsync(
            new GetProductRequest { Id = productId });
        return new Order { ProductName = product.Name, Quantity = qty };
    }
}

Snabb kontroll

Varför ska ett befintligt Protobuf-fältnummer aldrig ändras efter distribution?

Besvara frågan i den interaktiva lektionen

Sammanfattning: Grunderna i gRPC och Protobuf

Viktiga punkter:

gRPC använder HTTP/2 + Protobuf för snabb, starkt typad kommunikation mellan tjänster
Definiera tjänstekontrakt i .proto-filer – kod genereras vid bygget
Fältnummer utgör trådkodningen – ändra eller återanvänd dem aldrig
Ärv från den genererade basklassen och åsidosätt RPC-metoder
Använd RpcException med StatusCode för typade felsvar
Aktivera gRPC-reflektion för stöd i utvecklingsverktyg

Gratis att börja

Lär dig C# med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 93
Lektioner: 346

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Grunderna i gRPC och Protobuf” gratis?

Ja – hela texten till ”Grunderna i gRPC och Protobuf” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i C# Academy, kan Ni uppgradera till CoddyKit PRO. Kursen i C# Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”Grunderna i gRPC och Protobuf”?

Definiera tjänstekontrakt i .proto-filer, generera C#-kod med Grpc.Tools och förstå gRPC-transport. Ni övar på C# Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig C# Academy?

Du behöver inga förkunskaper. Utbildningen i C# Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 1 av 4.

Hur lång tid tar lektionen ”Grunderna i gRPC och Protobuf”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här C# Academy-lektionen?

Ja. Varje C# Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till C# Academy