DEV Community: Syed Mohamed

Rate Limiting in ASP.NET Core Web API

Syed Mohamed — Wed, 23 Sep 2026 03:45:06 +0000

Rate Limiting in ASP.NET Core Web API

What is rate limiting?

Rate limiting controls how many requests a client can send to an API during a specified period.

More Articles Visit: https://jntech.in/Articles

Example:

Allow a maximum of 5 requests every 10 seconds.

If the client sends more than five requests within ten seconds, the API rejects the additional requests with:

HTTP 429 Too Many Requests

Why do we need rate limiting?

Rate limiting helps to:

Protect the API from excessive traffic
Prevent API abuse
Reduce server and database load
Ensure fair usage among clients
Control costly operations
Improve application stability
Partially reduce denial-of-service attacks

Rate limiting helps with abusive traffic, but it is not complete DDoS protection. Production systems should also use services such as a WAF, CDN, Azure Front Door or Cloudflare.

Simple fixed-window example

This example allows:

5 requests every 10 seconds

Step 1: Configure rate limiting in `Program.cs`

using Microsoft.AspNetCore.RateLimiting;
using System.Threading.RateLimiting;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddControllers();

builder.Services.AddRateLimiter(options =>
{
    // Response status when the limit is exceeded
    options.RejectionStatusCode =
        StatusCodes.Status429TooManyRequests;

    // Create a named rate-limiting policy
    options.AddFixedWindowLimiter(
        policyName: "FixedPolicy",
        configureOptions: limiterOptions =>
        {
            // Maximum requests allowed in one window
            limiterOptions.PermitLimit = 5;

            // Duration of one window
            limiterOptions.Window =
                TimeSpan.FromSeconds(10);

            // Do not wait when the limit is exceeded
            limiterOptions.QueueLimit = 0;

            limiterOptions.QueueProcessingOrder =
                QueueProcessingOrder.OldestFirst;

            // Automatically start a new window
            limiterOptions.AutoReplenishment = true;
        });
});

var app = builder.Build();

app.UseHttpsRedirection();

app.UseRateLimiter();

app.MapControllers();

app.Run();

Step 2: Apply the policy to a controller

using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.RateLimiting;

namespace RateLimitDemo.Controllers;

[ApiController]
[Route("api/[controller]")]
[EnableRateLimiting("FixedPolicy")]
public class ProductsController : ControllerBase
{
    [HttpGet]
    public IActionResult GetProducts()
    {
        var products = new[]
        {
            "Laptop",
            "Mobile",
            "Keyboard"
        };

        return Ok(products);
    }
}

The rate-limiting policy now applies to every endpoint inside ProductsController.

How the example works

Call this endpoint repeatedly:

GET /api/products

Within the same 10-second window:

Request	Result
1	`200 OK`
2	`200 OK`
3	`200 OK`
4	`200 OK`
5	`200 OK`
6	`429 Too Many Requests`
7	`429 Too Many Requests`

After the 10-second window ends, the counter resets, and another five requests are allowed.

Code explanation

`AddRateLimiter()`

builder.Services.AddRateLimiter(options =>
{
    // Policies
});

Registers ASP.NET Core’s built-in rate-limiting services.

`AddFixedWindowLimiter()`

options.AddFixedWindowLimiter(
    policyName: "FixedPolicy",
    configureOptions: limiterOptions =>
    {
        // Settings
    });

Creates a named policy using the fixed-window algorithm.

The name "FixedPolicy" is later used to apply the policy to controllers or endpoints.

`PermitLimit`

limiterOptions.PermitLimit = 5;

Specifies the maximum number of requests allowed in one window.

Here, only five requests are permitted.

`Window`

limiterOptions.Window = TimeSpan.FromSeconds(10);

Defines the duration of one window.

Therefore:

5 requests / 10 seconds

`QueueLimit`

limiterOptions.QueueLimit = 0;

Specifies how many extra requests may wait in a queue.

Because it is 0, extra requests are rejected immediately with 429.

If it were:

limiterOptions.QueueLimit = 2;

two additional requests could wait for permits. Queueing can increase response time, so 0 is often simpler for APIs.

`QueueProcessingOrder`

limiterOptions.QueueProcessingOrder =
    QueueProcessingOrder.OldestFirst;

When queueing is enabled, the oldest waiting request is processed first.

This setting has no practical effect when QueueLimit is 0.

`AutoReplenishment`

limiterOptions.AutoReplenishment = true;

ASP.NET Core automatically renews the available request permits when a new window begins.

`UseRateLimiter()`

app.UseRateLimiter();

Adds the rate-limiting middleware to the HTTP request pipeline.

Registering AddRateLimiter() alone is insufficient. The middleware must also be enabled.

`EnableRateLimiting`

[EnableRateLimiting("FixedPolicy")]

Applies the named policy to a controller or action.

Apply rate limiting to only one action

Instead of placing the attribute on the controller, it can be placed on an individual action:

[ApiController]
[Route("api/[controller]")]
public class ProductsController : ControllerBase
{
    [HttpGet]
    [EnableRateLimiting("FixedPolicy")]
    public IActionResult GetProducts()
    {
        return Ok(new[] { "Laptop", "Mobile" });
    }

    [HttpGet("public")]
    public IActionResult GetPublicInformation()
    {
        return Ok("This endpoint is not rate limited.");
    }
}

Only GET /api/products is rate limited.

Apply rate limiting to all controllers

Remove [EnableRateLimiting] from the controller and change endpoint mapping:

app.MapControllers()
   .RequireRateLimiting("FixedPolicy");

Now the policy applies to all controller endpoints.

Customize the `429` response

A meaningful response helps API clients understand why their request failed.

