# ASP.NET Core Minimal APIs 2026: สถาปัตยกรรม ประสิทธิภาพ และคำถามสัมภาษณ์งาน

> คู่มือฉบับสมบูรณ์เกี่ยวกับ ASP.NET Core Minimal APIs พร้อมสถาปัตยกรรมสมัยใหม่ การเพิ่มประสิทธิภาพด้วย Native AOT และคำถามสัมภาษณ์ที่พบบ่อยสำหรับนักพัฒนา .NET

- Published: 2026-07-24
- Updated: 2026-07-24
- Author: SharpSkill
- Reading time: 5 min

---

ASP.NET Core Minimal APIs ลดความซับซ้อนของ boilerplate code จาก MVC controllers แบบดั้งเดิม โดยนำเสนอวิธีการที่กระชับกว่าในการสร้าง HTTP endpoints ตั้งแต่เปิดตัวใน .NET 6 และได้รับการปรับปรุงอย่างต่อเนื่องผ่าน .NET 8, 9 และปัจจุบันคือ .NET 10 Minimal APIs ได้พัฒนาเป็นตัวเลือกที่พร้อมใช้งานในระบบ production สำหรับ microservices, serverless functions และ lightweight web services

> **Minimal APIs vs Controllers**
>
> Minimal APIs ใช้ top-level route handlers ที่กำหนดโดยตรงใน Program.cs ในขณะที่ MVC controllers ต้องการการกำหนด class, attributes และ convention-based routing สำหรับการดำเนินการ CRUD ง่ายๆ หรือ microservices ที่มีน้อยกว่า 20 endpoints Minimal APIs มักจะลดโค้ดได้ 40-60%

## สถาปัตยกรรม Minimal API และ Request Pipeline

Request pipeline ของ ASP.NET Core ประมวลผล HTTP requests ผ่าน middleware components ก่อนที่จะถึง endpoint handlers Minimal APIs ผสานรวมกับ pipeline นี้อย่างราบรื่น พร้อมทั้งนำเสนอ syntax ที่ประกาศชัดเจนมากขึ้นสำหรับการกำหนด route

```csharp
// Program.cs
var builder = WebApplication.CreateBuilder(args);

// Register services for dependency injection
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();
builder.Services.AddScoped<IProductRepository, ProductRepository>();

var app = builder.Build();

// Middleware pipeline configuration
app.UseExceptionHandler("/error");
app.UseHttpsRedirection();
app.UseAuthorization();

// Minimal API endpoint definitions
app.MapGet("/products", async (IProductRepository repo) =>
    Results.Ok(await repo.GetAllAsync()));

app.MapGet("/products/{id:int}", async (int id, IProductRepository repo) =>
    await repo.GetByIdAsync(id) is Product product
        ? Results.Ok(product)
        : Results.NotFound());

app.Run();
```

รูปแบบนี้รวมศูนย์การกำหนด route ในขณะที่ยังคงเข้าถึง dependency injection container ได้อย่างเต็มที่ พารามิเตอร์ `IProductRepository` แสดงให้เห็นถึง constructor-less injection โดยตรงเข้าไปใน handler delegates

## Route Groups และการจัดระเบียบ Endpoint

เมื่อแอปพลิเคชันเติบโต การจัดระเบียบ endpoints กลายเป็นสิ่งสำคัญ Route groups ที่เปิดตัวใน .NET 7 ให้ namespacing และการกำหนดค่าร่วมกันโดยไม่ต้องเสียสละแนวทางที่เรียบง่าย

