परिचय

भाग 1 में, हमने एक मशीन की कुल संरचनाओं का पता लगाया. वेनप्टर निवेदन और प्रतिक्रिया. अब, हम गहरी सतह में कूद देंगे: सर्वर और मेजबानों के साथ गहराई में. यह है जहां सब कुछ शुरू होता है - जहां आपका अनुप्रयोग जीवन के लिए आता है और जहाँ कच्चा नेटवर्क निवेदन किया जाता है संरचना में बदल रहे हैं. HttpContext वस्तुओं जो आपके मध्य ऐंग्रैप के माध्यम से प्रवाहित करते हैं।

इस परत को समझना महत्वपूर्ण है क्योंकि यह नियंत्रण करता है कि कैसे आपका अनुप्रयोग शुरू होता है, और यह किस प्रकार मूल वेब सर्वर के साथ व्यवहार करता है. क्या आप उत्पादन करने के लिए तैनात कर रहे हैं, न्यूनतम रूप से प्रदर्शन, या HTTP प्रवाहित करने के लिए, मेजबानिंग परत जहां इन चिन्ताओं को सम्बोधित किया जाता है.

ध्यान दीजिए: यह एआई / एक तरीका है जो अपने परीक्षणों का हिस्सा है. मैं इस पत्रों, मेरी समझ के कागजों, प्रश्नों को खिलाने के लिए मुझे यह लेख तैयार करना पड़ा है. यह मज़ेदार है और मैं कहीं भी नहीं देखा है.

दो केले- लेम्पेन: होस्ट तथा सर्वर

एनईएस. कोरल अनुप्रयोग होस्टिंग की चिन्ताओं को अलग करता है तथा दो अलग परतों में सेवा करता है:

होस्ट - अनुप्रयोग जीवन, विन्यास, इंजेक्शन, और लॉगिंग का प्रबंधन करता है
सर्वर - HTTP संकेतों को हैंडल करता है, निवेदन के लिए सुनता है, और कनेक्शन का प्रबंधन करता है

यह अलग से अलग है: आप कंसोल में अदला बदली कर सकते हैं (Krow, HTTPssss. switations) अपने अनुप्रयोग कोड को बदलने के बिना या अलग मेजबानिंग वातावरण में अपना अनुप्रयोग चलाने के लिए. (कोई समायोजन, विंडोज़ सेवा, तंत्र) सर्वर को संशोधित किए बगैर.

होस्ट परत

वेब अनुप्रयोग और वेब अनुप्रयोग

वेन कोर 6 में और बाद में, होस्ट मॉडल को सरल कर दिया गया है WebApplication और WebApplicationBuilder. इसने वृद्ध जनों की जगह ले ली IHostBuilder और IWebHostBuilder एक अधिक धाराित एपीआई के साथ पैटर्न.

// Modern ASP.NET Core 8 application
var builder = WebApplication.CreateBuilder(args);

// Configure services during the build phase
builder.Services.AddControllers();
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();

// Build the application
var app = builder.Build();

// Configure middleware after building
if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI();
}

app.UseHttpsRedirection();
app.UseAuthorization();
app.MapControllers();

// Start the server and begin processing requests
app.Run();

वेब अनुप्रयोग के दौरान क्या हो रहा है. पूर्वनिर्धारित बनाएँ?

जब आप फोन करते हैं WebApplication.CreateBuilder(args), बहुत से आरंभ हो जाता है:

// Simplified view of what CreateBuilder does internally
public static WebApplicationBuilder CreateBuilder(string[] args)
{
    var builder = new WebApplicationBuilder();

    // 1. Configure the host defaults
    //    - Content root path (Directory.GetCurrentDirectory())
    //    - Load appsettings.json and appsettings.{Environment}.json
    //    - Load environment variables
    //    - Load command-line arguments
    //    - Setup default logging providers (Console, Debug, EventSource, EventLog on Windows)

    // 2. Configure Kestrel as the default web server
    builder.WebHost.UseKestrel();

    // 3. Setup dependency injection container
    //    - Creates the IServiceCollection
    //    - Registers core services

    // 4. Configure the environment
    //    - Sets ASPNETCORE_ENVIRONMENT (Development, Staging, Production)
    //    - Determines if running in development mode

    // 5. Setup configuration system
    //    - Creates the IConfiguration hierarchy
    //    - Combines all configuration sources

    return builder;
}

होस्ट को मनपसंद बनाया जा रहा है

आपके हाथ में है कि होस्ट को कैसे विन्यस्त किया गया है:

var builder = WebApplication.CreateBuilder(args);

// Configure Kestrel server options
builder.WebHost.ConfigureKestrel(serverOptions =>
{
    serverOptions.Limits.MaxConcurrentConnections = 100;
    serverOptions.Limits.MaxRequestBodySize = 10 * 1024 * 1024; // 10 MB
    serverOptions.Limits.MinRequestBodyDataRate = new MinDataRate(
        bytesPerSecond: 100,
        gracePeriod: TimeSpan.FromSeconds(10)
    );
});

// Add additional configuration sources
builder.Configuration.AddJsonFile("customsettings.json", optional: true);
builder.Configuration.AddEnvironmentVariables(prefix: "MYAPP_");

// Configure logging
builder.Logging.ClearProviders(); // Remove defaults
builder.Logging.AddConsole();
builder.Logging.AddDebug();
builder.Logging.SetMinimumLevel(LogLevel.Warning);

// Change the content root and web root
builder.Environment.ContentRootPath = "/custom/path";
builder.Environment.WebRootPath = "/custom/wwwroot";

var app = builder.Build();

सेवा कंटेनर

होस्ट आरंभ के दौरान इन्जेक्शन को बनाया गया है. सेवाएँ यहाँ आपके अनुप्रयोग में उपलब्ध हैं:

var builder = WebApplication.CreateBuilder(args);

// Singleton: One instance for the application lifetime
builder.Services.AddSingleton<IMyService, MyService>();

// Scoped: One instance per request
builder.Services.AddScoped<IRequestService, RequestService>();

// Transient: New instance every time it's requested
builder.Services.AddTransient<ITransientService, TransientService>();

// Configure options pattern
builder.Services.Configure<MyOptions>(
    builder.Configuration.GetSection("MyOptions")
);

// Access configuration directly during service registration
var connectionString = builder.Configuration.GetConnectionString("DefaultConnection");
builder.Services.AddDbContext<MyDbContext>(options =>
    options.UseSqlServer(connectionString)
);

var app = builder.Build();

वातावरण तथा कॉन्फ़िगरेशन

एनईएसई.NT एक जटिल कॉन्फ़िगरेशन तंत्र प्रदान करता है जो बहुत से स्रोतों को आगे बढ़ाता है:

var builder = WebApplication.CreateBuilder(args);

// Configuration is loaded in this order (later sources override earlier):
// 1. appsettings.json
// 2. appsettings.{Environment}.json
// 3. User secrets (in Development environment only)
// 4. Environment variables
// 5. Command-line arguments

// Access configuration
var mySetting = builder.Configuration["MySection:MySetting"];
var myValue = builder.Configuration.GetValue<int>("MySection:MyValue");

// Check environment
if (builder.Environment.IsDevelopment())
{
    // Development-specific configuration
    builder.Services.AddDatabaseDeveloperPageExceptionFilter();
}

if (builder.Environment.IsProduction())
{
    // Production-specific configuration
    builder.Configuration.AddAzureKeyVault(/* ... */);
}

var app = builder.Build();

सर्वर परत: estl

