Applikationsstart för ASP.NET Core

Filen Program

ASP.NET Core appar initierar och konfigurerar start i appens Program fil (Program.cs).

Den första delen av Program filen fokuserar på att skapa appen. Den här fasen använder WebApplication.CreateBuilder för att initiera en ny instans av WebApplicationBuilder klassen med förkonfigurerade standardvärden innan appen startas. De ASP.NET Core projektmallarna tilldelar webbprogramverktyget till en variabel med namnet builder:

var builder = WebApplication.CreateBuilder(args);

Egenskaperna för webbprogramverktyget är:

• builder.Configuration är en IConfigurationBuilder och IConfigurationRoot för att hantera konfigurationskällor och leverantörer. Mer information finns i Konfiguration i ASP.NET Core.
• builder.Environment är en IWebHostEnvironment som ger information om appens webbhotellsmiljö. Mer information finns i ASP.NET Core-körningsmiljöer.
• builder.Host är en IHostBuilder för att konfigurera värdspecifika egenskaper. Mer information finns i .NET Generic Host i ASP.NET Core.
• builder.Logging är en ILoggingBuilder med tilläggsmetoder som används för att lägga till och hantera loggningsleverantörer. Mer information finns i Loggning i .NET och ASP.NET Core.
• builder.Metrics(.NET 8 eller senare) möjliggör aktivering av mått och dirigerar deras utdata. För mer information, se ASP.NET Core metrics.
• builder.Services är en samling DI-tjänster för beroendeinjektion (IServiceCollection) som appen använder för att sätta samman Inversion of Control (IoC). Mer information finns i Beroendeinmatning i ASP.NET Core.
• builder.WebHost är en IWebHostBuilder för att konfigurera serverspecifika egenskaper.

Appen skapas genom att anropa WebApplicationBuilder.Build, vilket returnerar den skapade WebApplication. De ASP.NET Core projektmallarna tilldelar det byggda webbprogrammet till en variabel med namnet app:

var app = builder.Build();

Nästa del av filen fokuserar på att etablera hanteringspipelinen Program för HTTP-begäranden som en serie mellanprogramkomponenter. Varje mellanprogram utför åtgärder på en HttpContext och anropar antingen nästa mellanprogram i pipelinen eller avslutar begäran. Enligt konventionen läggs mellanprogramkomponenter till i pipelinen genom att anropa en tilläggsmetod som börjar med "Use." Mer information finns i ASP.NET Core mellanprogram.

Metoden Run startar appen och blockerar den anropande tråden tills värdprocessen avslutas:

app.Run();

När Run körs övergår appen till en aktiv, pågående process:

1. Start av värdtjänster

   Värden går igenom alla registrerade hostade tjänster (IHostedService instanser) och anropar deras StartAsync metoder. Såvida inte appen väljer samtidig start av värdbaserad tjänst (.NET 8 eller senare) börjar värdbaserade tjänster sekventiellt i ordningen för deras DI-containerregistreringar. Mer information finns i Bakgrundsaktiviteter med värdbaserade tjänster i ASP.NET Core.

2. Pipelinen för mellanprogram skapas.

   När builder.Build anropas löses beroenden, men den faktiska bearbetningskedjan är inte helt konfigurerad. När app.Run körs slutför ramverket pipelinen för HTTP-mellanprogram. De deklarerade mellanprogramsmetoderna och slutpunktsmappningarna kompileras till en enda körningsdelegatsekvens med höga prestanda. Mer information finns i ASP.NET Core mellanprogram.

3. Webbservern (Kestrel som standard) startas.

   Värden söker i sin beroendebehållare, hittar den registrerade serverimplementeringen (vanligtvis Kestrel) och initierar startcykeln. Kestrel sedan:

   • Söker efter definierade värd-URL:er och portar från konfiguration, miljövariabler eller kommandoradsargument.
   • Öppnar och allokerar fysiska nätverksuttag.
   • Binder portar och börjar lyssna efter inkommande trafik.

   Mer information finns i .NET allmän värd i ASP.NET Core, webbserverimplementeringar i ASP.NET Core och Kestrel webbserver i ASP.NET Core.

4. Livscykelhändelser vid programstart utlöses.

   Tjänsten IHostApplicationLifetime utlöser sin ApplicationStarted token, vilket anropar de återanrop som har registrerats för tokenen. Eventuella återanrop, databasseedrar eller andra anpassade händelselyssnare som har konfigurerats för att vänta på att tokenen aktiveras utlöses och börjar bearbetas.

5. Huvudkörningstråden blockeras medan appen körs.

   Run (app.Run()) väntar synkront tills avstängningen slutförs.

