ASP.NET Core アーキテクチャの深層 — リクエストが到達してからレスポンスを返すまで

var builder = WebApplication.CreateBuilder(args);
// 内部で起こること:
// 1. HostApplicationBuilder を初期化
// 2. Kestrel を既定の Web サーバーとして設定
// 3. 設定ソース (appsettings.json, 環境変数等) をロード
// 4. ログプロバイダーを設定
// 5. DI コンテナ (ServiceCollection) を初期化

// dotnet/aspnetcore の簡略化した実装イメージ
public static WebApplicationBuilder CreateBuilder(string[] args)
{
    var builder = new WebApplicationBuilder(
        new WebApplicationOptions { Args = args });
    return builder;
}

// Kestrel の HTTP/1.1 パーサーの簡略イメージ
while (true)
{
    // PipeReader からデータを読み取り（コピー不要）
    ReadResult result = await reader.ReadAsync();
    ReadOnlySequence<byte> buffer = result.Buffer;
 
    // HTTP リクエストラインとヘッダーをパース
    if (TryParseRequest(buffer, out var consumed, out var examined))
    {
        reader.AdvanceTo(consumed, examined);
        break;
    }
 
    // データが不足している場合、追加データを待つ
    reader.AdvanceTo(buffer.Start, buffer.End);
}

// RequestDelegate の定義
public delegate Task RequestDelegate(HttpContext context);
 
// ミドルウェアの基本形
public class MyMiddleware
{
    private readonly RequestDelegate _next;
 
    public MyMiddleware(RequestDelegate next)
    {
        _next = next;
    }
 
    public async Task InvokeAsync(HttpContext context)
    {
        // リクエスト処理（パイプラインの下流へ行く前）
        Console.WriteLine("Before next middleware");
 
        await _next(context); // 次のミドルウェアを呼び出す
 
        // レスポンス処理（パイプラインの下流から戻ってきた後）
        Console.WriteLine("After next middleware");
    }
}

// ApplicationBuilder.Build() の簡略化した実装
public RequestDelegate Build()
{
    // 最終段：どのミドルウェアも処理しなかった場合 404 を返す
    RequestDelegate app = context =>
    {
        context.Response.StatusCode = 404;
        return Task.CompletedTask;
    };
 
    // 登録されたミドルウェアを逆順に適用
    for (int i = _components.Count - 1; i >= 0; i--)
    {
        app = _components[i](app);
    }
 
    return app;
}

// 危険：Singleton が Scoped に依存
services.AddSingleton<MySingleton>();
services.AddScoped<MyScopedService>();
 
public class MySingleton
{
    private readonly MyScopedService _scoped; // この参照がリーク
 
    public MySingleton(MyScopedService scoped)
    {
        _scoped = scoped; // リクエストをまたいで保持されてしまう
    }
}

builder.Host.UseDefaultServiceProvider(options =>
{
    options.ValidateScopes = true;  // 開発環境では既定で有効
    options.ValidateOnBuild = true; // ビルド時に依存関係を検証
});

// ServiceProvider の解決プロセスの概要
// 1. CallSiteFactory が ServiceDescriptor から CallSite ツリーを構築
// 2. RuntimeResolver / CompiledResolver が CallSite を走査してインスタンスを生成
// 3. ライフタイムに応じたキャッシュに格納
 
// 高頻度で呼ばれるため、以下の最適化が適用されています（.NET Core 3.0 以降改善が継続）:
// - IL Emit によるファクトリの動的コンパイル
// - Expression Tree から Delegate への変換
// - キャッシュ済み Singleton の直接返却

// ルートパターンの例と内部的なマッチング
app.MapGet("/api/users/{id:int}", (int id) => ...);
// パターン: Literal("api") -> Literal("users") -> Parameter("id", IntConstraint)
 
app.MapGet("/api/users/{id:guid}", (Guid id) => ...);
// パターン: Literal("api") -> Literal("users") -> Parameter("id", GuidConstraint)
 
// 同じパスでも制約が異なれば別のエンドポイントにマッチ
// /api/users/42       → int 版
// /api/users/abc-def  → guid 版（GUID 形式の場合）

// バインディングソースの明示指定
[HttpPost("api/orders/{id}")]
public IActionResult UpdateOrder(
    [FromRoute] int id,           // URL: /api/orders/42
    [FromQuery] bool notify,      // Query: ?notify=true
    [FromBody] OrderDto order,    // Body: JSON
    [FromHeader(Name = "X-Correlation-Id")] string correlationId,
    [FromServices] IOrderService service)  // DI コンテナ
{
    // ...
}

// Source Generator を使った高速 JSON シリアライズ
[JsonSerializable(typeof(WeatherForecast))]
[JsonSerializable(typeof(List<WeatherForecast>))]
public partial class AppJsonContext : JsonSerializerContext { }
 
// Program.cs で登録
builder.Services.ConfigureHttpJsonOptions(options =>
{
    options.SerializerOptions.TypeInfoResolverChain
        .Insert(0, AppJsonContext.Default);
});

app.MapGet("/api/users/{id}", (int id) => ...)
    .AddEndpointFilter(async (context, next) =>
    {
        var id = context.GetArgument<int>(0);
        if (id <= 0)
        {
            return Results.BadRequest("ID は正の整数である必要があります");
        }
 
        // 次のフィルタまたはハンドラを実行
        return await next(context);
    });

// 構成値の取得方法
// 1. IConfiguration から直接取得
var connectionString = builder.Configuration
    .GetConnectionString("DefaultConnection");
 
