Top 25 ASP.NET Core Interview-Fragen: Middleware, DI und Minimal APIs

Die Vorbereitung auf ein ASP.NET Core Interview erfordert fundierte Kenntnisse der Kernkonzepte des Frameworks. Middleware, Dependency Injection und Minimal APIs bilden das Fundament moderner .NET-Webanwendungen und gehören zu den häufigsten Themengebieten in technischen Vorstellungsgesprächen. Dieser Leitfaden behandelt die 25 wichtigsten Fragen, die Entwickler beherrschen sollten.

Middleware in ASP.NET Core

Die Middleware-Pipeline ist das Herzstück jeder ASP.NET Core Anwendung. Jede HTTP-Anfrage durchläuft diese Pipeline, wobei jede Middleware-Komponente die Anfrage verarbeiten, modifizieren oder an die nächste Komponente weiterleiten kann.

1. Was ist Middleware und wie funktioniert die Request-Pipeline?

Middleware sind Softwarekomponenten, die in einer Anwendungspipeline angeordnet werden, um Anfragen und Antworten zu verarbeiten. Jede Komponente entscheidet, ob sie die Anfrage an die nächste Komponente weiterleitet oder die Pipeline kurzschließt.

Die Pipeline funktioniert bidirektional: Anfragen fließen von außen nach innen, Antworten von innen nach außen. Diese Architektur ermöglicht es, Logik sowohl vor als auch nach der Verarbeitung durch nachfolgende Middleware auszuführen.

2. Warum ist die Reihenfolge der Middleware-Registrierung entscheidend?

Die Registrierungsreihenfolge bestimmt die Ausführungsreihenfolge. Eine falsche Anordnung führt zu unerwartetem Verhalten oder Sicherheitslücken. Beispielsweise muss die Authentifizierung vor der Autorisierung erfolgen.

var app = builder.Build();

app.UseExceptionHandler("/error");   // 1. Outermost: catches all exceptions
app.UseHsts();                        // 2. HTTP Strict Transport Security
app.UseHttpsRedirection();            // 3. Redirect HTTP to HTTPS
app.UseStaticFiles();                 // 4. Serve static files (short-circuits if found)
app.UseRouting();                     // 5. Match request to endpoint
app.UseAuthentication();              // 6. Identify the user
app.UseAuthorization();               // 7. Check permissions
app.MapControllers();                 // 8. Execute the matched endpoint

app.Run();

3. Was bedeutet "Short-Circuiting" in der Middleware-Pipeline?

Short-Circuiting tritt auf, wenn eine Middleware die Pipeline vorzeitig beendet, ohne die nächste Komponente aufzurufen. UseStaticFiles demonstriert dieses Verhalten: Wenn eine statische Datei gefunden wird, wird die Antwort direkt zurückgegeben, ohne weitere Middleware zu durchlaufen.

4. Wie wird eine benutzerdefinierte Middleware implementiert?

Eine benutzerdefinierte Middleware benötigt einen Konstruktor mit RequestDelegate und eine InvokeAsync-Methode. Das folgende Beispiel misst die Bearbeitungszeit jeder Anfrage:

public class RequestTimingMiddleware
{
    private readonly RequestDelegate _next;
    private readonly ILogger<RequestTimingMiddleware> _logger;

    public RequestTimingMiddleware(RequestDelegate next, ILogger<RequestTimingMiddleware> logger)
    {
        _next = next;
        _logger = logger;
    }

    public async Task InvokeAsync(HttpContext context)
    {
        var stopwatch = Stopwatch.StartNew();
        
        await _next(context);  // Call the next middleware
        
        stopwatch.Stop();
        _logger.LogInformation(
            "Request {Method} {Path} completed in {Elapsed}ms",
            context.Request.Method,
            context.Request.Path,
            stopwatch.ElapsedMilliseconds);
    }
}

// Registration in Program.cs
app.UseMiddleware<RequestTimingMiddleware>();

5. Was ist der Unterschied zwischen Use, Map und Run?