builder.Services.AddRateLimiter(options =>
{
    options.RejectionStatusCode =
        StatusCodes.Status429TooManyRequests;

    options.OnRejected = async (context, cancellationToken) =>
    {
        context.HttpContext.Response.ContentType =
            "application/json";

        await context.HttpContext.Response.WriteAsJsonAsync(
            new
            {
                statusCode = 429,
                message = "Too many requests. Please try again later."
            },
            cancellationToken);
    };

    options.AddFixedWindowLimiter(
        policyName: "FixedPolicy",
        configureOptions: limiterOptions =>
        {
            limiterOptions.PermitLimit = 5;
            limiterOptions.Window =
                TimeSpan.FromSeconds(10);

            limiterOptions.QueueLimit = 0;
            limiterOptions.QueueProcessingOrder =
                QueueProcessingOrder.OldestFirst;
        });
});

Response after exceeding the limit:

{
  "statusCode": 429,
  "message": "Too many requests. Please try again later."
}

Disable rate limiting for an action

An endpoint can be excluded using [DisableRateLimiting]:

[HttpGet("health")]
[DisableRateLimiting]
public IActionResult Health()
{
    return Ok("API is healthy.");
}

This can be useful for selected health-check or internal endpoints, but exclusions should be chosen carefully.

Important limitation of the simple example

The named fixed-window policy shown above uses a shared limit for the protected endpoint. In most real applications, limits should be separated by:

User ID
Client IP address
API key
Subscription plan

Otherwise, one busy client could consume the request quota and affect other clients.

For example:

User A → 100 requests per minute
User B → Separate 100 requests per minute
User C → Separate 100 requests per minute

This is called partitioned rate limiting.

Rate-limiting algorithms

ASP.NET Core provides four main algorithms:

Algorithm	Purpose
Fixed window	Allows a fixed number of requests during fixed time blocks
Sliding window	Provides smoother control by dividing the window into segments
Token bucket	Permits controlled traffic bursts while tokens are available
Concurrency	Limits requests executing at the same time

For a basic Web API, fixed window is the easiest starting point.

Key points

Rate limiting controls incoming API traffic.
Rejected requests normally receive 429 Too Many Requests.
Register services using AddRateLimiter().
Enable middleware using UseRateLimiter().
Create a policy such as "FixedPolicy".
Apply it with [EnableRateLimiting] or RequireRateLimiting().
Use [DisableRateLimiting] for carefully selected exceptions.
Prefer per-user, per-IP or per-API-key limits in production.
Load-test the chosen limits before deploying.
Rate limiting supports security but does not replace proper DDoS protection.

More Articles Visit: https://jntech.in/Articles

𝗨𝗻𝗱𝗲𝗿𝘀𝘁𝗮𝗻𝗱𝗶𝗻𝗴 𝗔𝗻𝗴𝘂𝗹𝗮𝗿 𝗙𝘂𝗻𝗱𝗮𝗺𝗲𝗻𝘁𝗮𝗹𝘀

Syed Mohamed — Tue, 22 Sep 2026 03:55:33 +0000

𝗔𝗻𝗴𝘂𝗹𝗮𝗿 𝗧𝘂𝘁𝗼𝗿𝗶𝗮𝗹 𝗦𝗲𝗿𝗶𝗲𝘀 – 𝗗𝗮𝘆 𝟭 | 𝗨𝗻𝗱𝗲𝗿𝘀𝘁𝗮𝗻𝗱𝗶𝗻𝗴 𝗔𝗻𝗴𝘂𝗹𝗮𝗿 𝗙𝘂𝗻𝗱𝗮𝗺𝗲𝗻𝘁𝗮𝗹𝘀

I’m starting a 𝗱𝗮𝗶𝗹𝘆 𝗔𝗻𝗴𝘂𝗹𝗮𝗿 𝘁𝘂𝘁𝗼𝗿𝗶𝗮𝗹 𝘀𝗲𝗿𝗶𝗲𝘀 covering Angular concepts in a simple, practical, and interview-friendly way.

Every day, I’ll share a new topic along with a 𝗣𝗗𝗙 𝗰𝗼𝗻𝘁𝗮𝗶𝗻𝗶𝗻𝗴 𝗲𝘅𝗽𝗹𝗮𝗻𝗮𝘁𝗶𝗼𝗻𝘀, 𝗱𝗶𝗮𝗴𝗿𝗮𝗺𝘀, 𝗸𝗲𝘆 𝗽𝗼𝗶𝗻𝘁𝘀, 𝗮𝗻𝗱 𝗲𝘅𝗮𝗺𝗽𝗹𝗲𝘀 for quick reference.

𝗧𝗼𝗱𝗮𝘆’𝘀 𝘁𝗼𝗽𝗶𝗰: 𝗔𝗻𝗴𝘂𝗹𝗮𝗿 𝗙𝘂𝗻𝗱𝗮𝗺𝗲𝗻𝘁𝗮𝗹𝘀

