C# Academy · Pelajaran

Gambaran Umum Alur ASP.NET Core

Pahami cara permintaan mengalir melalui alur middleware dan HttpContext, serta cara respons dibangun.

Pelajaran 1 dari 412 langkah

Gambaran Umum Alur ASP.NET Core adalah pelajaran C# Academy gratis di CoddyKit. Ini adalah pelajaran 1 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.

Alur Permintaan

Setiap permintaan HTTP dalam ASP.NET Core mengalir melalui alur middleware. Setiap bagian middleware dapat memeriksa, mengubah, menghentikan sementara, atau meneruskan permintaan ke komponen berikutnya. Memahami alur ini merupakan dasar penting untuk membangun aplikasi ASP.NET Core.

HttpContext: Amplop Permintaan

HttpContext membawa semua informasi tentang permintaan dan respons: header, kuki, isi, klaim pengguna, informasi koneksi, serta token pembatalan. Semua middleware beroperasi pada objek ini.

app.Use(async (context, next) =>
{
    // Read request info
    var method  = context.Request.Method;
    var path    = context.Request.Path;
    var headers = context.Request.Headers;
    var user    = context.User.Identity?.Name;

    // Write to response
    context.Response.Headers.Append("X-Processed-By", "MyMiddleware");

    await next(context); // forward to next middleware
});

Urutan Pendaftaran Middleware

Middleware berjalan sesuai urutan pendaftarannya. Respons dibuka kembali dalam urutan terbalik, seperti tumpukan. Urutan sangat penting: autentikasi harus berjalan sebelum otorisasi; perutean harus berjalan sebelum pencocokan titik akhir.

// Typical order for an ASP.NET Core app:
app.UseExceptionHandler("/error"); // outermost — catches everything
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();
app.UseCors("policy");
app.UseAuthentication();  // must be before Authorization
app.UseAuthorization();
app.UseRateLimiter();
app.UseOutputCache();
// MapHub, MapControllers, MapGet etc.
app.Run();

Use, Run, dan Map

Tiga metode menambahkan middleware: Use (memanggil next), Run (bersifat terminal dan tidak pernah memanggil next), serta Map (membuat percabangan berdasarkan jalur).

// Use: passes to next
app.Use(async (ctx, next) =>
{
    Console.WriteLine("Before");
    await next(ctx);
    Console.WriteLine("After");
});

// Run: terminal — no next
app.Run(async ctx =>
    await ctx.Response.WriteAsync("Terminal"));

// Map: branch on path prefix
app.Map("/api", apiApp =>
    apiApp.Run(async ctx =>
        await ctx.Response.WriteAsync("API branch")));

Isi Permintaan dan Respons

Isi permintaan dan respons berupa aliran data. Isi permintaan hanya dapat dibaca satu kali — aktifkan buffering isi permintaan jika Anda perlu membacanya beberapa kali, misalnya dalam beberapa middleware.

app.Use(async (ctx, next) =>
{
    // Enable buffering so body can be read multiple times
    ctx.Request.EnableBuffering();

    using var reader = new StreamReader(
        ctx.Request.Body,
        leaveOpen: true);
    var body = await reader.ReadToEndAsync();
    ctx.Request.Body.Position = 0; // rewind for next middleware

    Console.WriteLine($"Body: {body}");
    await next(ctx);
});

Menghentikan Alur Lebih Awal

Middleware dapat menghentikan alur lebih awal dengan menulis respons dan NOT memanggil next. Ini berguna untuk gerbang autentikasi, pemeriksaan kesehatan, atau halaman pemeliharaan.

app.Use(async (ctx, next) =>
{
    if (ctx.Request.Path == "/maintenance")
    {
        ctx.Response.StatusCode = 503;
        await ctx.Response.WriteAsync("Service under maintenance");
        return; // short-circuit — next is NOT called
    }
    await next(ctx);
});

Antarmuka IMiddleware

Untuk middleware berbasis kelas yang memerlukan DI, implementasikan IMiddleware. Daftarkan implementasinya dalam DI dan gunakan app.UseMiddleware<T>().

public class RequestTimingMiddleware : IMiddleware
{
    private readonly ILogger<RequestTimingMiddleware> _logger;
    public RequestTimingMiddleware(ILogger<RequestTimingMiddleware> l) => _logger = l;