Use fügt Middleware hinzu, die die Pipeline fortsetzen kann. Run fügt terminale Middleware hinzu, die die Pipeline immer beendet. Map verzweigt die Pipeline basierend auf dem Anfragepfad und erstellt eine separate Pipeline für bestimmte Routen.

6. Wie werden Exceptions global in der Pipeline behandelt?

UseExceptionHandler fängt alle unbehandelten Ausnahmen ab und leitet zu einer Fehlerseite weiter. Die Platzierung am Anfang der Pipeline ist entscheidend, damit alle nachfolgenden Ausnahmen erfasst werden. Für API-Anwendungen kann UseExceptionHandler mit einem Lambda konfiguriert werden, das JSON-Fehlerantworten zurückgibt.

7. Wie lässt sich benutzerdefinierte Middleware testen?

Unit-Tests für Middleware erfordern das Mocken von HttpContext und RequestDelegate. Der folgende Test überprüft, ob die Timing-Middleware korrekt loggt:

[Fact]
public async Task Middleware_LogsElapsedTime()
{
    var logger = new FakeLogger<RequestTimingMiddleware>();
    var middleware = new RequestTimingMiddleware(
        next: (ctx) => Task.CompletedTask,  // Terminal delegate
        logger: logger);

    var context = new DefaultHttpContext();
    context.Request.Method = "GET";
    context.Request.Path = "/api/products";

    await middleware.InvokeAsync(context);

    Assert.Single(logger.LogEntries);
    Assert.Contains("completed in", logger.LogEntries[0].Message);
}

Dependency Injection in ASP.NET Core

Dependency Injection ist ein integraler Bestandteil von ASP.NET Core und ermöglicht lose Kopplung, bessere Testbarkeit und saubere Architektur. Der eingebaute DI-Container unterstützt Constructor Injection als primäres Pattern.

8. Welche Service-Lifetimes existieren und wann wird welche verwendet?

ASP.NET Core bietet drei Lifetimes: Transient erstellt bei jeder Anforderung eine neue Instanz und eignet sich für leichtgewichtige, zustandslose Services. Scoped erstellt eine Instanz pro HTTP-Request und ist ideal für Datenbankkontext oder Request-spezifische Services. Singleton existiert für die gesamte Anwendungslebensdauer und passt für Caching-Services oder Konfigurationsobjekte.

9. Was ist das Captive Dependency Problem?

Captive Dependencies entstehen, wenn ein Service mit längerer Lebensdauer einen Service mit kürzerer Lebensdauer injiziert bekommt. Ein Singleton, der einen Scoped Service hält, führt dazu, dass der Scoped Service ebenfalls zur Singleton-Lebensdauer gezwungen wird.

builder.Services.AddScoped<IUserRepository, UserRepository>();
builder.Services.AddSingleton<ICacheService, CacheService>(); // CacheService takes IUserRepository

// This throws at startup in Development when ValidateScopes is enabled:
builder.Host.UseDefaultServiceProvider(options =>
{
    options.ValidateScopes = true;    // Catches captive dependencies
    options.ValidateOnBuild = true;   // Validates all registrations at startup
});

10. Wie funktionieren Keyed Services in .NET 8?

Keyed Services ermöglichen die Registrierung mehrerer Implementierungen desselben Interface unter verschiedenen Schlüsseln. Dies ist besonders nützlich, wenn verschiedene Implementierungen in unterschiedlichen Kontexten benötigt werden:

builder.Services.AddKeyedSingleton<INotificationService, EmailNotification>("email");
builder.Services.AddKeyedSingleton<INotificationService, SmsNotification>("sms");
builder.Services.AddKeyedSingleton<INotificationService, PushNotification>("push");

// Resolving in a controller or service
public class OrderService
{
    public OrderService(
        [FromKeyedServices("email")] INotificationService emailService,
        [FromKeyedServices("sms")] INotificationService smsService)
    {
        // Each parameter gets its specific implementation
    }
}