𝟭. 𝗪𝗵𝗮𝘁 𝗶𝘀 𝗔𝗻𝗴𝘂𝗹𝗮𝗿?
Angular is a 𝗧𝘆𝗽𝗲𝗦𝗰𝗿𝗶𝗽𝘁-𝗯𝗮𝘀𝗲𝗱 𝘄𝗲𝗯 𝗳𝗿𝗮𝗺𝗲𝘄𝗼𝗿𝗸 for building modern, scalable, and maintainable web applications.
𝟮. 𝗖𝗼𝗺𝗽𝗼𝗻𝗲𝗻𝘁𝘀 𝗶𝗻 𝗔𝗻𝗴𝘂𝗹𝗮𝗿
Components are the 𝗯𝘂𝗶𝗹𝗱𝗶𝗻𝗴 𝗯𝗹𝗼𝗰𝗸𝘀 𝗼𝗳 𝗮𝗻 𝗔𝗻𝗴𝘂𝗹𝗮𝗿 𝗮𝗽𝗽𝗹𝗶𝗰𝗮𝘁𝗶𝗼𝗻. Each component manages a specific part of the UI and its behavior.
𝟯. 𝗦𝗶𝗻𝗴𝗹𝗲 𝗣𝗮𝗴𝗲 𝗔𝗽𝗽𝗹𝗶𝗰𝗮𝘁𝗶𝗼𝗻 (𝗦𝗣𝗔)
A SPA loads the application once and dynamically updates the required content without reloading the entire page during normal navigation.
𝟰. 𝗧𝗼𝗽 𝗙𝗲𝗮𝘁𝘂𝗿𝗲𝘀 𝗼𝗳 𝗔𝗻𝗴𝘂𝗹𝗮𝗿
Component-based architecture, Data Binding, Dependency Injection, Routing, Directives, Pipes, Forms, HttpClient, TypeScript support, and scalability.
𝟱. 𝗔𝗻𝗴𝘂𝗹𝗮𝗿 𝘃𝘀 𝗝𝗮𝘃𝗮𝗦𝗰𝗿𝗶𝗽𝘁 𝘃𝘀 𝗧𝘆𝗽𝗲𝗦𝗰𝗿𝗶𝗽𝘁
𝗝𝗮𝘃𝗮𝗦𝗰𝗿𝗶𝗽𝘁 → Programming language
𝗧𝘆𝗽𝗲𝗦𝗰𝗿𝗶𝗽𝘁 → JavaScript with static typing and additional development-time features
𝗔𝗻𝗴𝘂𝗹𝗮𝗿 → Web application framework primarily built around TypeScript
𝟲. 𝗔𝗢𝗧 𝘃𝘀 𝗝𝗜𝗧 𝗖𝗼𝗺𝗽𝗶𝗹𝗮𝘁𝗶𝗼𝗻
𝗔𝗢𝗧 (𝗔𝗵𝗲𝗮𝗱-𝗼𝗳-𝗧𝗶𝗺𝗲) → Compiles during the build process.
𝗝𝗜𝗧 (𝗝𝘂𝘀𝘁-𝗶𝗻-𝗧𝗶𝗺𝗲) → Compiles at runtime in the browser.
Modern Angular production builds use 𝗔𝗢𝗧 𝗯𝘆 𝗱𝗲𝗳𝗮𝘂𝗹𝘁.

𝗖𝗼𝗺𝗽𝗼𝗻𝗲𝗻𝘁𝘀 → 𝗗𝗮𝘁𝗮 𝗕𝗶𝗻𝗱𝗶𝗻𝗴 → 𝗗𝗶𝗿𝗲𝗰𝘁𝗶𝘃𝗲𝘀 → 𝗣𝗶𝗽𝗲𝘀 → 𝗦𝗲𝗿𝘃𝗶𝗰𝗲𝘀 & 𝗗𝗲𝗽𝗲𝗻𝗱𝗲𝗻𝗰𝘆 𝗜𝗻𝗷𝗲𝗰𝘁𝗶𝗼𝗻 → 𝗥𝗼𝘂𝘁𝗶𝗻𝗴 → 𝗙𝗼𝗿𝗺𝘀 → 𝗥𝘅𝗝𝗦 & 𝗢𝗯𝘀𝗲𝗿𝘃𝗮𝗯𝗹𝗲𝘀 → 𝗛𝘁𝘁𝗽𝗖𝗹𝗶𝗲𝗻𝘁 → 𝗦𝗶𝗴𝗻𝗮𝗹𝘀 → 𝗔𝘂𝘁𝗵𝗲𝗻𝘁𝗶𝗰𝗮𝘁𝗶𝗼𝗻 → 𝗚𝘂𝗮𝗿𝗱𝘀 → 𝗜𝗻𝘁𝗲𝗿𝗰𝗲𝗽𝘁𝗼𝗿𝘀 → 𝗦𝘁𝗮𝗻𝗱𝗮𝗹𝗼𝗻𝗲 𝗔𝗿𝗰𝗵𝗶𝘁𝗲𝗰𝘁𝘂𝗿𝗲 → 𝗣𝗲𝗿𝗳𝗼𝗿𝗺𝗮𝗻𝗰𝗲 𝗮𝗻𝗱 𝗺𝗼𝗿𝗲.

𝗜’𝘃𝗲 𝗮𝘁𝘁𝗮𝗰𝗵𝗲𝗱 𝘁𝗼𝗱𝗮𝘆’𝘀 𝗣𝗗𝗙 𝘄𝗶𝘁𝗵 𝗱𝗲𝘁𝗮𝗶𝗹𝗲𝗱 𝗻𝗼𝘁𝗲𝘀 𝗮𝗻𝗱 𝗱𝗶𝗮𝗴𝗿𝗮𝗺𝘀 𝗳𝗼𝗿 𝗿𝗲𝗳𝗲𝗿𝗲𝗻𝗰𝗲.

If you are also learning Angular or preparing for frontend/full-stack interviews, 𝗳𝗲𝗲𝗹 𝗳𝗿𝗲𝗲 𝘁𝗼 𝗳𝗼𝗹𝗹𝗼𝘄 𝘁𝗵𝗲 𝘀𝗲𝗿𝗶𝗲𝘀.

𝗧𝗵𝗿𝗼𝘂𝗴𝗵 𝘁𝗵𝗶𝘀 𝘀𝗲𝗿𝗶𝗲𝘀, I’ll focus not only on Angular syntax, but also on how Angular works, why each concept is required, where it is used in 𝗿𝗲𝗮𝗹-𝘄𝗼𝗿𝗹𝗱 𝗮𝗽𝗽𝗹𝗶𝗰𝗮𝘁𝗶𝗼𝗻𝘀, and the key points to know for interviews.

More Articles: www.jntech.in

hashtag#Angular hashtag#Angular20 hashtag#TypeScript hashtag#JavaScript hashtag#DotNet hashtag#FullStackDevelopment hashtag#FrontendDevelopment hashtag#WebDevelopment hashtag#SoftwareEngineering hashtag#InterviewPreparation hashtag#LearningJourney