6. Appen är redo att bearbeta begäranden.

   Nu loggar kommandotolken värddiagnostik:

   info: Microsoft.Hosting.Lifetime[14]
         Now listening on: https://localhost:7123
   info: Microsoft.Hosting.Lifetime[14]
         Now listening on: http://localhost:5123
   info: Microsoft.Hosting.Lifetime[0]
         Application started. Press Ctrl+C to shut down.
   

Appen förblir i det här tillståndet på obestämd tid, skickar inkommande webbtrafik ner i pipelinen för mellanprogram och skickar svar.

När avstängningen signaleras, till exempel när Ctrl+c identifieras i kommandogränssnittet som kör appen eller ett verktyg för containerorkestrering skickar en SIGTERM-händelse, Run avblockeras och följande åtgärder utförs:

1. ApplicationStopping token utlöses, vilket gör att appen kan köra logik innan avstängningsprocessen börjar.

2. Servern Kestrel stängs av, vilket inaktiverar nya anslutningar. Servern väntar på att begäranden om befintliga anslutningar ska slutföras så länge tidsgränsen för avstängning tillåter det. Servern skickar anslutningsstängningshuvudet för ytterligare begäranden om befintliga anslutningar.

3. Värden stänger ned registrerade värdtjänster. Såvida inte appen väljer att stoppa värdbaserade tjänster samtidigt (.NET 8 eller senare) stoppas värdbaserade tjänster sekventiellt i omvänd ordning i sina DI-containerregistreringar. Mer information finns i Bakgrundsaktiviteter med värdbaserade tjänster i ASP.NET Core.

4. ApplicationStopped händelsehanterare utlöses, vilket gör att appen kan köra logik när appen har stängts av.

5. Konsolkörningen avslutas utan fel med avslutningskoden 0.

Klassen Startup konfigurerar tjänster och appens pipeline för begäranden.

Klassen Startup

ASP.NET Core appar använder en startklass, som namnges Startup av konventionen. Klassen Startup:

• Du kan även använda en ConfigureServices-metod för att konfigurera appens -tjänster. En tjänst är en återanvändbar komponent som tillhandahåller appfunktioner. Tjänsterna registreras i ConfigureServices och används i hela appen via beroendeinmatning (DI) eller ApplicationServices.
• Innehåller en Configure metod för att skapa appens pipeline för bearbetning av begäranden.

ConfigureServices och Configure anropas av ASP.NET Core-körningen när appen startar:

public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        ...
    }

    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
    {
        ...
    }
}

Klassen Startup anges när appens värd skapas. Klassen Startup anges vanligtvis genom att anropa WebHostBuilderExtensions.UseStartup på värdverktyget:

public class Program
{
    public static void Main(string[] args)
    {
        CreateHostBuilder(args).Build().Run();
    }

    public static IHostBuilder CreateHostBuilder(string[] args) =>
        Host.CreateDefaultBuilder(args)
            .ConfigureWebHostDefaults(webBuilder =>
            {
                webBuilder.UseStartup<Startup>();
            });
}

Värden tillhandahåller tjänster som är tillgängliga för Startup-klasskonstruktorn. Appen lägger till ytterligare tjänster via ConfigureServices. Både värd- och apptjänsterna är tillgängliga i Configure och i hela appen.

Endast följande tjänsttyper kan matas in i Startup konstruktorn när du använder Generic Host (IHostBuilder):

• IWebHostEnvironment
• IHostEnvironment
• IConfiguration

public class Startup
{
    private readonly IWebHostEnvironment _env;

    public Startup(IConfiguration configuration, IWebHostEnvironment env)
    {
        Configuration = configuration;
        _env = env;
    }

    public IConfiguration Configuration { get; }

    public void ConfigureServices(IServiceCollection services)
    {
        if (_env.IsDevelopment())
        {
        }
        else
        {
        }
    }
}

De flesta tjänster är inte tillgängliga förrän Configure metoden anropas.

Flera Startup klasser

När appen definierar separata Startup klasser för olika miljöer (till exempel StartupDevelopment) väljs lämplig Startup klass vid körning. Klassen vars namnsuffix matchar den aktuella miljön prioriteras. Om appen körs i Development-miljön och innehåller både en Startup-klass och en StartupDevelopment-klass används StartupDevelopment-klassen. Mer information finns i Använda flera miljöer.

ConfigureServices metoden

Den valfria ConfigureServices metoden är:

• Anropas av servern före Configure-metoden för att konfigurera applikationens tjänster.
• Där konfigurationsalternativ anges av konventionen.

Värden kan konfigurera vissa tjänster innan Startup metoder anropas. Mer information finns i översikten över grunderna i ASP.NET Core.

För funktioner som kräver omfattande konfigurering finns Add{Service} tilläggsmetoder för IServiceCollection, till exempel:

• AddDbContext
• AddDefaultIdentity
• AddEntityFrameworkStores
• AddRazorPages