11. Was ist der Unterschied zwischen AddScoped und AddTransient für Datenbankkontext?

Für DbContext ist Scoped die empfohlene Lifetime, da Entity Framework Core Change Tracking und Unit of Work Pattern auf Request-Ebene implementiert. Transient würde bei jeder Injektion einen neuen Kontext erstellen, was zu inkonsistentem Tracking und Performance-Problemen führt.

12. Wie wird das Decorator Pattern mit DI implementiert?

Das Decorator Pattern erweitert Funktionalität, ohne die ursprüngliche Klasse zu modifizieren. In ASP.NET Core wird dies durch manuelle Registrierung erreicht:

// Decorating IProductService with caching
builder.Services.AddScoped<ProductService>();
builder.Services.AddScoped<IProductService>(sp =>
{
    var inner = sp.GetRequiredService<ProductService>();
    var cache = sp.GetRequiredService<IMemoryCache>();
    return new CachedProductService(inner, cache);
});

13. Wann sollte IServiceScopeFactory verwendet werden?

IServiceScopeFactory wird benötigt, wenn Scoped Services in Singleton-Kontexten aufgelöst werden müssen, beispielsweise in Background Services. Es ermöglicht das Erstellen eines neuen Scopes, innerhalb dessen Scoped Services korrekt funktionieren.

14. Was bewirkt ValidateOnBuild?

ValidateOnBuild überprüft beim Anwendungsstart, ob alle registrierten Services aufgelöst werden können. Fehlende Abhängigkeiten werden sofort erkannt, anstatt erst zur Laufzeit Fehler zu verursachen. Diese Option sollte in Development aktiviert sein.

Minimal APIs in ASP.NET Core

Minimal APIs bieten eine schlanke Alternative zu Controller-basierten APIs. Sie reduzieren Boilerplate-Code und ermöglichen schnelle Entwicklung von HTTP-Endpunkten mit vollem Zugriff auf alle ASP.NET Core Features.

15. Was sind Minimal APIs und wann sind sie geeignet?

Minimal APIs sind ein vereinfachtes Modell für die Erstellung von HTTP-Endpunkten ohne Controller-Klassen. Sie eignen sich für Microservices, einfache APIs und Prototypen. Für komplexe Anwendungen mit umfangreicher Geschäftslogik bieten Controller weiterhin bessere Strukturierungsmöglichkeiten.

16. Wie werden Endpunkte mit MapGroup organisiert?

MapGroup ermöglicht die Gruppierung von Endpunkten unter einem gemeinsamen Präfix mit geteilten Filtern und Metadaten:

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

        group.MapGet("/", GetAll);
        group.MapGet("/{id:int}", GetById);
        group.MapPost("/", Create);
    }

    private static async Task<IResult> GetAll(
        IProductService productService,    // Auto-resolved from DI
        CancellationToken cancellationToken)
    {
        var products = await productService.GetAllAsync(cancellationToken);
        return TypedResults.Ok(products);
    }

    private static async Task<IResult> GetById(
        int id,
        IProductService productService)
    {
        var product = await productService.GetByIdAsync(id);
        return product is null
            ? TypedResults.NotFound()
            : TypedResults.Ok(product);
    }

    private static async Task<IResult> Create(
        CreateProductRequest request,
        IProductService productService)
    {
        var product = await productService.CreateAsync(request);
        return TypedResults.Created($"/api/products/{product.Id}", product);
    }
}

// Program.cs — Clean registration
app.MapProductEndpoints();

17. Was ist der Unterschied zwischen Results und TypedResults?

Results gibt IResult zurück und ist flexibler, aber bietet keine Compile-Time-Informationen über den Rückgabetyp. TypedResults gibt spezifische Typen zurück und ermöglicht bessere OpenAPI-Dokumentation und IDE-Unterstützung.

18. Wie funktioniert Parameter Binding in Minimal APIs?