```csharp
// ProductEndpoints.cs
public static class ProductEndpoints
{
    public static void MapProductEndpoints(this WebApplication app)
    {
        var group = app.MapGroup("/api/products")
            .WithTags("Products")
            .RequireAuthorization();

        group.MapGet("/", GetAllProducts);
        group.MapGet("/{id:int}", GetProductById);
        group.MapPost("/", CreateProduct)
            .Accepts<CreateProductRequest>("application/json")
            .Produces<Product>(StatusCodes.Status201Created);
        group.MapPut("/{id:int}", UpdateProduct);
        group.MapDelete("/{id:int}", DeleteProduct)
            .RequireAuthorization("AdminOnly");
    }

    private static async Task<IResult> GetAllProducts(
        IProductRepository repo,
        CancellationToken ct)
    {
        var products = await repo.GetAllAsync(ct);
        return Results.Ok(products);
    }

    private static async Task<IResult> GetProductById(
        int id,
        IProductRepository repo,
        CancellationToken ct)
    {
        var product = await repo.GetByIdAsync(id, ct);
        return product is not null
            ? Results.Ok(product)
            : Results.NotFound();
    }

    private static async Task<IResult> CreateProduct(
        CreateProductRequest request,
        IProductRepository repo,
        IValidator<CreateProductRequest> validator,
        CancellationToken ct)
    {
        var validation = await validator.ValidateAsync(request, ct);
        if (!validation.IsValid)
            return Results.ValidationProblem(validation.ToDictionary());

        var product = await repo.CreateAsync(request.ToProduct(), ct);
        return Results.Created($"/api/products/{product.Id}", product);
    }
}
```

การเรียก `app.MapProductEndpoints()` ใน Program.cs ลงทะเบียน product routes ทั้งหมดพร้อม shared authorization requirements และ OpenAPI metadata โครงสร้างนี้ขยายได้ดีสำหรับแอปพลิเคชันที่มีหลายร้อย endpoints

## Parameter Binding และ Validation

Minimal APIs รองรับ binding sources หลายแหล่ง: route parameters, query strings, headers, request bodies และ services จาก DI การทำความเข้าใจ binding precedence ช่วยป้องกันข้อผิดพลาดทั่วไปในการสัมภาษณ์

```csharp
// Program.cs - Parameter binding examples
app.MapGet("/search", (
    [FromQuery] string? query,           // Explicit query string
    [FromQuery] int page = 1,            // Default value
    [FromQuery] int pageSize = 20,       // Default value
    [FromHeader(Name = "X-Correlation-Id")] string? correlationId,
    ILogger<Program> logger) =>
{
    logger.LogInformation("Search request: {Query}, Page: {Page}, CorrelationId: {CorrelationId}",
        query, page, correlationId);

    return Results.Ok(new { query, page, pageSize, correlationId });
});

// Complex model binding with validation
app.MapPost("/orders", async (
    [FromBody] CreateOrderRequest request,
    [FromServices] IValidator<CreateOrderRequest> validator,
    [FromServices] IOrderService orderService,
    HttpContext context,
    CancellationToken ct) =>
{
    var validationResult = await validator.ValidateAsync(request, ct);

    if (!validationResult.IsValid)
    {
        return Results.ValidationProblem(
            validationResult.Errors
                .GroupBy(e => e.PropertyName)
                .ToDictionary(
                    g => g.Key,
                    g => g.Select(e => e.ErrorMessage).ToArray()));
    }

    var userId = context.User.FindFirstValue(ClaimTypes.NameIdentifier);
    var order = await orderService.CreateOrderAsync(request, userId!, ct);

    return Results.Created($"/orders/{order.Id}", order);
});
```

Attribute `[FromBody]` เป็นตัวเลือกสำหรับ complex types แต่ช่วยเพิ่มความสามารถในการอ่านโค้ด FluentValidation ผสานรวมอย่างเป็นธรรมชาติผ่าน dependency injection แยก logic การ validation ออกจาก endpoint handlers

> **ลำดับความสำคัญของ Binding Source**
>
> เมื่อไม่มี attribute ระบุไว้ Minimal APIs จะอนุมาน binding sources: route parameters ก่อน จากนั้น query strings สำหรับ simple types และ request body สำหรับ complex types Explicit attributes เช่น [FromQuery] หรือ [FromBody] จะแทนที่พฤติกรรมนี้

## การเพิ่มประสิทธิภาพด้วย Native AOT

.NET 8 เปิดตัวการรองรับ Native AOT (Ahead-of-Time) compilation สำหรับ Minimal APIs สร้าง executable แบบ self-contained พร้อมเวลาเริ่มต้นระดับต่ำกว่ามิลลิวินาที ความสามารถนี้ทำให้ Minimal APIs เหมาะอย่างยิ่งสำหรับ serverless deployments ที่ cold start latency มีความสำคัญ

