C# Academy · Pelajaran

RPC Unary & Streaming Server

Implementasikan panggilan unary dan streaming sisi server untuk mengirim data dari server ke klien secara real-time.

RPC Unary & Streaming Server adalah pelajaran C# Academy gratis di CoddyKit. Ini adalah pelajaran 2 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar C# Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus C# Academy mencakup 4 pelajaran total.

Jenis RPC gRPC

gRPC mendukung empat pola RPC: Tunggal (permintaan/respons), Aliran Peladen (klien mengirim satu, peladen mengirim banyak), Aliran Klien, dan Aliran Dua Arah. Pelajaran ini membahas dua pola pertama.

RPC Tunggal: Pola Dasar

Pola tunggal adalah pola paling sederhana—satu permintaan, satu respons. Pola ini tampak seperti pemanggilan fungsi biasa, tetapi berjalan melalui HTTP/2 dengan pengodean Protobuf.

// .proto definition
service OrderService {
  rpc GetOrder (GetOrderRequest) returns (OrderResponse);
}

message GetOrderRequest { int32 id = 1; }
message OrderResponse   { int32 id = 1; string status = 2; double total = 3; }

Mengimplementasikan RPC Tunggal

Override metode dasar yang dihasilkan. ServerCallContext menyediakan metadata, token pembatalan, tenggat waktu, dan informasi rekan.

public class OrderService : OrderService.OrderServiceBase
{
    private readonly IOrderRepository _repo;
    public OrderService(IOrderRepository repo) => _repo = repo;

    public override async Task<OrderResponse> GetOrder(
        GetOrderRequest request,
        ServerCallContext context)
    {
        var order = await _repo.GetByIdAsync(request.Id, context.CancellationToken);
        if (order is null)
            throw new RpcException(new Status(StatusCode.NotFound, "Order not found"));

        return new OrderResponse
        {
            Id     = order.Id,
            Status = order.Status.ToString(),
            Total  = (double)order.Total
        };
    }
}

Memanggil RPC Satu Arah dari Klien

Klien yang dihasilkan menyediakan metode yang tampak sinkron maupun metode yang benar-benar asinkron. Selalu gunakan varian Async di lingkungan produksi.

var client = new OrderService.OrderServiceClient(channel);

// Async call with cancellation
var cts = new CancellationTokenSource(TimeSpan.FromSeconds(5));
var reply = await client.GetOrderAsync(
    new GetOrderRequest { Id = 42 },
    cancellationToken: cts.Token);

Console.WriteLine($"Order {reply.Id}: {reply.Status} - ${reply.Total}");

Streaming dari Server: Definisi Proto

Streaming dari server menambahkan kata kunci stream sebelum tipe respons. Server mengirim beberapa pesan melalui koneksi yang sama sebelum menutup aliran.

service StockService {
  // Client sends one symbol, server streams price updates
  rpc WatchStock (WatchRequest) returns (stream StockUpdate);
}

message WatchRequest  { string symbol = 1; }
message StockUpdate   { string symbol = 1; double price = 2; int64 timestamp = 3; }

Menerapkan Streaming dari Server

Gunakan IServerStreamWriter<T> untuk mengirim pesan. Metode tersebut mengembalikan Task — tulis hingga selesai, lalu kembalikan kontrol.

public override async Task WatchStock(
    WatchRequest request,
    IServerStreamWriter<StockUpdate> responseStream,
    ServerCallContext context)
{
    while (!context.CancellationToken.IsCancellationRequested)
    {
        var price = await _market.GetPriceAsync(request.Symbol);

        await responseStream.WriteAsync(new StockUpdate
        {
            Symbol    = request.Symbol,
            Price     = price,
            Timestamp = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds()
        });

        await Task.Delay(1000, context.CancellationToken);
    }
}

Menerima Aliran dari Server di Klien

Gunakan await foreach pada ResponseStream.ReadAllAsync() untuk memproses setiap pesan saat tiba.

using var call = client.WatchStock(
    new WatchRequest { Symbol = "MSFT" });

await foreach (var update in call.ResponseStream.ReadAllAsync())
{
    Console.WriteLine($"{update.Symbol}: ${update.Price:F2}");
}
// Continues until server closes the stream or client cancels