Minimal APIs unterstützen automatisches Binding aus Route, Query String, Header und Body. Komplexe Typen werden standardmäßig aus dem Body gebunden, primitive Typen aus Route oder Query. Attribute wie [FromQuery], [FromRoute] oder [FromBody] ermöglichen explizite Kontrolle.

19. Wie werden Filter in Minimal APIs implementiert?

Endpoint Filter sind das Minimal API Äquivalent zu Action Filters. Sie werden mit AddEndpointFilter hinzugefügt und können Requests vor und nach der Handler-Ausführung verarbeiten. Filter eignen sich für Validierung, Logging und Cross-Cutting Concerns.

20. Wie wird Validierung in Minimal APIs durchgeführt?

Validierung erfolgt typischerweise durch Endpoint Filter oder manuelle Überprüfung im Handler. FluentValidation oder Data Annotations können verwendet werden. Ein Validierungs-Filter prüft eingehende Requests und gibt bei Fehlern automatisch BadRequest-Responses zurück.

Fortgeschrittene Konzepte

21. Wie interagieren Middleware und Minimal APIs?

Middleware wird vor den Minimal API Endpunkten ausgeführt. Der Aufruf von MapControllers oder MapGet registriert Terminal-Middleware, die die Pipeline für passende Requests beendet. Die gesamte registrierte Middleware durchläuft den Request, bevor der Endpunkt erreicht wird.

22. Was ist der Unterschied zwischen IOptions, IOptionsSnapshot und IOptionsMonitor?

IOptions<T> ist Singleton und lädt Konfiguration einmalig beim Start. IOptionsSnapshot<T> ist Scoped und lädt Konfiguration pro Request neu. IOptionsMonitor<T> ist Singleton, unterstützt aber Change Notifications und eignet sich für langlebige Services, die auf Konfigurationsänderungen reagieren müssen.

23. Wie wird Health Checking implementiert?

Health Checks werden mit AddHealthChecks registriert und mit MapHealthChecks als Endpunkt exponiert. Benutzerdefinierte Health Checks implementieren IHealthCheck und können Datenbankverbindungen, externe Services oder andere Abhängigkeiten überprüfen.

24. Was sind die Best Practices für API-Versionierung?

ASP.NET Core unterstützt URL-Segment-, Query-String- und Header-basierte Versionierung. URL-Segmente wie /api/v1/products sind am explizitesten. Das Asp.Versioning.Http Package bietet umfassende Unterstützung für alle Versionierungsstrategien.

25. Wie werden Background Services mit DI integriert?

Background Services erben von BackgroundService und werden als Hosted Services registriert. Da sie Singleton-Lifetime haben, muss IServiceScopeFactory verwendet werden, um Scoped Services wie DbContext korrekt aufzulösen.

Zusammenfassung

Die Beherrschung von ASP.NET Core für technische Interviews erfordert tiefgreifendes Verständnis der Kernkonzepte:

• Middleware-Pipeline: Reihenfolge ist entscheidend, Short-Circuiting verstehen, benutzerdefinierte Middleware implementieren können
• Dependency Injection: Lifetimes korrekt wählen, Captive Dependencies vermeiden, Keyed Services für komplexe Szenarien nutzen
• Minimal APIs: Moderne Alternative zu Controllern, TypedResults für bessere OpenAPI-Unterstützung, Filter für Cross-Cutting Concerns
• Testing: Middleware und Services isoliert testen, HttpContext mocken, Validierung verifizieren
• Konfiguration: Options Pattern verstehen, Health Checks implementieren, Background Services korrekt integrieren

Die praktische Anwendung dieser Konzepte unterscheidet erfolgreiche Kandidaten von theoretischen Wissenden. Regelmäßiges Coding und das Lösen realistischer Aufgaben sind der Schlüssel zum Interview-Erfolg.

Für intensive Vorbereitung auf ASP.NET Core Interviews bietet der SharpSkill .NET Interview-Simulator praktische Coding-Übungen zu Minimal APIs, Web API-Entwicklung und Clean Architecture.