```csharp
// Program.cs - AOT-compatible configuration
var builder = WebApplication.CreateSlimBuilder(args);

// AOT-friendly JSON serialization
builder.Services.ConfigureHttpJsonOptions(options =>
{
    options.SerializerOptions.TypeInfoResolverChain.Insert(0, AppJsonContext.Default);
});

var app = builder.Build();

app.MapGet("/health", () => Results.Ok(new HealthResponse("Healthy", DateTime.UtcNow)));

app.Run();

// Source-generated JSON serializer context
[JsonSerializable(typeof(HealthResponse))]
[JsonSerializable(typeof(Product))]
[JsonSerializable(typeof(List<Product>))]
internal partial class AppJsonContext : JsonSerializerContext { }

public record HealthResponse(string Status, DateTime CheckedAt);
```

Method `CreateSlimBuilder` ไม่รวมคุณสมบัติ framework ที่ไม่จำเป็น ในขณะที่ source-generated `JsonSerializerContext` กำจัด runtime reflection สำหรับ JSON serialization Published AOT binaries สำหรับ simple APIs มักมีขนาด 10-15 MB เมื่อเทียบกับ 80+ MB สำหรับ standard self-contained deployments

## Typed Results และ Response Metadata

.NET 7 เปิดตัว `TypedResults` สำหรับการตรวจสอบ compile-time ของ response types ปรับปรุงความถูกต้องของเอกสาร OpenAPI และตรวจจับ type mismatches ระหว่างการพัฒนา

```csharp
// Strongly-typed results with OpenAPI metadata
app.MapGet("/products/{id:int}", async Task<Results<Ok<Product>, NotFound, ProblemHttpResult>> (
    int id,
    IProductRepository repo,
    CancellationToken ct) =>
{
    try
    {
        var product = await repo.GetByIdAsync(id, ct);

        return product is not null
            ? TypedResults.Ok(product)
            : TypedResults.NotFound();
    }
    catch (Exception ex)
    {
        return TypedResults.Problem(
            detail: "An error occurred retrieving the product",
            statusCode: StatusCodes.Status500InternalServerError);
    }
})
.WithName("GetProductById")
.WithOpenApi(operation =>
{
    operation.Summary = "Retrieves a product by ID";
    operation.Description = "Returns the product details or 404 if not found";
    return operation;
});
```

Union type `Results<T1, T2, T3>` ประกาศ response types ที่เป็นไปได้ทั้งหมด ซึ่ง Swagger/OpenAPI generators ใช้เพื่อสร้างเอกสารที่ถูกต้อง Pattern นี้มีคุณค่าอย่างยิ่งเมื่อเตรียมตัวสำหรับคำถามสัมภาษณ์เกี่ยวกับ API design

## Endpoint Filters สำหรับ Cross-Cutting Concerns

Endpoint filters ให้ฟังก์ชันการทำงานคล้าย middleware ที่จำกัดขอบเขตไว้สำหรับ endpoints หรือ groups เฉพาะ จัดการ concerns เช่น logging, caching และ request transformation

```csharp
// ValidationFilter.cs
public class ValidationFilter<T> : IEndpointFilter where T : class
{
    public async ValueTask<object?> InvokeAsync(
        EndpointFilterInvocationContext context,
        EndpointFilterDelegate next)
    {
        var validator = context.HttpContext
            .RequestServices
            .GetService<IValidator<T>>();

        if (validator is null)
            return await next(context);

        var argument = context.Arguments
            .OfType<T>()
            .FirstOrDefault();

        if (argument is null)
            return await next(context);

        var validationResult = await validator.ValidateAsync(argument);

        if (!validationResult.IsValid)
        {
            return Results.ValidationProblem(
                validationResult.Errors
                    .GroupBy(e => e.PropertyName)
                    .ToDictionary(
                        g => g.Key,
                        g => g.Select(e => e.ErrorMessage).ToArray()));
        }

        return await next(context);
    }
}

// Usage in Program.cs
app.MapPost("/products", CreateProduct)
    .AddEndpointFilter<ValidationFilter<CreateProductRequest>>();

// Global filter registration via route group
var api = app.MapGroup("/api")
    .AddEndpointFilter(async (context, next) =>
    {
        var logger = context.HttpContext
            .RequestServices
            .GetRequiredService<ILogger<Program>>();

        var stopwatch = Stopwatch.StartNew();
        var result = await next(context);
        stopwatch.Stop();

        logger.LogInformation(
            "Endpoint {Method} {Path} completed in {ElapsedMs}ms",
            context.HttpContext.Request.Method,
            context.HttpContext.Request.Path,
            stopwatch.ElapsedMilliseconds);

        return result;
    });
```