𝗔𝗦𝗣.𝗡𝗘𝗧 𝗪𝗲𝗯 𝗔𝗣𝗜 𝗦𝗲𝗿𝗶𝗲𝘀 | 𝗚𝗹𝗼𝗯𝗮𝗹 𝗘𝘅𝗰𝗲𝗽𝘁𝗶𝗼𝗻 𝗛𝗮𝗻𝗱𝗹𝗶𝗻𝗴 𝗶𝗻 𝗔𝗦𝗣.𝗡𝗘𝗧 𝗖𝗼𝗿𝗲 𝗪𝗲𝗯 𝗔𝗣𝗜

Syed Mohamed — Wed, 16 Sep 2026 14:47:24 +0000

𝗣𝗮𝗿𝘁 𝟰 | 𝗔𝗦𝗣.𝗡𝗘𝗧 𝗪𝗲𝗯 𝗔𝗣𝗜 𝗦𝗲𝗿𝗶𝗲𝘀 | 𝗚𝗹𝗼𝗯𝗮𝗹 𝗘𝘅𝗰𝗲𝗽𝘁𝗶𝗼𝗻 𝗛𝗮𝗻𝗱𝗹𝗶𝗻𝗴 𝗶𝗻 𝗔𝗦𝗣.𝗡𝗘𝗧 𝗖𝗼𝗿𝗲 𝗪𝗲𝗯 𝗔𝗣𝗜
🚨 One unhandled exception can expose sensitive information and create an inconsistent experience for API consumers.

That is why every production-ready ASP.NET Core Web API needs Global Exception Handling.

Instead of adding 𝗿𝗲𝗽𝗲𝘁𝗶𝘁𝗶𝘃𝗲 try-catch 𝗯𝗹𝗼𝗰𝗸𝘀 inside every controller action, we can handle exceptions in one centralized place.

𝗜𝗻 .𝗡𝗘𝗧 𝟴+, 𝘁𝗵𝗲 𝗿𝗲𝗰𝗼𝗺𝗺𝗲𝗻𝗱𝗲𝗱 𝗮𝗽𝗽𝗿𝗼𝗮𝗰𝗵 𝗶𝘀:
✅ Implement IExceptionHandler
✅ Register it using AddExceptionHandler()
✅ Enable it using UseExceptionHandler()
✅ Return consistent ProblemDetails responses
✅ Log the complete exception internally

𝗛𝗼𝘄 𝗱𝗼𝗲𝘀 𝗶𝘁 𝘄𝗼𝗿𝗸?
1️⃣ The client sends an API request.
2️⃣ The request passes through the exception-handling middleware.
3️⃣ The controller calls the service and repository.
4️⃣ If an unhandled exception occurs, it travels back through the pipeline.
5️⃣ The global handler catches and logs it.
6️⃣ The exception is mapped to the correct HTTP status code.
7️⃣ A safe and consistent error response is returned.

𝗖𝗼𝗺𝗺𝗼𝗻 𝗲𝘅𝗰𝗲𝗽𝘁𝗶𝗼𝗻 𝗺𝗮𝗽𝗽𝗶𝗻𝗴:
🔹 𝗜𝗻𝘃𝗮𝗹𝗶𝗱 𝗶𝗻𝗽𝘂𝘁 → 400 Bad Request
🔹 𝗔𝘂𝘁𝗵𝗲𝗻𝘁𝗶𝗰𝗮𝘁𝗶𝗼𝗻 𝗿𝗲𝗾𝘂𝗶𝗿𝗲𝗱 → 401 Unauthorized
🔹 𝗣𝗲𝗿𝗺𝗶𝘀𝘀𝗶𝗼𝗻 𝗱𝗲𝗻𝗶𝗲𝗱 → 403 Forbidden
🔹 𝗥𝗲𝘀𝗼𝘂𝗿𝗰𝗲 𝗻𝗼𝘁 𝗳𝗼𝘂𝗻𝗱 → 404 Not Found
🔹 𝗗𝘂𝗽𝗹𝗶𝗰𝗮𝘁𝗲 𝗼𝗿 𝗰𝗼𝗻𝗰𝘂𝗿𝗿𝗲𝗻𝗰𝘆 𝗰𝗼𝗻𝗳𝗹𝗶𝗰𝘁 → 409 Conflict
🔹 𝗕𝘂𝘀𝗶𝗻𝗲𝘀𝘀 𝘃𝗮𝗹𝗶𝗱𝗮𝘁𝗶𝗼𝗻 𝗳𝗮𝗶𝗹𝘂𝗿𝗲 → 422 Unprocessable Entity
🔹 𝗘𝘅𝘁𝗲𝗿𝗻𝗮𝗹 𝘀𝗲𝗿𝘃𝗶𝗰𝗲 𝘁𝗶𝗺𝗲𝗼𝘂𝘁 → 504 Gateway Timeout
🔹 𝗨𝗻𝗲𝘅𝗽𝗲𝗰𝘁𝗲𝗱 𝗲𝘅𝗰𝗲𝗽𝘁𝗶𝗼𝗻 → 500 Internal Server Error

A standard error response can include:
{
"title": "Resource not found",
"status": 404,
"detail": "Product with ID 100 was not found.",
"instance": "/api/products/100",
"traceId": "0HN7K2B8N98R2:00000001"
}
𝗧𝗵𝗲 traceId 𝗶𝘀 𝗲𝘀𝗽𝗲𝗰𝗶𝗮𝗹𝗹𝘆 𝘃𝗮𝗹𝘂𝗮𝗯𝗹𝗲 𝗶𝗻 𝗽𝗿𝗼𝗱𝘂𝗰𝘁𝗶𝗼𝗻. When a user reports an issue, the support team can use it to locate the related logs quickly.

𝗞𝗲𝘆 𝗽𝗼𝗶𝗻𝘁𝘀:
✅ Keep controllers clean and focused.
✅ Log complete exception details on the server.
✅ Return only safe messages to clients.
✅ Never expose stack traces, SQL queries or connection strings.
✅ Use custom exceptions for known business errors.
✅ Do not return 500 for every exception.
✅ Register the exception middleware early in the pipeline.
✅ Remember: normal validation errors and unknown-route 404 responses are not necessarily exceptions.

