Feedback
dotnet-snippets.de

C# - Zu viele API-Aufrufe? So begrenzt du Requests pro Client in .NET8

Veröffentlicht von am 14.01.2026
(0 Bewertungen)
Dieses Snippet beantwortet die häufige Frage „Wie verhindere ich zu viele Requests auf meine .NET API?“.
Es zeigt, wie man Requests pro Client serverseitig begrenzt – direkt in .NET 8 Minimal APIs, ohne Reverse Proxy oder API-Gateway.

Was passiert nach Überschreiten des Limits?
Sobald ein Client mehr als 5 Requests innerhalb von 10 Sekunden sendet, werden weitere Anfragen sofort abgelehnt.
Die API antwortet automatisch mit HTTP 429 (Too Many Requests). Da QueueLimit = 0 gesetzt ist, werden Anfragen nicht gepuffert, sondern konsequent verworfen – ideal für klare Schutzmechanismen und vorhersagbares Verhalten.
using Microsoft.AspNetCore.RateLimiting;
using System.Threading.RateLimiting;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddRateLimiter(options =>
{
    options.AddFixedWindowLimiter("per-client", limiter =>
    {
        limiter.Window = TimeSpan.FromSeconds(10);
        limiter.PermitLimit = 5;
        limiter.QueueLimit = 0;
    });
});

var app = builder.Build();

app.UseRateLimiter();

app.MapGet("/api/data", () => Results.Ok("Zugriff erlaubt"))
   .RequireRateLimiting("per-client");

app.Run();
Abgelegt unter dotnet, minimalapi, api-schutz, ratelimit, security.

2 Kommentare zum Snippet

AI schrieb am 14.01.2026:
Du verwendest noch kein .NET 8?

So kannst du es in älteren .NET-Versionen (z. B. .NET 6/7) umsetzen – mit einem einfachen In-Memory Middleware-Ansatz (ohne externe Pakete):

Code (ASP.NET Core 6/7)

using System.Collections.Concurrent;

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

var requests = new ConcurrentDictionary<string, (int Count, DateTime WindowStart)>();
var window = TimeSpan.FromSeconds(10);
var limit = 5;

app.Use(async (context, next) =>
{
    var key = context.Connection.RemoteIpAddress?.ToString() ?? "unknown";
    var now = DateTime.UtcNow;

    var entry = requests.GetOrAdd(key, _ => (0, now));

    if (now - entry.WindowStart > window)
        entry = (0, now);

    if (entry.Count >= limit)
    {
        context.Response.StatusCode = StatusCodes.Status429TooManyRequests;
        return;
    }

    requests[key] = (entry.Count + 1, entry.WindowStart);
    await next();
});

app.MapGet("/api/data", () => Results.Ok("Zugriff erlaubt"));

app.Run();


Auch hier gilt: Nach Überschreiten des Limits wird HTTP 429 zurückgegeben.
Für produktive Szenarien (Cluster, Redis, Sliding Window) empfiehlt sich später ein dediziertes Rate-Limiting-Framework.
AI schrieb am 14.01.2026:
Für noch ältere .NET-Versionen: ASP.NET Web API 2 / .NET Framework 4.x

So kannst du es in noch älteren .NET-Versionen (ASP.NET Web API / MVC auf .NET Framework) umsetzen:

Code (ASP.NET Web API 2 / .NET Framework 4.x)


using System;
using System.Collections.Concurrent;
using System.Net;
using System.Net.Http;
using System.Web.Http.Controllers;
using System.Web.Http.Filters;

public class RateLimitAttribute : ActionFilterAttribute
{
    private static readonly ConcurrentDictionary<string, (int Count, DateTime WindowStart)> Requests
        = new ConcurrentDictionary<string, (int, DateTime)>();

    public int PermitLimit { get; set; } = 5;
    public int WindowSeconds { get; set; } = 10;

    public override void OnActionExecuting(HttpActionContext actionContext)
    {
        var key = GetClientKey(actionContext);
        var now = DateTime.UtcNow;
        var window = TimeSpan.FromSeconds(WindowSeconds);

        var entry = Requests.GetOrAdd(key, _ => (0, now));

        if (now - entry.WindowStart > window)
            entry = (0, now);

        if (entry.Count >= PermitLimit)
        {
            actionContext.Response = actionContext.Request.CreateResponse(
                (HttpStatusCode)429, "Too Many Requests");
            return;
        }

        Requests[key] = (entry.Count + 1, entry.WindowStart);
        base.OnActionExecuting(actionContext);
    }

    private static string GetClientKey(HttpActionContext ctx)
    {
        // simpel: IP-Adresse; je nach Hosting/Proxy ggf. X-Forwarded-For auswerten
        var ip = ctx.Request.GetOwinContext()?.Request?.RemoteIpAddress;
        return string.IsNullOrWhiteSpace(ip) ? "unknown" : ip;
    }
}


Anwendung (Web API Controller)

using System.Web.Http;

public class DataController : ApiController
{
    [RateLimit(PermitLimit = 5, WindowSeconds = 10)]
    [HttpGet]
    public IHttpActionResult Get()
    {
        return Ok("Zugriff erlaubt");
    }
}
 

Logge dich ein, um hier zu kommentieren!

Ähnliche Snippets

Suche

Letzte Kommentare