Filters ถูกเรียกใช้ตามลำดับการลงทะเบียน โดย innermost filter อยู่ใกล้กับ endpoint handler มากที่สุด สถาปัตยกรรมนี้ช่วยให้แยก logic การ validation, logging และ authorization ได้อย่างชัดเจน

## รูปแบบ Authentication และ Authorization

Minimal APIs รองรับกลไก authentication และ authorization เหมือนกับ MVC controllers พร้อม syntax การกำหนดค่าที่ประกาศชัดเจนมากขึ้น

```csharp
// Program.cs - JWT authentication setup
builder.Services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
    .AddJwtBearer(options =>
    {
        options.TokenValidationParameters = new TokenValidationParameters
        {
            ValidateIssuer = true,
            ValidateAudience = true,
            ValidateLifetime = true,
            ValidateIssuerSigningKey = true,
            ValidIssuer = builder.Configuration["Jwt:Issuer"],
            ValidAudience = builder.Configuration["Jwt:Audience"],
            IssuerSigningKey = new SymmetricSecurityKey(
                Encoding.UTF8.GetBytes(builder.Configuration["Jwt:Key"]!))
        };
    });

builder.Services.AddAuthorizationBuilder()
    .AddPolicy("AdminOnly", policy =>
        policy.RequireRole("Admin"))
    .AddPolicy("PremiumUser", policy =>
        policy.RequireClaim("subscription", "premium", "enterprise"));

var app = builder.Build();

app.UseAuthentication();
app.UseAuthorization();

// Protected endpoints
app.MapGet("/admin/users", async (IUserService userService) =>
    Results.Ok(await userService.GetAllUsersAsync()))
    .RequireAuthorization("AdminOnly");

app.MapGet("/profile", async (ClaimsPrincipal user, IUserService userService) =>
{
    var userId = user.FindFirstValue(ClaimTypes.NameIdentifier);
    var profile = await userService.GetProfileAsync(userId!);
    return Results.Ok(profile);
})
.RequireAuthorization();

// Anonymous endpoint within protected group
var protectedGroup = app.MapGroup("/api/secure")
    .RequireAuthorization();

protectedGroup.MapGet("/public-info", () => Results.Ok("This is public"))
    .AllowAnonymous();
```

Extension method `RequireAuthorization` รับชื่อ policy หรือสามารถเรียกโดยไม่มี argument เพื่อต้องการ user ที่ authenticated แล้ว การเข้าใจ patterns เหล่านี้มีความสำคัญสำหรับคำถามสัมภาษณ์เกี่ยวกับ authentication และ authorization

## คำถามสัมภาษณ์: Patterns ที่พบบ่อย

การสัมภาษณ์ทางเทคนิคมักสำรวจความแตกต่างระหว่าง Minimal APIs และ traditional controllers ตารางด้านล่างสรุปความแตกต่างหลัก:

| ด้าน | Minimal APIs | MVC Controllers |
|------|--------------|----------------|
| Boilerplate | ต่ำ - handler delegates โดยตรง | สูงกว่า - class + method + attributes |
| Routing | Inline ด้วย `MapGet`, `MapPost` | Attribute หรือ convention-based |
| Model Binding | อัตโนมัติพร้อม optional attributes | Convention + attributes |
| Filters | Endpoint filters | Action filters + middleware |
| รองรับ AOT | เต็มรูปแบบตั้งแต่ .NET 8 | จำกัด, reflection-heavy |
| Testability | Function-based, unit test ง่าย | ต้องการ instantiation controller |
| เหมาะสำหรับ | Microservices, simple APIs | แอปพลิเคชันขนาดใหญ่, complex workflows |