♻️ 𝗥𝗲𝗽𝗼𝘀𝘁 𝗶𝗳 𝘁𝗵𝗶𝘀 𝗵𝗲𝗹𝗽𝘀 𝗮𝗻𝗼𝘁𝗵𝗲𝗿 .𝗡𝗘𝗧 𝗱𝗲𝘃𝗲𝗹𝗼𝗽𝗲𝗿.

𝗖𝗵𝗲𝗰𝗸 𝗼𝘂𝘁 𝘁𝗵𝗲 𝗹𝗶𝗻𝗸 𝗯𝗲𝗹𝗼𝘄 𝗳𝗼𝗿 𝗮 𝗱𝗲𝘁𝗮𝗶𝗹𝗲𝗱 𝗲𝘅𝗽𝗹𝗮𝗻𝗮𝘁𝗶𝗼𝗻 𝘄𝗶𝘁𝗵 𝗽𝗿𝗮𝗰𝘁𝗶𝗰𝗮𝗹 𝗲𝘅𝗮𝗺𝗽𝗹𝗲𝘀.👇
https://jntech.in/view/global-exception-handling-in-aspnet-core-web-api

𝗔𝗻𝗴𝘂𝗹𝗮𝗿 𝗧𝘂𝘁𝗼𝗿𝗶𝗮𝗹 𝗦𝗲𝗿𝗶𝗲𝘀 – 𝗗𝗮𝘆 𝟭 | 𝗨𝗻𝗱𝗲𝗿𝘀𝘁𝗮𝗻𝗱𝗶𝗻𝗴 𝗔𝗻𝗴𝘂𝗹𝗮𝗿 𝗙𝘂𝗻𝗱𝗮𝗺𝗲𝗻𝘁𝗮𝗹𝘀

Syed Mohamed — Sun, 06 Sep 2026 07:12:20 +0000

𝗧𝗼𝗱𝗮𝘆’𝘀 𝘁𝗼𝗽𝗶𝗰: 𝗔𝗻𝗴𝘂𝗹𝗮𝗿 𝗙𝘂𝗻𝗱𝗮𝗺𝗲𝗻𝘁𝗮𝗹𝘀

If you are also learning Angular or preparing for frontend/full-stack interviews, 𝗳𝗲𝗲𝗹 𝗳𝗿𝗲𝗲 𝘁𝗼 𝗳𝗼𝗹𝗹𝗼𝘄 𝘁𝗵𝗲 𝘀𝗲𝗿𝗶𝗲𝘀.

What is an Azure DevOps Agent?

Syed Mohamed — Sun, 12 Apr 2026 09:54:58 +0000

𝗔𝘇𝘂𝗿𝗲 𝗗𝗲𝘃𝗢𝗽𝘀 𝗔𝗴𝗲𝗻𝘁 𝗮𝗻𝗱 𝗜𝘁𝘀 𝗧𝘆𝗽𝗲𝘀
Ever wondered what actually runs your 𝗽𝗶𝗽𝗲𝗹𝗶𝗻𝗲𝘀 𝗶𝗻 𝗔𝘇𝘂𝗿𝗲 𝗗𝗲𝘃𝗢𝗽𝘀?

That’s where 𝗔𝘇𝘂𝗿𝗲 𝗗𝗲𝘃𝗢𝗽𝘀 𝗔𝗴𝗲𝗻𝘁𝘀 come in.

Think of an agent as the worker behind the scenes — the one that picks up your pipeline job, executes the steps, installs dependencies, builds your code, runs tests, and pushes deployments.

Now, not all agents are the same. There are 𝗺𝗮𝗶𝗻𝗹𝘆 𝘁𝘄𝗼 𝘁𝘆𝗽𝗲𝘀:
🔹 𝗠𝗶𝗰𝗿𝗼𝘀𝗼𝗳𝘁-𝗵𝗼𝘀𝘁𝗲𝗱 𝗮𝗴𝗲𝗻𝘁𝘀
These are managed by Microsoft. You don’t need to set up anything — just select an image and run your pipeline. Perfect when you want simplicity and quick setup.

🔹 𝗦𝗲𝗹𝗳-𝗵𝗼𝘀𝘁𝗲𝗱 𝗮𝗴𝗲𝗻𝘁𝘀
These run on your own machines (VMs, servers, or even your local system). You have full control over configurations, installed tools, and network access. Ideal for custom requirements or secure environments.

𝗖𝗵𝗼𝗼𝘀𝗶𝗻𝗴 𝗯𝗲𝘁𝘄𝗲𝗲𝗻 𝘁𝗵𝗲𝗺 𝗱𝗲𝗽𝗲𝗻𝗱𝘀 𝗼𝗻 𝘆𝗼𝘂𝗿 𝗻𝗲𝗲𝗱:
• 𝗪𝗮𝗻𝘁 𝘇𝗲𝗿𝗼 𝗺𝗮𝗶𝗻𝘁𝗲𝗻𝗮𝗻𝗰𝗲? 𝗚𝗼 𝘄𝗶𝘁𝗵 𝗠𝗶𝗰𝗿𝗼𝘀𝗼𝗳𝘁-𝗵𝗼𝘀𝘁𝗲𝗱
• 𝗡𝗲𝗲𝗱 𝗰𝗼𝗻𝘁𝗿𝗼𝗹 𝗼𝗿 𝗮𝗰𝗰𝗲𝘀𝘀 𝘁𝗼 𝗽𝗿𝗶𝘃𝗮𝘁𝗲 𝗿𝗲𝘀𝗼𝘂𝗿𝗰𝗲𝘀? 𝗦𝗲𝗹𝗳-𝗵𝗼𝘀𝘁𝗲𝗱 𝗶𝘀 𝘁𝗵𝗲 𝘄𝗮𝘆

At the end of the day, no agent = no pipeline execution.

If you're learning Azure DevOps, understanding agents is a game changer