Membatalkan Aliran dari Server

Teruskan CancellationToken saat membuka panggilan untuk menghentikan aliran di sisi klien. Server menerima pembatalan melalui token miliknya sendiri.

var cts = new CancellationTokenSource();

// Cancel after 30 seconds
cts.CancelAfter(TimeSpan.FromSeconds(30));

using var call = client.WatchStock(
    new WatchRequest { Symbol = "AAPL" },
    cancellationToken: cts.Token);

try
{
    await foreach (var update in
        call.ResponseStream.ReadAllAsync(cts.Token))
    {
        Console.WriteLine($"Price: {update.Price}");
    }
}
catch (OperationCanceledException)
{
    Console.WriteLine("Stream cancelled.");
}

Metadata: Header Permintaan dan Trailer

gRPC mendukung metadata (pasangan kunci-nilai) yang dikirim sebagai header sebelum respons dan trailer setelah respons. Gunakan metadata untuk token autentikasi, ID pelacakan, atau kursor paginasi.

// Server: send initial metadata
await context.WriteResponseHeadersAsync(new Metadata
{
    { "x-correlation-id", Guid.NewGuid().ToString() }
});

// Server: set trailing metadata
context.ResponseTrailers.Add("x-total-count", "1500");

// Client: read headers
var headers  = await call.ResponseHeadersAsync;
var trailerId = headers.GetValue("x-correlation-id");

gRPC-Web untuk Klien Peramban

Peramban tidak dapat menggunakan gRPC mentah (trailer HTTP/2 tidak didukung). Gunakan Grpc.AspNetCore.Web dan klien JavaScript grpc-web atau Grpc.Net.Client.Web milik Blazor.

// dotnet add package Grpc.AspNetCore.Web

app.UseGrpcWeb();
app.MapGrpcService<GreeterService>().EnableGrpcWeb();

// Blazor client:
var handler = new GrpcWebHandler(GrpcWebMode.GrpcWeb,
    new HttpClientHandler());
using var channel = GrpcChannel.ForAddress(
    "https://localhost:7042",
    new GrpcChannelOptions { HttpHandler = handler });

Layanan Streaming Log di Dunia Nyata

Layanan agregasi log mengalirkan entri log aplikasi ke klien pemantauan yang terhubung secara waktu nyata menggunakan streaming dari server.

public override async Task StreamLogs(
    LogStreamRequest request,
    IServerStreamWriter<LogEntry> responseStream,
    ServerCallContext context)
{
    await foreach (var log in _logChannel.Reader.ReadAllAsync(
        context.CancellationToken))
    {
        if (log.Level >= request.MinLevel)
        {
            await responseStream.WriteAsync(new LogEntry
            {
                Level   = log.Level.ToString(),
                Message = log.Message,
                Timestamp = Timestamp.FromDateTime(log.Timestamp)
            });
        }
    }
}

Pemeriksaan Singkat

Kata kunci apa dalam berkas .proto yang menunjukkan RPC streaming dari server?

Ringkasan: RPC Satu Arah dan Streaming dari Server

Poin penting:

RPC satu arah: satu permintaan, satu respons — pola yang paling umum
Streaming dari server: satu permintaan, beberapa pesan respons seiring waktu
Terapkan streaming dari server dengan menulis ke IServerStreamWriter<T>
Terima aliran dari server dengan await foreach pada ReadAllAsync()
Gunakan CancellationToken untuk menghentikan aliran dengan rapi dari salah satu sisi
gRPC-Web memungkinkan klien peramban memanggil layanan gRPC

Pertanyaan yang Sering Diajukan

Apakah pelajaran “RPC Unary & Streaming Server” gratis?

Ya — teks lengkap “RPC Unary & Streaming Server” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus C# Academy, upgrade ke CoddyKit PRO. Kursus C# Academy mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “RPC Unary & Streaming Server”?

Implementasikan panggilan unary dan streaming sisi server untuk mengirim data dari server ke klien secara real-time. Kamu berlatih C# Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai C# Academy?

Tidak diperlukan pengalaman sebelumnya. C# Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 2 dari 4.

Berapa lama pelajaran “RPC Unary & Streaming Server” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran C# Academy ini?

Ya. Setiap pelajaran C# Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

← Kembali ke C# Academy