C# ASP.NET Core में IApplicationBuilder.Use() और IApplicationBuilder.Run() में क्या अंतर है?

हम Startup क्लास के Configure मेथड में IApplicationBuilder इंस्टेंस का उपयोग करके मिडलवेयर कॉन्फिगर कर सकते हैं।

Run() मेथड

Run() IApplicationBuilder पर एक एक्सटेंशन मेथड है जो एप्लिकेशन के रिक्वेस्ट पाइपलाइन में एक टर्मिनल मिडलवेयर जोड़ता है। यह पाइपलाइन को समाप्त करता है - इसके बाद कोई मिडलवेयर एक्जीक्यूट नहीं होता।

सिग्नेचर

public static void Run(this IApplicationBuilder app, RequestDelegate handler)

RequestDelegate सिग्नेचर

public delegate Task RequestDelegate(HttpContext context);

Run() का उदाहरण

public class Startup
{
    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
    {
        app.Run(async (context) =>
        {
            await context.Response.WriteAsync("Hello World!");
        });
        
        // यह कोड कभी एक्जीक्यूट नहीं होगा क्योंकि Run() पाइपलाइन समाप्त करता है
        // app.Run(async (context) => { await context.Response.WriteAsync("Never runs"); });
    }
}

एकाधिक Run() कॉल करने की समस्या

public void Configure(IApplicationBuilder app)
{
    app.Run(async (context) =>
    {
        await context.Response.WriteAsync("1st Middleware");
    });
    
    // निम्नलिखित कभी एक्जीक्यूट नहीं होगा
    app.Run(async (context) =>
    {
        await context.Response.WriteAsync("2nd Middleware");
    });
}

Use() मेथड

Use() एक्सटेंशन मेथड एकाधिक मिडलवेयर कॉन्फिगर करने के लिए उपयोग किया जाता है। यह Run() के समान है लेकिन इसमें अगले मिडलवेयर को क्रम में इनवोक करने के लिए next पैरामीटर शामिल होता है।

Use() सिग्नेचर

public static IApplicationBuilder Use(this IApplicationBuilder app, 
    Func, Task> middleware)

Use() के साथ एकाधिक मिडलवेयर कॉन्फिगर करना

public void Configure(IApplicationBuilder app)
{
    // पहला मिडलवेयर
    app.Use(async (context, next) =>
    {
        await context.Response.WriteAsync("1st Middleware! ");
        await next(); // अगले मिडलवेयर को कॉल करें
    });
    
    // दूसरा मिडलवेयर (टर्मिनल)
    app.Run(async (context) =>
    {
        await context.Response.WriteAsync("2nd Middleware");
    });
}

Use() vs Run() - मुख्य अंतर

व्यावहारिक उदाहरण: कस्टम मिडलवेयर

public class RequestLoggingMiddleware
{
    private readonly RequestDelegate _next;
    private readonly ILogger _logger;

    public RequestLoggingMiddleware(RequestDelegate next, ILogger logger)
    {
        _next = next;
        _logger = logger;
    }

    public async Task InvokeAsync(HttpContext context)
    {
        _logger.LogInformation("Request: {Method} {Path}", context.Request.Method, context.Request.Path);
        
        // अगले मिडलवेयर को कॉल करें (Use पैटर्न)
        await _next(context);
        
        _logger.LogInformation("Response: {StatusCode}", context.Response.StatusCode);
    }
}

// Startup.cs में रजिस्ट्रेशन
public void Configure(IApplicationBuilder app)
{
    app.UseMiddleware(); // Use पैटर्न का उपयोग
    app.UseRouting();
    app.UseEndpoints(endpoints => endpoints.MapControllers());
}

Map() एक्सटेंशन - पाइपलाइन ब्रांचिंग

Map() का उपयोग पथ-आधारित पाइपलाइन ब्रांचिंग के लिए किया जाता है:

app.Map("/admin", adminApp =>
{
    adminApp.UseMiddleware();
    adminApp.Run(async context => await context.Response.WriteAsync("Admin Area"));
});

app.Map("/api", apiApp =>
{
    apiApp.UseMiddleware();
    apiApp.UseRouting();
    apiApp.UseEndpoints(e => e.MapControllers());
});

सारांश: पाइपलाइन में मिडलवेयर चेन करने के लिए Use() का उपयोग करें, अंतिम रिस्पॉन्स हैंडलर के लिए Run() का उपयोग करें।