𝗧𝗵𝗲 𝗰𝗼𝗺𝗽𝗹𝗲𝘁𝗲 𝗮𝗿𝘁𝗶𝗰𝗹𝗲 𝗶𝘀 𝗮𝘃𝗮𝗶𝗹𝗮𝗯𝗹𝗲 𝗶𝗻 𝗺𝘆 𝗣𝗼𝗿𝘁𝗳𝗼𝗹𝗶𝗼 𝘂𝗻𝗱𝗲𝗿 𝘁𝗵𝗲 𝗔𝗿𝘁𝗶𝗰𝗹𝗲𝘀 𝘀𝗲𝗰𝘁𝗶𝗼𝗻:https://www.youtube.com/watch?v=2fPgEK_anlo

Upload & Download Files in Azure Blob Storage using C# (Full Tutorial) | Syed Cloud Tech

Syed Mohamed — Sat, 04 Apr 2026 02:45:00 +0000

𝗨𝗽𝗹𝗼𝗮𝗱 & 𝗗𝗼𝘄𝗻𝗹𝗼𝗮𝗱 𝗙𝗶𝗹𝗲𝘀 𝗶𝗻 𝗔𝘇𝘂𝗿𝗲 𝗕𝗹𝗼𝗯 𝗦𝘁𝗼𝗿𝗮𝗴𝗲 𝘂𝘀𝗶𝗻𝗴 𝗖#
Working with files in the cloud is something every developer eventually needs to master—and 𝗔𝘇𝘂𝗿𝗲 𝗕𝗹𝗼𝗯 𝗦𝘁𝗼𝗿𝗮𝗴𝗲 makes it incredibly powerful and scalable.

Recently, I explored how to 𝘂𝗽𝗹𝗼𝗮𝗱 𝗮𝗻𝗱 𝗱𝗼𝘄𝗻𝗹𝗼𝗮𝗱 𝗳𝗶𝗹𝗲𝘀 𝘂𝘀𝗶𝗻𝗴 𝗖# 𝘄𝗶𝘁𝗵 𝗔𝘇𝘂𝗿𝗲 𝗕𝗹𝗼𝗯 𝗦𝘁𝗼𝗿𝗮𝗴𝗲, and it’s surprisingly straightforward once you understand the flow.

You basically:
• 𝗖𝗼𝗻𝗻𝗲𝗰𝘁 𝘂𝘀𝗶𝗻𝗴 𝘁𝗵𝗲 𝘀𝘁𝗼𝗿𝗮𝗴𝗲 𝗮𝗰𝗰𝗼𝘂𝗻𝘁 𝗰𝗼𝗻𝗻𝗲𝗰𝘁𝗶𝗼𝗻 𝘀𝘁𝗿𝗶𝗻𝗴
• 𝗪𝗼𝗿𝗸 𝘄𝗶𝘁𝗵 𝗰𝗼𝗻𝘁𝗮𝗶𝗻𝗲𝗿𝘀 𝗮𝗻𝗱 𝗯𝗹𝗼𝗯𝘀
• 𝗨𝘀𝗲 𝘁𝗵𝗲 𝗔𝘇𝘂𝗿𝗲 𝗦𝗗𝗞 𝘁𝗼 𝘂𝗽𝗹𝗼𝗮𝗱 𝗮𝗻𝗱 𝗱𝗼𝘄𝗻𝗹𝗼𝗮𝗱 𝗳𝗶𝗹𝗲𝘀 𝘀𝗲𝗮𝗺𝗹𝗲𝘀𝘀𝗹𝘆

What I found interesting is how clean the .NET SDK is—you can handle large files, manage storage efficiently, and integrate it easily into real-world applications.

If you're a .𝗡𝗘𝗧 𝗱𝗲𝘃𝗲𝗹𝗼𝗽𝗲𝗿 or getting started with 𝗔𝘇𝘂𝗿𝗲, this is definitely a must-learn skill. It’s widely used in real-time applications like document storage, media handling, backups, and more.

I’ve put together a full tutorial where I walk through everything step by step with practical examples.

🎥 You can check out the complete video on my YouTube channel 𝗦𝘆𝗲𝗱 𝗖𝗹𝗼𝘂𝗱 𝗧𝗲𝗰𝗵 for a detailed explanation.

𝗘𝘅𝗽𝗹𝗼𝗿𝗲 𝘁𝗵𝗲 𝗙𝘂𝗹𝗹 𝗩𝗶𝗱𝗲𝗼:https://youtu.be/0HWaJsHf8v0

Azure #AzureBlobStorage #CSharp #DotNet #CloudComputing #AzureStorage #Programming #Developers #TechLearning #SoftwareDevelopment #MicrosoftAzure

Azure Key Vault Explained | Secure Secrets, Keys & Certificates

Syed Mohamed — Fri, 03 Apr 2026 07:13:01 +0000

When working with applications in Azure, one of the biggest challenges is managing sensitive data like API keys, connection strings, certificates, and passwords. Storing them directly in code or config files? Risky.

That’s where Azure Key Vault comes in.

It provides a centralized and secure way to store and control access to:

Secrets (passwords, connection strings)
Keys (encryption keys)
Certificates (SSL/TLS)

What I really like about Key Vault:
✔ Tight integration with Azure services
✔ Role-based access control (RBAC)
✔ Managed Identity support (no hardcoding credentials!)
✔ Audit logs for better security tracking

Instead of worrying about "where to store secrets", you can focus on building your application while Azure takes care of securing them.

If you're building cloud applications, learning Key Vault is a must-have skill — not just for developers, but also for DevOps engineers.

👉 I’ve explained Azure Key Vault in a simple way in my latest video on my YouTube channel Syed Cloud Tech. Feel free to check it out here.
https://www.youtube.com/watch?v=FV8ZyfUpMjM

Azure #CloudSecurity #AzureKeyVault #DevOps #CloudComputing #MicrosoftAzure #Security #Developers #Learning #Tech

File Access Modifier in C# with Examples (C# 11 Guide)

Syed Mohamed — Thu, 26 Mar 2026 08:43:43 +0000

More .NET related Articles: https://jntech.in/Articles