Kestrol है Abl. neck Cont Cons' क्रास-ब्ब्ब्बक वेब सर्वर. यह तेजी से, हल्का है और उत्पादन कार्य लोड करने में सक्षम सक्षम सक्षम है. को समझने की क्षमता आपको अपने अनुप्रयोग के प्रदर्शन और सुरक्षा को कम करने में मदद करती है.

केआईआरल- स्फीति

flowchart TD
  cc[Client Connection]
  ch["Connection Handler Layer<br/>• TLS/SSL Termination (if HTTPS)<br/>• Protocol Negotiation (HTTP/1.1, HTTP/2, HTTP/3)"]
  parser["HTTP Protocol Parser<br/>• Request Line Parsing (Method, Path, Protocol)<br/>• Header Parsing<br/>• Body Reading"]
  ctx["HttpContext Creation<br/>• Creates HttpContext object<br/>• Populates Request properties<br/>• Prepares Response object"]
  pipeline[Middleware Pipeline]

  cc --> ch --> parser --> ctx --> pipeline

केरल स्फीयर - गहरा Dard

बाइट्स कैसे बन जाते हैं यह समझने के लिए कि आपके बीच का कौन - सा संदर्भ इस्तेमाल कर सकता है, यह कोरल के आंतरिक प्रवाह और ज़िम्मेदारियों पर ज़ूम करने में मदद करता है ।

flowchart LR
  subgraph os[OS / Network Stack]
    net[(TCP/UDP Sockets)]
  end

  subgraph kestrel[Kestrel Server]
    accept["Connection Accept Loop<br/>(.NET Sockets)"]

    subgraph connmw[Per-Connection Middleware]
      tls["TLS Termination / ALPN<br/>(Selects HTTP/1.1 vs HTTP/2 vs HTTP/3)"]
      limits["Connection & Request Limits<br/>(timeouts, sizes, rate limits)"]
      logging[Connection Logging]
    end

    subgraph proto[Protocol Handlers]
      h1["HTTP/1.1 Handler<br/>(keep-alive, chunked, pipelining)"]
      h2["HTTP/2 Handler<br/>(multiplexing, HPACK)"]
      h3["HTTP/3 Handler<br/>(QUIC, QPACK)"]
    end

    subgraph io[High-Perf IO]
      pipes["System.IO.Pipelines<br/>(zero-copy buffers)"]
      parser2[HTTP Parser]
    end

    features["Feature Mapping<br/>(IFeatureCollection)"]
    ctxpool[HttpContext Pool]
    appinvoke[IHttpApplication.ProcessRequestAsync]
  end

  app[Your Middleware Pipeline]

  net --> accept --> connmw --> proto
  proto --> io --> features --> ctxpool --> appinvoke --> app

sequenceDiagram
  autonumber
  participant C as Client
  participant S as Socket
  participant K as Kestrel
  participant P as Protocol Handler
  participant A as App (Middleware)

  C->>S: Connect (TCP/QUIC)
  S->>K: New connection accepted
  K->>K: TLS handshake + ALPN
  K->>P: Select protocol (HTTP/1.1, 2, or 3)
  loop Read/Parse
    P->>P: Read using System.IO.Pipelines
    P->>P: Parse request line/headers/body
  end
  P->>K: Build features + rent HttpContext from pool
  K->>A: ProcessRequestAsync(HttpContext)
  A-->>K: Writes response via Pipes
  K-->>C: Flush/Send response frames
  Note over K,C: Backpressure applied when client is slow

देखने हेतु कुंजी:

टीएलएस तथा EPN चयन निर्णय लें कि कौन इस कनेक्शन के लिए प्रोटोकॉल हैंडलर चलाता है.
तंत्र. आई. आई.Pio के तहत सभी एनीमेशन और न्यूनतम ए.एस. तथा उच्च के माध्यम से लिखने के लिए लिखते हैं.
विशेषता फिल्टर (IFuuppliock) कम- स्तर- स्तर सर्वर क्षमता का समर्थन करता है बिना के के किचिलल क़िस्म के लिए यह पता लगाने के लिए.
[ फुटनो संदर्भ वस्तुओं को GCC दबाव कम करने के लिए बंद कर दिया जाता है; वे वापस आ रहे हैं और हर निवेदन को फिर से इस्तेमाल कर रहे हैं.
बैक अप पाइपों के माध्यम से लागू होता है जब क्लाएंट पर्याप्त तेजी से पढ़ नहीं सकता, सर्वर पर लिखने के लिए नहीं लिखेगा.
टाइम- आउटः तथा सीमाएँ (क्लेटेड, शीर्ष, निवेदन आकार, HTTP/2 स्ट्रीम सीमा) सर्वर को धीमालो तथा संसाधन कम करने से संरक्षित करता है.
थ्रेडिंग:

केवरल अंत बिन्दु कॉन्फ़िगर किया जा रहा है

आप कॉन्फ़िगर कर सकते हैं कि कौन - से अंत - बिन्दु कान सुनते हैं और कैसे:

var builder = WebApplication.CreateBuilder(args);

builder.WebHost.ConfigureKestrel(options =>
{
    // Listen on all network interfaces on port 5000 (HTTP)
    options.Listen(IPAddress.Any, 5000);

    // Listen on localhost port 5001 (HTTPS)
    options.Listen(IPAddress.Loopback, 5001, listenOptions =>
    {
        listenOptions.UseHttps("certificate.pfx", "password");
    });

    // Listen on specific IP with HTTP/2
    options.Listen(IPAddress.Parse("192.168.1.100"), 5002, listenOptions =>
    {
        listenOptions.Protocols = HttpProtocols.Http2;
    });

    // Unix domain socket (Linux/macOS)
    options.ListenUnixSocket("/tmp/myapp.sock");

    // Named pipe (Windows)
    options.ListenNamedPipe("mypipename");
});

var app = builder.Build();

वैकल्पिक रूप से, आप एग्रेसन के जरिए अंत- बिन्दु कॉन्फ़िगर कर सकते हैं:

{
  "Kestrel": {
    "Endpoints": {
      "Http": {
        "Url": "http://localhost:5000"
      },
      "Https": {
        "Url": "https://localhost:5001",
        "Certificate": {
          "Path": "certificate.pfx",
          "Password": "your-password"
        }
      }
    }
  }
}

var builder = WebApplication.CreateBuilder(args);

// Endpoints are automatically configured from appsettings.json
// when you don't explicitly call ConfigureKestrel

var app = builder.Build();

HTTPS कॉन्फ़िगरेशन

ग्रोन अनुप्रयोगों के लिए HTTP आवश्यक है. केआईआरल टीएलएस को कॉन्फ़िगर करने के लिए कई तरीके प्रदान करता है:

var builder = WebApplication.CreateBuilder(args);

builder.WebHost.ConfigureKestrel(options =>
{
    options.Listen(IPAddress.Any, 5001, listenOptions =>
    {
        // Option 1: Certificate from file
        listenOptions.UseHttps("certificate.pfx", "password");

        // Option 2: Certificate from store (Windows)
        listenOptions.UseHttps(storeCert =>
        {
            storeCert.Subject = "localhost";
            storeCert.Store = "My";
            storeCert.Location = StoreLocation.CurrentUser;
            storeCert.AllowInvalid = false; // Don't allow invalid certs
        });

        // Option 3: Development certificate
        listenOptions.UseHttps(); // Uses development certificate in Development environment

        // Option 4: Configure TLS details
        listenOptions.UseHttps(httpsOptions =>
        {
            httpsOptions.ServerCertificate = LoadCertificate();
            httpsOptions.ClientCertificateMode = ClientCertificateMode.RequireCertificate;
            httpsOptions.CheckCertificateRevocation = true;
            httpsOptions.SslProtocols = SslProtocols.Tls12 | SslProtocols.Tls13;

            // Client certificate validation
            httpsOptions.ClientCertificateValidation = (certificate, chain, errors) =>
            {
                // Custom validation logic
                return errors == SslPolicyErrors.None;
            };
        });
    });
});

var app = builder.Build();

केआईआरल सीमा तथा परफ़ॉर्मेंस ट्यूनिंग

केआईआरल रिसोर्स उपयोग को नियंत्रित करने के लिए बहुत सारे विकल्पों को प्रदान करता है:

var builder = WebApplication.CreateBuilder(args);

builder.WebHost.ConfigureKestrel(options =>
{
    // Connection limits
    options.Limits.MaxConcurrentConnections = 100;
    options.Limits.MaxConcurrentUpgradedConnections = 100;

    // Request limits
    options.Limits.MaxRequestBodySize = 10 * 1024 * 1024; // 10 MB
    options.Limits.MaxRequestHeaderCount = 100;
    options.Limits.MaxRequestHeadersTotalSize = 32 * 1024; // 32 KB
    options.Limits.MaxRequestLineSize = 8 * 1024; // 8 KB

    // Keep-alive timeout
    options.Limits.KeepAliveTimeout = TimeSpan.FromMinutes(2);

    // Request header read timeout
    options.Limits.RequestHeadersTimeout = TimeSpan.FromSeconds(30);

    // Minimum data rate for request body
    options.Limits.MinRequestBodyDataRate = new MinDataRate(
        bytesPerSecond: 240,
        gracePeriod: TimeSpan.FromSeconds(5)
    );

    // Minimum data rate for response body
    options.Limits.MinResponseDataRate = new MinDataRate(
        bytesPerSecond: 240,
        gracePeriod: TimeSpan.FromSeconds(5)
    );

    // HTTP/2 specific limits
    options.Limits.Http2.MaxStreamsPerConnection = 100;
    options.Limits.Http2.HeaderTableSize = 4096;
    options.Limits.Http2.MaxFrameSize = 16 * 1024; // 16 KB
    options.Limits.Http2.MaxRequestHeaderFieldSize = 8 * 1024; // 8 KB
    options.Limits.Http2.InitialConnectionWindowSize = 128 * 1024; // 128 KB
    options.Limits.Http2.InitialStreamWindowSize = 96 * 1024; // 96 KB
});

var app = builder.Build();

एचटीटीपी/2 तथा एचटीटीपी/3 समर्थन

केआईआरल आधुनिक एचटीटीपी प्रोटोकॉल समर्थित करता है:

var builder = WebApplication.CreateBuilder(args);

builder.WebHost.ConfigureKestrel(options =>
{
    // HTTP/1.1 only
    options.Listen(IPAddress.Any, 5000, listenOptions =>
    {
        listenOptions.Protocols = HttpProtocols.Http1;
    });

    // HTTP/1.1 and HTTP/2
    options.Listen(IPAddress.Any, 5001, listenOptions =>
    {
        listenOptions.Protocols = HttpProtocols.Http1AndHttp2;
        listenOptions.UseHttps();
    });

    // HTTP/2 only
    options.Listen(IPAddress.Any, 5002, listenOptions =>
    {
        listenOptions.Protocols = HttpProtocols.Http2;
        listenOptions.UseHttps();
    });

    // HTTP/3 (QUIC) - requires .NET 7+
    options.Listen(IPAddress.Any, 5003, listenOptions =>
    {
        listenOptions.Protocols = HttpProtocols.Http1AndHttp2AndHttp3;
        listenOptions.UseHttps();
    });
});

var app = builder.Build();

सर्वर विशेषताएँ

केआईआरल सर्वर क्षमताओं को प्रकट करता है IFeatureCollection पर उपलब्ध HttpContext:

app.Use(async (context, next) =>
{
    // Check if HTTP/2 is being used
    var http2Feature = context.Features.Get<IHttpRequestFeature>();
    if (http2Feature?.Protocol == "HTTP/2")
    {
        Console.WriteLine("Using HTTP/2");
    }

    // Access connection features
    var connectionFeature = context.Features.Get<IHttpConnectionFeature>();
    Console.WriteLine($"Remote IP: {connectionFeature?.RemoteIpAddress}");
    Console.WriteLine($"Local IP: {connectionFeature?.LocalIpAddress}");

    // TLS information
    var tlsFeature = context.Features.Get<ITlsConnectionFeature>();
    if (tlsFeature?.ClientCertificate != null)
    {
        Console.WriteLine($"Client cert: {tlsFeature.ClientCertificate.Subject}");
    }

    // Request body pipe for high-performance scenarios
    var bodyPipeFeature = context.Features.Get<IRequestBodyPipeFeature>();
    if (bodyPipeFeature != null)
    {
        var reader = bodyPipeFeature.Reader;
        // Use System.IO.Pipelines for zero-copy reads
    }

    await next(context);
});

अनुप्रयोग जीवन समय घटनाएँ

होस्ट जीवन - संबंधी घटनाओं को अनुप्रयोग के लिए क्रमांक प्रदान करता है:

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

// Get the application lifetime
var lifetime = app.Services.GetRequiredService<IHostApplicationLifetime>();

// Application started event
lifetime.ApplicationStarted.Register(() =>
{
    Console.WriteLine("Application has started");
    // Perform startup tasks (warm up caches, etc.)
});

// Application stopping event
lifetime.ApplicationStopping.Register(() =>
{
    Console.WriteLine("Application is stopping");
    // Begin graceful shutdown (stop accepting new requests)
});

// Application stopped event
lifetime.ApplicationStopped.Register(() =>
{
    Console.WriteLine("Application has stopped");
    // Cleanup resources
});

app.Run();

आप भी लागू कर सकते हैं IHostedService पृष्ठभूमि कार्य के लिए:

public class MyBackgroundService : IHostedService, IDisposable
{
    private Timer? _timer;
    private readonly ILogger<MyBackgroundService> _logger;

    public MyBackgroundService(ILogger<MyBackgroundService> logger)
    {
        _logger = logger;
    }

    public Task StartAsync(CancellationToken cancellationToken)
    {
        _logger.LogInformation("Background service is starting");

        _timer = new Timer(DoWork, null, TimeSpan.Zero, TimeSpan.FromMinutes(5));

        return Task.CompletedTask;
    }

    private void DoWork(object? state)
    {
        _logger.LogInformation("Background service is working");
        // Perform periodic work
    }

    public Task StopAsync(CancellationToken cancellationToken)
    {
        _logger.LogInformation("Background service is stopping");

        _timer?.Change(Timeout.Infinite, 0);

        return Task.CompletedTask;
    }

    public void Dispose()
    {
        _timer?.Dispose();
    }
}

// Register the service
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddHostedService<MyBackgroundService>();
var app = builder.Build();

बहुमुखी बन्दिंग

एनईएससी कोरस हैंडल स्वतः बंद कर देता है, लेकिन आप व्यवहार को अनुकूलित कर सकते हैं:

var builder = WebApplication.CreateBuilder(args);

// Configure shutdown timeout
builder.WebHost.ConfigureKestrel(options =>
{
    options.AddServerHeader = false; // Remove Server header for security
});

builder.Host.ConfigureHostOptions(options =>
{
    // How long to wait for the application to shut down gracefully
    options.ShutdownTimeout = TimeSpan.FromSeconds(30);
});

var app = builder.Build();

// During shutdown, Kestrel:
// 1. Stops accepting new connections
// 2. Waits for existing requests to complete (up to ShutdownTimeout)
// 3. Aborts remaining requests
// 4. Disposes services
// 5. Runs ApplicationStopped callbacks

app.Run();

उत्पादों के बारे में जानकारी

विपरीत प्रॉक्सी के पीछे चल रहा है

उत्पादन में, केवरल किसी उलटा प्रॉक्सी के पीछे विशेष रूप से रहता है (जाक्स, ft, IIS):

var builder = WebApplication.CreateBuilder(args);

// Configure forwarded headers for reverse proxy scenarios
builder.Services.Configure<ForwardedHeadersOptions>(options =>
{
    options.ForwardedHeaders = ForwardedHeaders.XForwardedFor | ForwardedHeaders.XForwardedProto;

    // If your proxy is on a known network
    options.KnownNetworks.Add(new IPNetwork(IPAddress.Parse("10.0.0.0"), 8));
    options.KnownProxies.Add(IPAddress.Parse("10.0.0.1"));

    // Required when running in containers/Kubernetes
    options.ForwardedHeaders = ForwardedHeaders.All;
    options.KnownNetworks.Clear();
    options.KnownProxies.Clear();
});

var app = builder.Build();

// Must be before other middleware
app.UseForwardedHeaders();

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

app.MapControllers();

app.Run();

विंडोज़ सेवा होस्टिंग

var builder = WebApplication.CreateBuilder(args);

// Enable Windows Service lifetime
builder.Host.UseWindowsService();

// Configure content root for Windows Service
builder.Host.UseContentRoot(AppContext.BaseDirectory);

var app = builder.Build();

app.Run();

लिनक्स सिस्टम सेवा मेजबानिंग

var builder = WebApplication.CreateBuilder(args);

// Enable systemd lifetime
builder.Host.UseSystemd();

var app = builder.Build();

app.Run();

विस्तृत: मनपसंद सर्वर

जब केस्टल मानक विकल्प है, तब आप आवश्यकता होने पर मनपसंद सर्वर को लागू कर सकते हैं:

public class CustomServer : IServer
{
    private IFeatureCollection _features = new FeatureCollection();

    public IFeatureCollection Features => _features;

    public Task StartAsync<TContext>(IHttpApplication<TContext> application,
        CancellationToken cancellationToken) where TContext : notnull
    {
        // Start listening for connections
        // Create HttpContext for each request
        // Invoke application.ProcessRequestAsync(httpContext)
        return Task.CompletedTask;
    }

    public Task StopAsync(CancellationToken cancellationToken)
    {
        // Stop accepting new connections
        // Wait for existing requests to complete
        return Task.CompletedTask;
    }

    public void Dispose()
    {
        // Cleanup resources
    }
}

// Use custom server
var builder = WebApplication.CreateBuilder(args);
builder.WebHost.UseServer(new CustomServer());
var app = builder.Build();

कुंजी अगलों को दूर ले जाता है

होस्ट अनुप्रयोग जीवन, विन्यास, DIS, तथा लॉगिंग का प्रबंधन करता है
केआईआरल एक उच्च आयामी, क्रास-फॉर्म वेब सर्वर है
आप अंत- बिन्दुओं, HTTP, प्रोटोकॉल, तथा प्रदर्शन सीमा कॉन्फ़िगर कर सकते हैं
सर्वर उत्पन्न करता है HttpContext वस्तु जो मध्य- एलबम के माध्यम से प्रवाहित करती है
अनुप्रयोग बन्द करने के पूर्व अनुग्रहदार बन्द करता है
उत्पाद तैनाती आमतौर पर किसी उलटा प्रॉक्सी के पीछे के के-रूल का उपयोग करती है
वह IFeatureCollection कम- स्तर सर्वर क्षमता में पहुँच प्रदान करता है

सर्वर तथा होस्टिंग परत को समझने से आप अपने अनुप्रयोग की शुरूआत कैसे होती है यह कनेक्शन को नियंत्रित करता है, और कैसे यह लोड के नीचे काम करता है. यह नींव जो कुछ भी ऊपर होता है उसे समर्थन करता है.

एनईसी को समझने की कोशिश करता है.