    public async Task InvokeAsync(HttpContext ctx, RequestDelegate next)
    {
        var sw = System.Diagnostics.Stopwatch.StartNew();
        await next(ctx);
        _logger.LogInformation("{Method} {Path}: {Ms}ms",
            ctx.Request.Method, ctx.Request.Path, sw.ElapsedMilliseconds);
    }
}

// Register:
builder.Services.AddTransient<RequestTimingMiddleware>();
app.UseMiddleware<RequestTimingMiddleware>();

Kelas Middleware Konvensional

Alternatifnya, buat kelas dengan metode InvokeAsync(HttpContext, RequestDelegate). Kerangka kerja menyuntikkan dependensi, termasuk delegasi berikutnya, melalui konstruktor.

public class ApiKeyMiddleware
{
    private readonly RequestDelegate _next;
    private readonly string _key;

    // RequestDelegate injected by framework
    public ApiKeyMiddleware(RequestDelegate next, IConfiguration cfg)
    {
        _next = next;
        _key = cfg["ApiKey"] ?? "";
    }

    public async Task InvokeAsync(HttpContext ctx)
    {
        if (ctx.Request.Headers["X-Api-Key"] != _key)
        {
            ctx.Response.StatusCode = 401;
            return;
        }
        await _next(ctx);
    }
}

Memodifikasi Respons Setelah next

Kode setelah await next(ctx) berjalan setelah penulisan respons dimulai. Anda dapat menambahkan header respons sebelum next, tetapi tidak dapat mengubah kode status atau isi setelahnya.

app.Use(async (ctx, next) =>
{
    // Before: add response headers (safe)
    ctx.Response.OnStarting(() =>
    {
        ctx.Response.Headers.Append("X-Request-Id",
            Guid.NewGuid().ToString("N"));
        return Task.CompletedTask;
    });

    await next(ctx);

    // After: response may already be sent
    // SAFE: logging, metrics
    // UNSAFE: changing status code or writing body
    Console.WriteLine($"Response status: {ctx.Response.StatusCode}");
});

Di Dunia Nyata: Middleware ID Korelasi

Middleware ID korelasi untuk produksi yang menambahkan ID pelacakan ke setiap permintaan untuk pelacakan terdistribusi dan pencatatan.

public class CorrelationIdMiddleware
{
    private readonly RequestDelegate _next;
    private const string Header = "X-Correlation-Id";

    public CorrelationIdMiddleware(RequestDelegate next) => _next = next;

    public async Task InvokeAsync(HttpContext ctx)
    {
        var correlationId = ctx.Request.Headers[Header].FirstOrDefault()
            ?? Guid.NewGuid().ToString("N");

        ctx.Items["CorrelationId"] = correlationId;

        ctx.Response.OnStarting(() =>
        {
            ctx.Response.Headers.Append(Header, correlationId);
            return Task.CompletedTask;
        });

        using (Serilog.Context.LogContext.PushProperty("CorrelationId", correlationId))
            await _next(ctx);
    }
}

Pemeriksaan Singkat

Apa perbedaan antara app.Use() dan app.Run() saat menambahkan middleware?

Jawab di pelajaran interaktif

Rangkuman: Ikhtisar Alur ASP.NET Core

Inti penting:

Middleware berjalan sesuai urutan pendaftaran; respons dibuka kembali dalam urutan terbalik
Use → memanggil next; Run → terminal; Map → percabangan berdasarkan jalur
HttpContext berisi permintaan, respons, pengguna, dan token pembatalan
Aktifkan buffering untuk membaca isi permintaan beberapa kali
Antarmuka IMiddleware memungkinkan middleware berbasis kelas yang ramah terhadap DI
Tambahkan header respons melalui OnStarting(); jangan ubah status setelah next

Gratis untuk memulai

Belajar C# dengan tutor AI — gratis

Tulis dan jalankan kode asli di browser kamu, dapatkan bantuan instan dari tutor AI 24/7, dan lanjutkan di mana kamu tinggalkan di web atau aplikasi.

Kursus: 93
Pelajaran: 346

Mulai belajar gratis Lihat kursus lengkapnya

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Gambaran Umum Alur ASP.NET Core” gratis?

Ya — teks lengkap “Gambaran Umum Alur ASP.NET Core” 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 “Gambaran Umum Alur ASP.NET Core”?

Pahami cara permintaan mengalir melalui alur middleware dan HttpContext, serta cara respons dibangun. 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 1 dari 4.

Berapa lama pelajaran “Gambaran Umum Alur ASP.NET Core” 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