File Access Modifier in C# – Why It Exists and When to Use It
The Problem
In real projects, we often create helper classes that are only needed inside one file.

If we use internal, those classes become accessible across the entire project. This can lead to:

Accidental usage
Poor code organization
Tight coupling between files
So the question is:
How do we restrict a class to just one file?

The Solution
C# introduced the file access modifier.
It allows you to define a class that is:

Accessible only within the same file
Completely hidden from other files
This gives better control over your code and improves encapsulation.

file class DataFormatter
{
    public string Format(string data)
    {
        return data.Trim();
    }
}

public class DataService
{
    public void Execute()
    {
        var formatter = new DataFormatter();
        Console.WriteLine(formatter.Format("  sample  "));
    }
}

Note: The file access modifier restricts a class so that it is accessible only within the same source file. Multiple classes inside the same file can use it, but it cannot be accessed from another file, even within the same project. It is mainly used for helper classes and provides better encapsulation than internal.

Can we use file inside another class?

No. We cannot use file for nested classes

public class Outer
{
    file class Inner  // Not allowed
    {
    }
}

Key Points about file Access Modifier in C#

General Rules
file restricts a type to only the same source file
Introduced in C# 11
Works only with top-level types
Cannot be used inside another class (no nested file types)
Supported Types
You can use file with:

file class
file struct
file interface
file record
Example:

file struct MyStruct { }
file interface IHelper { }

Inheritance Rules
A file class can inherit from another class (if accessible)
file class Base { }

file class Derived : Base // Allowed (same file)
{
}
Cannot inherit a file class from another file. Because it is not visible

Interface Implementation
file classes can implement interfaces

file interface IHelper
{
    void DoWork();
}

file class Helper : IHelper
{
    public void DoWork() { }
}

Works only within the same file

Real Usage Scenarios
Helper classes used only in one file
Utility logic tightly coupled to a feature
Avoiding accidental usage across project

Limitations
Cannot be used for:
Nested classes
Members (methods, properties, fields)
Only applies to types, not methods or variables

Best Practice
Use file when:
The class is not reusable
Logic should stay in one file
You want strong encapsulation

Conclusion
The file access modifier is a simple but powerful feature in C# that helps you control how your code is used. By restricting a class, struct, or interface to a single file, it ensures that internal logic stays exactly where it belongs.

It is especially useful when you are working with helper classes or feature-specific logic that should not be exposed to the rest of the project. Compared to internal, it provides a stricter level of encapsulation, which helps avoid accidental usage and keeps your codebase clean.

From a design perspective, using file encourages better organization and makes your intent clear to other developers. When someone reads your code, they immediately understand that certain types are meant to be used only within that file.

In short, the file modifier is a great tool for writing more maintainable, readable, and well-structured applications.

More .NET related Articles: https://jntech.in/Articles

What’s New in C# 14: Exploring the Latest Features in .NET 10

Syed Mohamed — Wed, 11 Mar 2026 05:25:08 +0000

🔗 𝗙𝘂𝗹𝗹 𝗮𝗿𝘁𝗶𝗰𝗹𝗲 𝗿𝗲𝗹𝗮𝘁𝗲𝗱 𝘁𝗼 𝘁𝗵𝗶𝘀 𝗽𝗼𝘀𝘁: https://jntech.in/view/whats-new-in-csharp-14-exploring-the-latest-features-in-net-10

C# continues to evolve with every .NET release, and 𝗖# 𝟭𝟰 (𝘄𝗶𝘁𝗵 .𝗡𝗘𝗧 𝟭𝟬) introduces several improvements that make the language cleaner, more flexible, and easier for developers to work with.

Here are some of the 𝗻𝗲𝘄 𝗳𝗲𝗮𝘁𝘂𝗿𝗲𝘀 𝗶𝗻𝘁𝗿𝗼𝗱𝘂𝗰𝗲𝗱 𝗶𝗻 𝗖# 𝟭𝟰:
• 𝗘𝘅𝘁𝗲𝗻𝘀𝗶𝗼𝗻 𝗠𝗲𝗺𝗯𝗲𝗿𝘀 (𝗘𝘅𝘁𝗲𝗻𝘀𝗶𝗼𝗻 𝗕𝗹𝗼𝗰𝗸𝘀) — Allows grouping multiple extension methods and properties together for a specific type, improving code organization.

• 𝗘𝘅𝘁𝗲𝗻𝘀𝗶𝗼𝗻 𝗣𝗿𝗼𝗽𝗲𝗿𝘁𝗶𝗲𝘀 — Enables adding property-like members to existing types without modifying the original class.

• 𝗦𝘁𝗮𝘁𝗶𝗰 𝗘𝘅𝘁𝗲𝗻𝘀𝗶𝗼𝗻 𝗠𝗲𝗺𝗯𝗲𝗿𝘀 — Allows developers to extend static functionality of existing types using extensions.

• 𝗣𝗿𝗶𝘃𝗮𝘁𝗲 𝗙𝗶𝗲𝗹𝗱𝘀 𝗶𝗻𝘀𝗶𝗱𝗲 𝗘𝘅𝘁𝗲𝗻𝘀𝗶𝗼𝗻 𝗕𝗹𝗼𝗰𝗸𝘀 — Extension blocks can now contain private fields used internally by extension members.

• 𝗙𝗶𝗲𝗹𝗱-𝗯𝗮𝗰𝗸𝗲𝗱 𝗣𝗿𝗼𝗽𝗲𝗿𝘁𝗶𝗲𝘀 (field 𝗸𝗲𝘆𝘄𝗼𝗿𝗱) — Provides direct access to the compiler-generated backing field in auto-properties.

• 𝗡𝘂𝗹𝗹-𝗰𝗼𝗻𝗱𝗶𝘁𝗶𝗼𝗻𝗮𝗹 𝗔𝘀𝘀𝗶𝗴𝗻𝗺𝗲𝗻𝘁 (?.= 𝗮𝗻𝗱 ?[]=) — Allows assignments to occur only when the object is not null, reducing repetitive null checks.