// 2. Options パターン（推奨）
builder.Services.Configure<SmtpSettings>(
    builder.Configuration.GetSection("Smtp"));
 
// 3. 型安全な Options with validation
builder.Services.AddOptions<SmtpSettings>()
    .BindConfiguration("Smtp")
    .ValidateDataAnnotations()
    .ValidateOnStart(); // 起動時にバリデーション実行

// IOptionsMonitor で構成変更をリアルタイム監視
public class MyService
{
    private readonly IOptionsMonitor<MyConfig> _config;
 
    public MyService(IOptionsMonitor<MyConfig> config)
    {
        _config = config;
        _config.OnChange(newConfig =>
        {
            Console.WriteLine($"構成が変更されました: {newConfig.SomeKey}");
        });
    }
 
    public string GetValue() => _config.CurrentValue.SomeKey;
}

// AuthenticationMiddleware の簡略化した実装
public async Task InvokeAsync(HttpContext context)
{
    // 1. 既定のスキームで認証を試行
    var result = await context.AuthenticateAsync();
 
    if (result.Succeeded)
    {
        // 2. ClaimsPrincipal を HttpContext に設定
        context.User = result.Principal;
    }
 
    // 3. 次のミドルウェア（通常は Authorization）へ
    await _next(context);
}

// カスタム認可ポリシーの定義
builder.Services.AddAuthorization(options =>
{
    options.AddPolicy("AdminOnly", policy =>
        policy.RequireRole("Admin"));
 
    options.AddPolicy("MinimumAge", policy =>
        policy.Requirements.Add(new MinimumAgeRequirement(18)));
});
 
// カスタム AuthorizationHandler
public class MinimumAgeHandler
    : AuthorizationHandler<MinimumAgeRequirement>
{
    protected override Task HandleRequirementAsync(
        AuthorizationHandlerContext context,
        MinimumAgeRequirement requirement)
    {
        var birthDateClaim = context.User.FindFirst("birth_date");
        if (birthDateClaim is null)
        {
            return Task.CompletedTask; // Fail（明示的に Succeed しない）
        }
 
        var birthDate = DateOnly.Parse(birthDateClaim.Value);
        var age = DateOnly.FromDateTime(DateTime.Today)
            .DayNumber - birthDate.DayNumber;
 
        if (age / 365 >= requirement.MinimumAge)
        {
            context.Succeed(requirement);
        }
 
        return Task.CompletedTask;
    }
}

// Kestrel が提供する Feature の例
var connectionFeature = context.Features
    .Get<IHttpConnectionFeature>();
var localIp = connectionFeature?.LocalIpAddress;
 
// HTTP レスポンストレーラー（レスポンスボディの後に送信される末尾ヘッダー）
var trailersFeature = context.Features
    .Get<IHttpResponseTrailersFeature>();
 
// リクエストのタイムアウト (.NET 8+)
var timeoutFeature = context.Features
    .Get<IHttpRequestTimeoutFeature>();
timeoutFeature?.DisableTimeout();

// StringBuilder のプーリング例
var pool = serviceProvider
    .GetRequiredService<ObjectPool<StringBuilder>>();
 
var sb = pool.Get();
try
{
    sb.Append("Hello ");
    sb.Append("World");
    return sb.ToString();
}
finally
{
    pool.Return(sb); // プールに返却（Clear も自動）
}

// Kestrel 内部で使われるバッファ管理パターン
byte[] buffer = ArrayPool<byte>.Shared.Rent(4096);
try
{
    int bytesRead = await stream.ReadAsync(
        buffer.AsMemory(0, 4096));
    ProcessData(buffer.AsSpan(0, bytesRead));
}
finally
{
    ArrayPool<byte>.Shared.Return(buffer);
}

builder.Services.AddResponseCompression(options =>
{
    options.EnableForHttps = true; // HTTPS でも圧縮
    options.Providers.Add<BrotliCompressionProvider>();
    options.Providers.Add<GzipCompressionProvider>();
});
 
builder.Services.Configure<BrotliCompressionProviderOptions>(
    options => options.Level = CompressionLevel.Fastest);

// グローバルに Problem Details を有効化
builder.Services.AddProblemDetails(options =>
{
    options.CustomizeProblemDetails = context =>
    {
        context.ProblemDetails.Extensions["traceId"] =
            context.HttpContext.TraceIdentifier;
    };
});
 
// 例外ハンドラーでの使用
app.UseExceptionHandler();
app.UseStatusCodePages();
 
// レスポンス例:
// {
//   "type": "https://tools.ietf.org/html/rfc9110#section-15.5.5",
//   "title": "Not Found",
//   "status": 404,
//   "traceId": "00-abc123-def456-01"
// }

public class ApiTests : IClassFixture<WebApplicationFactory<Program>>
{
    private readonly HttpClient _client;
 
    public ApiTests(WebApplicationFactory<Program> factory)
    {
        _client = factory.WithWebHostBuilder(builder =>
        {
            builder.ConfigureServices(services =>
            {
                // テスト用にサービスを差し替え
                services.AddScoped<IEmailService, FakeEmailService>();
            });
        }).CreateClient();
    }
 
    [Fact]
    public async Task GetUsers_ReturnsOk()
    {
        var response = await _client.GetAsync("/api/users");
        response.EnsureSuccessStatusCode();
 
        var users = await response.Content
            .ReadFromJsonAsync<List<UserDto>>();
        Assert.NotEmpty(users);
    }
}