> **เคล็ดลับสัมภาษณ์**
>
> เมื่อถูกถามว่า "เมื่อไหร่ควรเลือก controllers แทน Minimal APIs?" ให้กล่าวถึงแอปพลิเคชันที่ซับซ้อนที่ต้องการ action filters, การปรับแต่ง model binding หรือ codebases ที่มีอยู่พร้อม patterns MVC ที่กำหนดไว้แล้ว Minimal APIs เหมาะสมสำหรับ greenfield microservices และ serverless functions

## การทดสอบ Endpoints ของ Minimal API

Integration testing ด้วย `WebApplicationFactory` ให้การตรวจสอบ endpoint ที่สมจริงโดยไม่ต้อง deploy แอปพลิเคชัน

```csharp
// ProductEndpointsTests.cs
public class ProductEndpointsTests : IClassFixture<WebApplicationFactory<Program>>
{
    private readonly HttpClient _client;
    private readonly WebApplicationFactory<Program> _factory;

    public ProductEndpointsTests(WebApplicationFactory<Program> factory)
    {
        _factory = factory.WithWebHostBuilder(builder =>
        {
            builder.ConfigureServices(services =>
            {
                // Replace real repository with mock
                services.RemoveAll<IProductRepository>();
                services.AddScoped<IProductRepository, MockProductRepository>();
            });
        });
        _client = _factory.CreateClient();
    }

    [Fact]
    public async Task GetProducts_ReturnsOkWithProductList()
    {
        // Act
        var response = await _client.GetAsync("/api/products");

        // Assert
        response.StatusCode.Should().Be(HttpStatusCode.OK);

        var products = await response.Content
            .ReadFromJsonAsync<List<Product>>();

        products.Should().NotBeNull();
        products.Should().HaveCountGreaterThan(0);
    }

    [Fact]
    public async Task GetProductById_WithInvalidId_ReturnsNotFound()
    {
        // Act
        var response = await _client.GetAsync("/api/products/99999");

        // Assert
        response.StatusCode.Should().Be(HttpStatusCode.NotFound);
    }

    [Fact]
    public async Task CreateProduct_WithValidRequest_ReturnsCreated()
    {
        // Arrange
        var request = new CreateProductRequest("Test Product", 29.99m, "Test Description");

        // Act
        var response = await _client.PostAsJsonAsync("/api/products", request);

        // Assert
        response.StatusCode.Should().Be(HttpStatusCode.Created);
        response.Headers.Location.Should().NotBeNull();
    }
}
```

สำหรับการสำรวจเชิงลึกเกี่ยวกับ clean architecture patterns ในแอปพลิเคชัน .NET ควรทดสอบ service layer แยกต่างหากด้วย unit tests ในขณะที่ integration tests ตรวจสอบ request pipeline ทั้งหมด

## บทสรุป

Minimal APIs เป็นตัวแทนของวิธีการสมัยใหม่ในการสร้าง HTTP services ใน ASP.NET Core:

- Route groups และการจัดระเบียบ endpoint ขยายได้ตั้งแต่ microservices ง่ายๆ ไปจนถึงแอปพลิเคชันที่ซับซ้อน
- Endpoint filters ให้การแยก cross-cutting concerns เช่น validation และ logging อย่างชัดเจน
- TypedResults ช่วยให้ตรวจสอบ compile-time response type และเอกสาร OpenAPI ที่ถูกต้อง
- Native AOT compilation มอบเวลาเริ่มต้นระดับต่ำกว่ามิลลิวินาทีสำหรับ serverless deployments
- Integration testing ด้วย WebApplicationFactory รับประกันการตรวจสอบ endpoint ที่สมจริง

สำหรับการเตรียมตัวสัมภาษณ์ ให้เน้นที่การอธิบายว่าเมื่อไหร่ Minimal APIs เหมาะสมเมื่อเทียบกับ traditional controllers และแสดงความเข้าใจเกี่ยวกับ request pipeline, dependency injection และ authentication patterns

---

Source: SharpSkill (https://sharpskill.dev), tech interview preparation for your real stack.
HTML version of this page: https://sharpskill.dev/th/blog/dotnet/aspnet-core-minimal-apis-architecture-performance-interview