• nameof 𝗦𝘂𝗽𝗽𝗼𝗿𝘁 𝗳𝗼𝗿 𝗨𝗻𝗯𝗼𝘂𝗻𝗱 𝗚𝗲𝗻𝗲𝗿𝗶𝗰 𝗧𝘆𝗽𝗲𝘀 — Enables using nameof with generic types without specifying type parameters.

• 𝗜𝗺𝗽𝗹𝗶𝗰𝗶𝘁 𝗖𝗼𝗻𝘃𝗲𝗿𝘀𝗶𝗼𝗻𝘀 𝗳𝗼𝗿 Span 𝗮𝗻𝗱 ReadOnlySpan — Simplifies working with spans by allowing more automatic conversions.

• 𝗣𝗮𝗿𝗮𝗺𝗲𝘁𝗲𝗿 𝗠𝗼𝗱𝗶𝗳𝗶𝗲𝗿𝘀 𝗶𝗻 𝗟𝗮𝗺𝗯𝗱𝗮 𝗘𝘅𝗽𝗿𝗲𝘀𝘀𝗶𝗼𝗻𝘀 — Lambdas now support modifiers like ref, in, and out.

• 𝗨𝘀𝗲𝗿-𝗱𝗲𝗳𝗶𝗻𝗲𝗱 𝗖𝗼𝗺𝗽𝗼𝘂𝗻𝗱 𝗔𝘀𝘀𝗶𝗴𝗻𝗺𝗲𝗻𝘁 𝗢𝗽𝗲𝗿𝗮𝘁𝗼𝗿𝘀 — Custom types can now define operators such as +=, -=, etc.

• 𝗣𝗮𝗿𝘁𝗶𝗮𝗹 𝗖𝗼𝗻𝘀𝘁𝗿𝘂𝗰𝘁𝗼𝗿𝘀 𝗮𝗻𝗱 𝗣𝗮𝗿𝘁𝗶𝗮𝗹 𝗘𝘃𝗲𝗻𝘁𝘀 — Extends partial member support to constructors and events.

🔗 𝗙𝘂𝗹𝗹 𝗮𝗿𝘁𝗶𝗰𝗹𝗲 𝗿𝗲𝗹𝗮𝘁𝗲𝗱 𝘁𝗼 𝘁𝗵𝗶𝘀 𝗽𝗼𝘀𝘁: https://jntech.in/articles/view/whats-new-in-csharp-14-exploring-the-latest-features-in-net-10

📚 𝗠𝗼𝗿𝗲 .𝗡𝗘𝗧, 𝗖#, 𝗦𝗤𝗟 𝗔𝗿𝘁𝗶𝗰𝗹𝗲𝘀: https://jntech.in/Articles

DEV Community: Syed Mohamed

Rate Limiting in ASP.NET Core Web API

Rate Limiting in ASP.NET Core Web API

What is rate limiting?

Why do we need rate limiting?

Simple fixed-window example

Step 1: Configure rate limiting in Program.cs

Step 2: Apply the policy to a controller

How the example works

Code explanation

AddRateLimiter()

AddFixedWindowLimiter()

PermitLimit

Window

QueueLimit

QueueProcessingOrder

AutoReplenishment

UseRateLimiter()

EnableRateLimiting

Apply rate limiting to only one action

Apply rate limiting to all controllers

Customize the 429 response

Disable rate limiting for an action

Important limitation of the simple example

Rate-limiting algorithms

Key points

𝗨𝗻𝗱𝗲𝗿𝘀𝘁𝗮𝗻𝗱𝗶𝗻𝗴 𝗔𝗻𝗴𝘂𝗹𝗮𝗿 𝗙𝘂𝗻𝗱𝗮𝗺𝗲𝗻𝘁𝗮𝗹𝘀

𝗔𝗦𝗣.𝗡𝗘𝗧 𝗪𝗲𝗯 𝗔𝗣𝗜 𝗦𝗲𝗿𝗶𝗲𝘀 | 𝗚𝗹𝗼𝗯𝗮𝗹 𝗘𝘅𝗰𝗲𝗽𝘁𝗶𝗼𝗻 𝗛𝗮𝗻𝗱𝗹𝗶𝗻𝗴 𝗶𝗻 𝗔𝗦𝗣.𝗡𝗘𝗧 𝗖𝗼𝗿𝗲 𝗪𝗲𝗯 𝗔𝗣𝗜

𝗔𝗻𝗴𝘂𝗹𝗮𝗿 𝗧𝘂𝘁𝗼𝗿𝗶𝗮𝗹 𝗦𝗲𝗿𝗶𝗲𝘀 – 𝗗𝗮𝘆 𝟭 | 𝗨𝗻𝗱𝗲𝗿𝘀𝘁𝗮𝗻𝗱𝗶𝗻𝗴 𝗔𝗻𝗴𝘂𝗹𝗮𝗿 𝗙𝘂𝗻𝗱𝗮𝗺𝗲𝗻𝘁𝗮𝗹𝘀

What is an Azure DevOps Agent?

Upload & Download Files in Azure Blob Storage using C# (Full Tutorial) | Syed Cloud Tech

Azure #AzureBlobStorage #CSharp #DotNet #CloudComputing #AzureStorage #Programming #Developers #TechLearning #SoftwareDevelopment #MicrosoftAzure

Azure Key Vault Explained | Secure Secrets, Keys & Certificates

Azure #CloudSecurity #AzureKeyVault #DevOps #CloudComputing #MicrosoftAzure #Security #Developers #Learning #Tech

File Access Modifier in C# with Examples (C# 11 Guide)

What’s New in C# 14: Exploring the Latest Features in .NET 10

Step 1: Configure rate limiting in `Program.cs`

`AddRateLimiter()`

`AddFixedWindowLimiter()`

`PermitLimit`

`Window`

`QueueLimit`

`QueueProcessingOrder`

`AutoReplenishment`

`UseRateLimiter()`

`EnableRateLimiting`

Customize the `429` response