Spuštění aplikace v ASP.NET Core

Rick Anderson, Dykstraa Steve Smith

ASP.NET Core aplikace vytvořené pomocí webových šablon obsahují spouštěcí kód aplikace v souboru program. cs .

Následující kód pro spuštění aplikace podporuje:

var builder = WebApplication.CreateBuilder(args);

// Add services to the container.
builder.Services.AddRazorPages();
builder.Services.AddControllersWithViews();

var app = builder.Build();

// Configure the HTTP request pipeline.
if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Error");
    app.UseHsts();
}

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

app.UseAuthorization();

app.MapGet("/hi", () => "Hello!");

app.MapDefaultControllerRoute();
app.MapRazorPages();

app.Run();

StartupTřída konfiguruje služby a kanál žádostí aplikace.

Spouštěcí třída

aplikace ASP.NET Core používají Startup třídu, která je pojmenována Startup podle konvence. Třída Startup:

  • Volitelně zahrnuje ConfigureServices metodu konfigurace služeb aplikace. Služba je opakovaně použitelná součást, která poskytuje funkce aplikace. Služby jsou v rámci aplikace registrovány ConfigureServices a spotřebovány prostřednictvím Injektáže závislosti (di) nebo ApplicationServices .
  • Obsahuje Configure metodu pro vytvoření kanálu zpracování požadavků aplikace.

ConfigureServicesa Configure jsou volány modulem runtime ASP.NET Core při spuštění aplikace:

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

    public IConfiguration Configuration { get; }

    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.UseAuthorization();

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

Předchozí vzorek je pro Razor stránky. verze MVC je podobná.

StartupTřída je určena při sestavení hostitele aplikace. StartupTřída je obvykle určena voláním WebHostBuilderExtensions.UseStartup/<TStartup> metody v Tvůrci hostitele:

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>();
            });
}

Hostitel poskytuje služby, které jsou k dispozici pro Startup konstruktor třídy. Aplikace přidá další služby prostřednictvím ConfigureServices . Hostitelská i Aplikační služba jsou k dispozici v Configure i v celé aplikaci.

StartupPři použití obecného hostitele () mohou být do konstruktoru vloženy pouze následující typy služeb IHostBuilder :

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
        {
        }
    }
}

Většina služeb není k dispozici, dokud Configure není volána metoda.

Vícenásobné spuštění

Když aplikace definuje samostatné Startup třídy pro různá prostředí (například StartupDevelopment ), příslušná Startup Třída se vybere za běhu. Určuje prioritu třídy, jejíž přípona názvu odpovídá aktuálnímu prostředí. Pokud je aplikace spuštěna ve vývojovém prostředí a obsahuje třídu i Startup StartupDevelopment třídu, StartupDevelopment je použita třída. Další informace najdete v tématu použití více prostředí.

Další informace o hostiteli najdete v hostiteli . Informace o zpracování chyb během spuštění najdete v tématu zpracování výjimek při spuštění.

Metoda ConfigureServices

ConfigureServicesMetoda je:

  • Nepovinný parametr.
  • Volá se hostitelem před Configure metodou konfigurace služeb aplikace.
  • Kde jsou Možnosti konfigurace nastaveny podle konvence.

Hostitel může nakonfigurovat některé služby před Startup voláním metod. Další informace najdete v tématu hostitel.

Pro funkce, které vyžadují podstatnou instalaci, jsou k dispozici Add{Service} metody rozšíření IServiceCollection . Přidejte například DbContext, přidejte výchozí Identity , přidejte EntityFrameworkStores a přidejte Razor stránky:

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();
    }

Přidání služeb do kontejneru služby je zpřístupní v rámci aplikace a v Configure metodě. Služby jsou vyřešeny prostřednictvím Injektáže závislosti nebo z ApplicationServices .

Metoda Configure

ConfigureMetoda slouží k určení způsobu, jakým aplikace reaguje na požadavky HTTP. Kanál požadavků je nakonfigurován přidáním součástí middlewaru do IApplicationBuilder instance. IApplicationBuilder je k dispozici pro Configure metodu, ale není zaregistrována v kontejneru služby. Hostování vytvoří IApplicationBuilder a předá ho přímo do Configure .

šablony ASP.NET Core konfigurují kanál s podporou pro:

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

    public IConfiguration Configuration { get; }

    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.UseAuthorization();

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

Předchozí vzorek je pro Razor stránky. verze MVC je podobná.

Každá Use metoda rozšíření přidá do kanálu žádosti jednu nebo více součástí middlewaru. Například UseStaticFiles nakonfiguruje middleware na poskytování statických souborů.

Každá součást middlewaru v kanálu požadavků zodpovídá za vyvolání další komponenty v kanálu nebo při krátkém okruhu řetězce, pokud je to vhodné.

Další služby, jako například IWebHostEnvironment , ILoggerFactory nebo cokoli definované v ConfigureServices , lze zadat v Configure signatuře metody. Tyto služby jsou vloženy, pokud jsou k dispozici.

Další informace o tom, jak používat IApplicationBuilder a pořadí zpracování middlewaru, najdete v tématu ASP.NET Core Jiné .