public class Startup
{
    public Startup(IConfiguration configuration)
    {
        Configuration = configuration;
    }

    public IConfiguration Configuration { get; }

    public void ConfigureServices(IServiceCollection services)
    {

        services.AddDbContext<ApplicationDbContext>(options =>
            options.UseSqlServer(
                Configuration.GetConnectionString("DefaultConnection")));
        services.AddDefaultIdentity<IdentityUser>(
            options => options.SignIn.RequireConfirmedAccount = true)
            .AddEntityFrameworkStores<ApplicationDbContext>();

        services.AddRazorPages();
    }
}

Genom att lägga till tjänster i tjänstcontainern blir de tillgängliga i appen och i metoden Configure. Tjänsterna hanteras via dependency injection eller från ApplicationServices.

Configure metoden

Metoden Configure används för att ange hur appen svarar på HTTP-begäranden. Begärans pipeline konfigureras genom att lägga till mellanprogram-komponenter till en IApplicationBuilder-instans. IApplicationBuilder är tillgängligt för metoden Configure, men den är inte registrerad i tjänstekontainern. Hosting skapar en IApplicationBuilder och skickar den direkt till Configure.

ASP.NET Core-mallarna konfigurerar pipelinen med stöd för:

• undantagssida för utvecklare
• Undantagshanterare
• HTTP Strikt transportsäkerhet (HSTS)
• HTTPS-omdirigering
• Statiska filer
• ASP.NET Core MVC och Razor Sidor

I följande exempel visas mellanprogram för en typisk Razor Pages-app:

public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        services.AddRazorPages();
    }

    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
    {
        if (env.IsDevelopment())
        {
            app.UseDeveloperExceptionPage();
        }
        else
        {
            app.UseExceptionHandler("/Error");
            app.UseHsts();
        }

        app.UseHttpsRedirection();
        app.UseStaticFiles();
        app.UseRouting();

        app.UseEndpoints(endpoints =>
        {
            endpoints.MapRazorPages();
        });
    }
}

Föregående exempel är för Razor Pages; MVC-versionen är liknande.

Varje Use tilläggsmetod lägger till en eller flera mellanprogramskomponenter i pipelinen för begäranden. Till exempel konfigurerar UseStaticFilesmellanprogram för att hantera statiska filer.

Varje mellanprogramskomponent i begärandepipelinen ansvarar för att anropa nästa komponent i pipelinen eller kortsluta kedjan, om det är lämpligt.

Ytterligare tjänster, till exempel IWebHostEnvironment, ILoggerFactoryeller något som definierats i ConfigureServices, kan anges i Configure-metodsignaturen. Dessa tjänster injiceras om de är tillgängliga.

Mer information om hur du använder IApplicationBuilder och ordningen på mellanprogramsbearbetning finns i ASP.NET Core mellanprogram.

Konfigurera tjänster utan klass Startup

Om du vill konfigurera tjänster och pipelinen för bearbetning av begäranden utan att använda en Startup-klass anropar du ConfigureServices och Configure bekvämlighetsmetoder på värdverktyget. Flera anrop till ConfigureServices läggs till efter varandra. Om det finns flera Configure metodanrop används det sista Configure-anropet.

public class Program
{
    public static void Main(string[] args)
    {
        CreateHostBuilder(args).Build().Run();
    }

    public static IHostBuilder CreateHostBuilder(string[] args) =>
        Host.CreateDefaultBuilder(args)
            .ConfigureAppConfiguration((hostingContext, config) =>
            {
            })
            .ConfigureWebHostDefaults(webBuilder =>
            {
                webBuilder.ConfigureServices(services =>
                {
                    ...
                })
                .Configure(app =>
                {
                    ...
                });
        });
}

Implementeringen av startfiltret är registrerad i Program filen:

builder.Services.AddTransient<IStartupFilter, CustomResponseHeaderFilter>();

Implementeringen av startfiltret är registrerad i Startup.ConfigureServices:

services.AddTransient<IStartupFilter, CustomResponseHeaderFilter>();

Klassen Startup (ConfigureServices och Configure metoderna)

Även om det stöds i ASP.NET Core appar som är inriktade på .NET 6 eller senare, rekommenderas inte användning av en Startup klass. Mer information finns i Migrera från ASP.NET Core i .NET 5 till .NET 6.

Information om hur du använder ConfigureServices metoderna och Configure med den minimala värdmodellen finns i följande:

• Använda en Startup klass med den minimala värdmodellen
• Klassen Startup (.NET 5 versionen av den här artikeln)

Mäta startprestanda

Den ASP.NET Core värd EventSource genererar ServerReady händelsen, som representerar den punkt där servern är redo att svara på begäranden och kan användas för att mäta starttiden. Mer information finns i Loggning i .NET och ASP.NET Core.