Konfigurace služeb bez spuštění

Ke konfiguraci služeb a kanálu zpracování požadavků bez použití Startup třídy, volání ConfigureServices a Configure praktických metod v Tvůrci hostitele. Několik volání, která se mají ConfigureServices navzájem připojit. Pokud Configure existuje více volání metody, Configure je použito poslední volání.

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 =>
                {
                    services.AddControllersWithViews();
                })
                .Configure(app =>
                {
                    var loggerFactory = app.ApplicationServices
                        .GetRequiredService<ILoggerFactory>();
                    var logger = loggerFactory.CreateLogger<Program>();
                    var env = app.ApplicationServices.GetRequiredService<IWebHostEnvironment>();
                    var config = app.ApplicationServices.GetRequiredService<IConfiguration>();

                    logger.LogInformation("Logged in Configure");

                    if (env.IsDevelopment())
                    {
                        app.UseDeveloperExceptionPage();
                    }
                    else
                    {
                        app.UseExceptionHandler("/Home/Error");
                        app.UseHsts();
                    }

                    var configValue = config["MyConfigKey"];
                });
            });
        });
}

Rozšířené spuštění s filtry po spuštění

Použijte IStartupFilter :

  • Konfigurace middlewaru na začátku nebo na konci kanálu Konfigurace middlewaru aplikace bez explicitního volání Use{Middleware} . IStartupFilterse používá ASP.NET Core k přidání výchozích hodnot na začátek kanálu, aniž by bylo nutné, aby autor aplikace explicitně zaregistroval výchozí middleware. IStartupFilter umožňuje, aby jiná komponenta volala Use{Middleware} jménem autora aplikace.
  • Pro vytvoření kanálu Configure metod. IStartupFilter. Configure může nastavit middleware pro spuštění před nebo po middlewaru přidaném knihovnami.

IStartupFilter implementuje Configure , které přijímá a vrací Action<IApplicationBuilder> . IApplicationBuilderDefinuje třídu pro konfiguraci kanálu požadavků aplikace. Další informace najdete v tématu vytvoření kanálu middlewaru pomocí IApplicationBuilder.

Každý IStartupFilter z nich může do kanálu požadavků přidat jeden nebo více middlewarů. Filtry jsou vyvolány v pořadí, v jakém byly přidány do kontejneru služby. Filtry můžou přidat middleware před nebo po předání řízení k dalšímu filtru, takže se připojí k začátku nebo konci kanálu aplikace.

Následující příklad ukazuje, jak registrovat middleware pomocí IStartupFilter . RequestSetOptionsMiddlewareMiddleware nastaví hodnotu možností z parametru řetězce dotazu:

public class RequestSetOptionsMiddleware
{
    private readonly RequestDelegate _next;

    public RequestSetOptionsMiddleware( RequestDelegate next )
    {
        _next = next;
    }

    // Test with https://localhost:5001/Privacy/?option=Hello
    public async Task Invoke(HttpContext httpContext)
    {
        var option = httpContext.Request.Query["option"];

        if (!string.IsNullOrWhiteSpace(option))
        {
            httpContext.Items["option"] = WebUtility.HtmlEncode(option);
        }

        await _next(httpContext);
    }
}

RequestSetOptionsMiddlewareJe nakonfigurován ve RequestSetOptionsStartupFilter třídě:

public class RequestSetOptionsStartupFilter : IStartupFilter
{
    public Action<IApplicationBuilder> Configure(Action<IApplicationBuilder> next)
    {
        return builder =>
        {
            builder.UseMiddleware<RequestSetOptionsMiddleware>();
            next(builder);
        };
    }
}

IStartupFilterJe zaregistrován v kontejneru služby v ConfigureServices .

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.UseStartup<Startup>();
         })
        .ConfigureServices(services =>
        {
            services.AddTransient<IStartupFilter,
                      RequestSetOptionsStartupFilter>();
        });
}

pokud je k dispozici parametr řetězce dotazu pro option , middleware zpracovává přiřazení hodnoty před tím, než ASP.NET Core middleware vykreslí odpověď.

Pořadí spouštění middlewaru je nastaveno podle pořadí IStartupFilter registrací:

  • Více IStartupFilter implementací může komunikovat se stejnými objekty. Pokud je řazení důležité, IStartupFilter zajistěte, aby registrace služeb odpovídaly pořadí, ve kterém by měly být spuštěny middleware.

  • Knihovny můžou přidat middlewaru s jednou nebo více IStartupFilter implementacemi, které se spouštějí před nebo po jiných middlewarech aplikace registrované IStartupFilter . Vyvolání IStartupFilter middlewaru před middlewarem přidaným knihovnou IStartupFilter :

    • Před přidáním knihovny do kontejneru služby umístěte registraci služby.
    • Chcete-li provést vyvolání, umístěte registraci služby po přidání knihovny.

Přidat konfiguraci při spuštění z externího sestavení

IHostingStartupImplementace umožňuje přidání vylepšení aplikace při spuštění z externího sestavení mimo Startup třídu aplikace. Další informace naleznete v tématu Použití hostování spouštěcích sestavení v ASP.NET Core.

Další zdroje informací