ASP.NET Alapvető alapismeretek áttekintése

Ez a cikk áttekintést nyújt az ASP.NET Core-alkalmazások létrehozásának alapjairól, beleértve a függőséginjektálást (DI), a konfigurációt, a köztes szoftvereket és egyebeket.

Az Blazor alapvető útmutatásért, amely hozzáadja vagy felülírja az ebben a cikkben szereplő útmutatást, tekintse meg ASP.NET Alapvető Blazor alapvetőcímű témakört.

Program.cs

ASP.NET webes sablonokkal létrehozott Core-alkalmazások tartalmazzák az alkalmazás indítási kódját a Program.cs fájlban. A Program.cs fájl a következő:

• Az alkalmazás által igényelt szolgáltatások konfigurálva vannak.
• Az alkalmazás kéréskezelési folyamata köztes szoftverösszetevőksorozataként van definiálva.

Az alábbi alkalmazásindítási kód számos alkalmazástípust támogat:

• Blazor Web Apps
• Razor Oldalak
• MVC-vezérlők nézetekkel
• Web API vezérlőkkel
• Minimális webes API-k

using WebAll.Components;

var builder = WebApplication.CreateBuilder(args);

// Add services to the container.
builder.Services.AddRazorComponents()
    .AddInteractiveServerComponents();
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.MapRazorComponents<App>()
    .AddInteractiveServerRenderMode();

app.UseAntiforgery();

app.Run();

Függőséginjektálás (szolgáltatások)

ASP.NET core funkciók beépített függőséginjektálási (DI), amely elérhetővé teszi a konfigurált szolgáltatásokat az alkalmazásokban. A szolgáltatások WebApplicationBuilder.Services, builder.Services az előző kódban vannak hozzáadva a DI-tárolóhoz. A WebApplicationBuilder példányosításakor számos keretrendszer által biztosított szolgáltatás automatikusan hozzáadódik. builder egy WebApplicationBuilder a következő kódban:

var builder = WebApplication.CreateBuilder(args);

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

var app = builder.Build();

Az előző kódban CreateBuilder konfigurálást, naplózást és számos más szolgáltatást a DI-tárolóhoz. A DI-keretrendszer futtatáskor biztosítja a kért szolgáltatás egy példányát.

A következő kód egy egyéni DbContext és Blazor összetevőt ad hozzá a DI-tárolóhoz:

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddDbContextFactory<BlazorWebAppMoviesContext>(options =>
    options.UseSqlServer(builder.Configuration.GetConnectionString("MoviesContext") 
        ?? throw new InvalidOperationException("Connection string not found.")));

builder.Services.AddQuickGridEntityFrameworkAdapter();

builder.Services.AddDatabaseDeveloperPageExceptionFilter();

// Add services to the container.
builder.Services.AddRazorComponents()
    .AddInteractiveServerComponents();

var app = builder.Build();

Az Blazor Web Apps-ben a szolgáltatásokat gyakran futtatáskor oldják fel a DI-ből az @inject irányelv használatával egy Razor összetevőben, ahogyan az alábbi példában látható:

@page "/movies"
@rendermode InteractiveServer
@using Microsoft.EntityFrameworkCore
@using Microsoft.AspNetCore.Components.QuickGrid
@using BlazorWebAppMovies.Models
@using BlazorWebAppMovies.Data
@implements IAsyncDisposable
@inject IDbContextFactory<BlazorWebAppMovies.Data.BlazorWebAppMoviesContext> DbFactory

<PageTitle>Index</PageTitle>

<h1>Index</h1>

<div>
    <input type="search" @bind="titleFilter" @bind:event="oninput" />
</div>

<p>
    <a href="movies/create">Create New</a>
</p>

<QuickGrid Class="table" Items="FilteredMovies" Pagination="pagination">
    <PropertyColumn Property="movie => movie.Title" Sortable="true" />
    <PropertyColumn Property="movie => movie.ReleaseDate" Title="Release Date" />
    <PropertyColumn Property="movie => movie.Genre" />
    <PropertyColumn Property="movie => movie.Price" />
    <PropertyColumn Property="movie => movie.Rating" />

    <TemplateColumn Context="movie">
        <a href="@($"movies/edit?id={movie.Id}")">Edit</a> |
        <a href="@($"movies/details?id={movie.Id}")">Details</a> |
        <a href="@($"movies/delete?id={movie.Id}")">Delete</a>
    </TemplateColumn>
</QuickGrid>

<Paginator State="pagination" />

@code {
    private BlazorWebAppMoviesContext context = default!;
    private PaginationState pagination = new PaginationState { ItemsPerPage = 10 };
    private string titleFilter = string.Empty;

    private IQueryable<Movie> FilteredMovies =>
        context.Movie.Where(m => m.Title!.Contains(titleFilter));

    protected override void OnInitialized()
    {
        context = DbFactory.CreateDbContext();
    }

    public async ValueTask DisposeAsync() => await context.DisposeAsync();
}

Az előző kódban:

• A @inject irányelv használatos.
• A szolgáltatás feloldása a OnInitialized metódusban történik, és hozzá van rendelve a context változóhoz.
• A context szolgáltatás létrehozza a FilteredMovie listát.

Egy szolgáltatás di-ből való feloldásának másik módja a konstruktorinjektálás. A következő Razor Pages-kód konstruktorinjektálással oldja fel az adatbázis-környezetet és egy naplózót a DI-ből:

public class IndexModel : PageModel
{
    private readonly RazorPagesMovieContext _context;
    private readonly ILogger<IndexModel> _logger;

    public IndexModel(RazorPagesMovieContext context, ILogger<IndexModel> logger)
    {
        _context = context;
        _logger = logger;
    }

    public IList<Movie> Movie { get;set; }

    public async Task OnGetAsync()
    {
        _logger.LogInformation("IndexModel OnGetAsync.");
        Movie = await _context.Movie.ToListAsync();
    }
}

Az előző kódban a IndexModel konstruktor egy RazorPagesMovieContexttípusú paramétert vesz fel, amely futásidőben lesz feloldva a _context változóban. A környezeti objektum a filmek listájának létrehozására szolgál a OnGetAsync metódusban.

További információért lásd: ASP.NET Core Blazor függőség-injektálás és függőség-injektálás az ASP.NET Core.

Middleware

A kérelemkezelési folyamat köztes szoftverösszetevők sorozataként áll össze. Minden összetevő műveleteket hajt végre egy HttpContext objektumon, és vagy meghívja a folyamat következő middleware-jét, vagy befejezi a kérést.

Konvenció szerint a rendszer egy köztes szoftverösszetevőt ad hozzá a folyamathoz egy Use{Feature} bővítménymetódus meghívásával. A köztes szoftver alkalmazáshoz való hozzáadásához Use{Feature} nevű metódusok használatát az alábbi kód szemlélteti:

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddDbContextFactory<BlazorWebAppMoviesContext>(options =>
    options.UseSqlServer(builder.Configuration.GetConnectionString("MoviesContext") 
        ?? throw new InvalidOperationException("Connection string not found.")));

builder.Services.AddQuickGridEntityFrameworkAdapter();

builder.Services.AddDatabaseDeveloperPageExceptionFilter();

// Add services to the container.
builder.Services.AddRazorComponents()
    .AddInteractiveServerComponents();

var app = builder.Build();

using (var scope = app.Services.CreateScope())
{
    var services = scope.ServiceProvider;

    SeedData.Initialize(services);
}

// Configure the HTTP request pipeline.
if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Error", createScopeForErrors: true);
    app.UseHsts();
    app.UseMigrationsEndPoint();
}
app.UseHttpsRedirection();

app.UseAntiforgery();

app.MapStaticAssets();
app.MapRazorComponents<App>()
    .AddInteractiveServerRenderMode();

app.Run();

További információ: ASP.NET Core Middleware.

Host

Indításkor egy ASP.NET Core-alkalmazás létrehoz egy gazdagépet. A gazdagép az alkalmazás összes erőforrását magában foglalja, például:

• HTTP-kiszolgáló implementálása
• Köztes szoftverösszetevők
• Logging
• Függőséginjektálási (DI-) szolgáltatások
• Configuration

Három különböző gazdagép képes egy ASP.NET Core-alkalmazás futtatására:

• ASP.NET Core WebApplication, más néven Minimal Host
• .NET Generikus Host kombinálva ASP.NET Core-ral ConfigureWebHostDefaults
• ASP.NET Core Webkiszolgáló

A ASP.NET Core-WebApplication és WebApplicationBuilder típusok ajánlottak, és az összes ASP.NET Core-sablonban használhatók. WebApplication hasonlóan viselkedik a .NET Általános gazdagéphez, és számos felületet tesz elérhetővé, de kevesebb visszahívást igényel a konfiguráláshoz. A ASP.NET Core WebHost csak a visszamenőleges kompatibilitás érdekében érhető el.

Az alábbi példa létrehoz egy WebApplication, és hozzárendeli egy appnevű változóhoz:

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddDbContextFactory<BlazorWebAppMoviesContext>(options =>
    options.UseSqlServer(builder.Configuration.GetConnectionString("MoviesContext") 
        ?? throw new InvalidOperationException("Connection string not found.")));

builder.Services.AddQuickGridEntityFrameworkAdapter();

builder.Services.AddDatabaseDeveloperPageExceptionFilter();

// Add services to the container.
builder.Services.AddRazorComponents()
    .AddInteractiveServerComponents();

var app = builder.Build();

A WebApplicationBuilder.Build metódus alapértelmezett beállításokkal konfigurál egy kiszolgálót, például:

• Használja a Kestrel webkiszolgálóként, és engedélyezze az IIS-integrációt.
• Töltse be konfiguráció a appsettings.json-ből, környezeti változókból, parancssori argumentumokból és más konfigurációs forrásokból.
• Naplózási kimenet küldése a konzolnak és hibakeresési szolgáltatóknak.

Nem webes forgatókönyvek

Az Általános Host lehetővé teszi más típusú alkalmazások számára, hogy keresztmetszeti keretrendszer-kiegészítéseket használjanak, például naplózást, függőséginjektálást (DI), konfigurációt és alkalmazásélettartam-kezelést. További információkért lásd: .NET Általános Gazda az ASP.NET Core-ban és Háttérfeladatok hosztolt szolgáltatásokkal az ASP.NET Core-ban.

Servers

Egy ASP.NET Core-alkalmazás HTTP-kiszolgálói implementációval figyeli a HTTP-kéréseket. A kiszolgáló az alkalmazáshoz érkező kéréseket egy -ként jeleníti meg, ami egy kérelmi funkciókészletből áll.

Windows

ASP.NET Core a következő kiszolgálói implementációkat biztosítja:

• Kestrel egy platformfüggetlen webkiszolgáló. Kestrel gyakran fordított proxykonfigurációban futtatják IIShasználatával. A ASP.NET Core 2.0-s vagy újabb verzióiban Kestrel futtatható nyilvános elérésű peremhálózati kiszolgálóként, amely közvetlenül az interneten érhető el.
• IIS HTTP Server egy windowsos kiszolgáló, amely IIS-t használ. Ezzel a kiszolgálóval a ASP.NET Core alkalmazás és az IIS ugyanabban a folyamatban fut.
• HTTP.sys olyan Windows-kiszolgáló, amelyet nem használnak IIS-vel.

macOS

ASP.NET Core biztosítja a Kestrel platformfüggetlen kiszolgáló implementálását. A ASP.NET Core 2.0-s vagy újabb verzióiban a Kestrel az interneten közvetlenül elérhető nyilvános elérésű peremhálózati kiszolgálóként is futtathatók. Kestrel gyakran fordított proxykonfigurációban futtatják Nginx vagy Apache.

Linux

ASP.NET Core biztosítja a Kestrel platformfüggetlen kiszolgáló implementálását. A ASP.NET Core 2.0-s vagy újabb verzióiban a Kestrel az interneten közvetlenül elérhető nyilvános elérésű peremhálózati kiszolgálóként is futtathatók. Kestrel gyakran fordított proxykonfigurációban futtatják Nginx vagy Apache.

További információért lásd az ASP.NET Corewebkiszolgáló-implementációit a hivatkozás alatt.

Configuration

ASP.NET Core egy konfigurációs keretrendszert biztosít, amely név-érték párként lekéri a beállításokat a konfigurációszolgáltatók rendezett készletéből. A beépített konfigurációszolgáltatók számos különböző forráshoz érhetők el, például .json fájlokhoz, .xml fájlokhoz, környezeti változókhoz és parancssori argumentumokhoz. Írjon egyéni konfigurációszolgáltatókat más források támogatására.

Az alapértelmezettASP.NET Core-alkalmazások úgy vannak konfigurálva, hogy , környezeti változókból, parancssorból és egyebekből olvassanak. Az alkalmazás konfigurációjának betöltésekor a környezeti változók értékei felülbírálják appsettings.jsonértékeit.

A bizalmas konfigurációs adatok, például a fejlesztési környezet jelszavainak kezeléséhez a .NET biztosítja a Secret Managert. A produkciós titkok esetében a(z) Azure Key Vault-et javasoljuk.

További információkért lásd: Konfiguráció az ASP.NET Core-ben.

Environments

A végrehajtási környezetek, például Development, Stagingés Production, ASP.NET Core-ban érhetők el. Adja meg az alkalmazás által futtatott környezetet a ASPNETCORE_ENVIRONMENT környezeti változó beállításával. ASP.NET Core beolvassa ezt a környezeti változót az alkalmazás indításakor, és egy IWebHostEnvironment-implementációban tárolja az értéket. Ez az implementáció az alkalmazás bármely pontján elérhető függőséginjektáláson (DI) keresztül.

Az alábbi példa konfigurálja a kivételkezelőt és HTTP Strict Transport Security Protocol (HSTS) köztes szoftvereket, ha nem futnak a Development környezetben:

if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Error", createScopeForErrors: true);
    app.UseHsts();
    app.UseMigrationsEndPoint();
}

További információ: ASP.NET Core futtatókörnyezetek.

Logging

ASP.NET Core támogatja a különböző beépített és külső naplózási szolgáltatókkal működő naplózási API-t. Az elérhető szolgáltatók a következők:

• Console
• Debug
• Eseménykövetés Windows rendszeren
• Windows eseménynapló
• TraceSource
• Azure App Service
• Azure Application Insights

Naplók létrehozásához oldjon fel egy ILogger<TCategoryName> szolgáltatást a függőség-injektálásból, és hívjon meg olyan naplózási módszereket, mint például a LogInformation. Az alábbi példa bemutatja, hogyan szerezhet be és használhat naplózót egy .razor fájlban egy Blazor Web Applapjához. A naplózó objektumot és a hozzá tartozó konzolszolgáltatót automatikusan a DI-tárolóban tárolják, amikor a CreateBuilder metódust a Program.cs-ben meghívják.

@page "/weather"
@attribute [StreamRendering]
@inject ILogger<Weather> Logger

<PageTitle>Weather</PageTitle>

<h1>Weather</h1>

<p>This component demonstrates showing data and logging.</p>

@if (forecasts == null)
{
    <p><em>Loading...</em></p>
}
else
{
    <table class="table">
        <thead>
            <tr>
                <th>Date</th>
                <th aria-label="Temperature in Celsius">Temp. (C)</th>
                <th aria-label="Temperature in Fahrenheit">Temp. (F)</th>
                <th>Summary</th>
            </tr>
        </thead>
        <tbody>
            @foreach (var forecast in forecasts)
            {
                <tr>
                    <td>@forecast.Date.ToShortDateString()</td>
                    <td>@forecast.TemperatureC</td>
                    <td>@forecast.TemperatureF</td>
                    <td>@forecast.Summary</td>
                </tr>
            }
        </tbody>
    </table>
}

@code {
    private WeatherForecast[]? forecasts;

    protected override async Task OnInitializedAsync()
    {
        // Simulate asynchronous loading to demonstrate streaming rendering
       
        await Task.Delay(500);

        Logger.LogInformation("This is an information log message.");
        Logger.LogWarning("This is a warning log message.");
        Logger.LogError("This is an error log message.");

        var startDate = DateOnly.FromDateTime(DateTime.Now);
        var summaries = new[] { "Freezing", "Bracing", "Chilly",
            "Cool", "Mild", "Warm", "Balmy", "Hot", "Sweltering", "Scorching" };
        forecasts = Enumerable.Range(1, 5).Select(index => new WeatherForecast
        {
            Date = startDate.AddDays(index),
            TemperatureC = Random.Shared.Next(-20, 55),
            Summary = summaries[Random.Shared.Next(summaries.Length)]
        }).ToArray();
    }

    private class WeatherForecast
    {
        public DateOnly Date { get; set; }
        public int TemperatureC { get; set; }
        public string? Summary { get; set; }
        public int TemperatureF => 32 + (int)(TemperatureC / 0.5556);
    }
}

További információ: Naplózás a .NET-ben és a ASP.NET Core-ban.

Routing

Az útválasztás a ASP.NET Core-ban egy olyan mechanizmus, amely leképozza a bejövő kéréseket egy alkalmazás adott végpontjaihoz. Lehetővé teszi a különböző összetevőknek megfelelő URL-minták meghatározását, például Blazor összetevőket, Razor lapokat, MVC-vezérlőműveleteket vagy köztes szoftvereket.

A UseRouting(IApplicationBuilder) metódus útválasztási köztes szoftvereket ad hozzá a kérelemfolyamathoz. Ez a köztes szoftver feldolgozza az útválasztási információkat, és meghatározza az egyes kérések megfelelő végpontjait. Csak akkor kell explicit módon meghívnia UseRouting, ha módosítani szeretné a köztes szoftver feldolgozásának sorrendjét.

További információ: Útválasztás ASP.NET Core és ASP.NET Core Blazor útválasztási és navigációs.

Hibakezelés

ASP.NET Core beépített funkciókkal rendelkezik a hibák kezelésére, például:

• Fejlesztői kivétel-oldal
• Egyéni hibalapok
• Statikus állapotkódlapok
• Indítási kivétel kezelése

További információ: ASP.NET Corehibáinak kezelése.

HTTP-kérések létrehozása

A IHttpClientFactory implementációja HttpClient példányok létrehozásához érhető el. A gyár:

• Központi helyet biztosít a logikai HttpClient-példányok elnevezéséhez és konfigurálásához. Regisztráljon és konfiguráljon például egy GitHub-ügyfelet a GitHub eléréséhez. Alapértelmezett ügyfél regisztrálása és konfigurálása más célokra.
• Támogatja a több delegáló kezelő regisztrációját és láncolását egy kimenő kérelem köztesszoftver-folyamat létrehozásához. Ez a minta hasonlít az ASP.NET Core bejövő middleware csatornájára. A minta egy mechanizmust biztosít a HTTP-kérések keresztvágási problémáinak kezelésére, beleértve a gyorsítótárazást, a hibakezelést, a szerializálást és a naplózást.
• Integrálódik Polly-vel, amely egy népszerű külső könyvtár az átmeneti hibakezeléshez.
• Kezeli az alapul szolgáló HttpClientHandler példányok összesítését és élettartamát, hogy elkerülje a gyakori DNS-problémákat, amelyek akkor fordulnak elő, amikor a HttpClient élettartamát manuálisan kezelik.
• Konfigurálható naplózási felületet ad hozzá ILogger a gyár által létrehozott ügyfeleken keresztül küldött összes kéréshez.

A további információkért lásd: HTTP-kérések létrehozása az IHttpClientFactory használatával az ASP.NET Core-ban.

Tartalomgyökér

A tartalomgyökér a következő alap elérési útja:

• Az alkalmazást futtató végrehajtható fájl (.exe).
• Az alkalmazást alkotó összeállított szerelvények (.dll).
• Az alkalmazás által használt tartalomfájlok, például:
  • Razor fájlok (.cshtml, .razor)
  • Konfigurációs fájlok (.json, .xml)
  • Adatfájlok (.db)
• A webes gyökér, általában a wwwroot mappa.

A fejlesztés során a tartalomgyökér alapértelmezés szerint a projekt gyökérkönyvtárában van. Ez a könyvtár az alkalmazás tartalomfájljainak és a webes gyökérnek is az alap elérési útja. Adjon meg egy másik tartalomgyökereket az elérési út beállításával a gazdagéplétrehozásakor. További információért lásd a Tartalomgyökérrészt.

Webes gyökér

A webes gyökér a nyilvános, statikus erőforrásfájlok alap elérési útja, például:

• Stíluslapok (.css)
• JavaScript (.js)
• Képek (.png, .jpg)

Alapértelmezés szerint a statikus fájlok csak a webes gyökérkönyvtárból és annak alkönyvtáraiból lesznek kiszolgálva. A webes gyökér elérési útja alapértelmezés szerint az {CONTENT ROOT}/wwwroot, ahol a {CONTENT ROOT} helyőrző a tartalomgyökér. Adjon meg egy másik webgyökeret az elérési útjának beállításával a gazdagép létrehozásakor. További információ: webes gyökér.

A fájlok közzétételének megakadályozása wwwroot a projektfájl <Content> projekt elemével. Az alábbi példa megakadályozza a tartalom közzétételét a wwwroot/local könyvtárban és annak alkönyvtáraiban.

<ItemGroup>
  <Content Update="wwwroot\local\**\*.*" CopyToPublishDirectory="Never" />
</ItemGroup>

Razor .cshtml fájlokban ~/ a webes gyökérre mutat. A ~/ kezdetű elérési utat virtuális elérési útnak nevezzük.

További információ: Statikus fájlok az ASP.NET Core-ban.

Minta letöltése

Számos cikk és oktatóanyag tartalmaz mintakódra mutató hivatkozásokat.

1. Töltse le a ASP.NET adattár zip-fájlját.
2. Bontsa ki a AspNetCore.Docs-main.zip fájlt.
3. Ha egy cikk mintaalkalmazását szeretné elérni a kibontott adattárban, használja a cikk mintahivatkozásában található URL-címet a mintamappához való navigáláshoz. A cikk mintahivatkozása általában a cikk tetején jelenik meg a hivatkozás szövegnézetével vagy a mintakód letöltésével.

Preprocesszor-irányelvek a mintakódban

Több forgatókönyv bemutatásához a mintaalkalmazások a #define és #if-#else/#elif-#endif előfeldolgozási irányelveket használják a mintakód különböző szakaszainak szelektív fordításához és futtatásához. Azoknál a mintáknál, amelyek ezt a megközelítést használják, állítsa a #define irányelvet a C#-fájlok tetején a futtatni kívánt forgatókönyvhöz társított szimbólum meghatározásához. Egyes mintákhoz több fájl tetején kell definiálni a szimbólumot egy forgatókönyv futtatásához.

Az alábbi #define szimbólumlista például azt jelzi, hogy négy forgatókönyv érhető el (szimbólumonként egy forgatókönyv). Az aktuális mintakonfiguráció a TemplateCode forgatókönyvet futtatja:

#define TemplateCode // or LogFromMain or ExpandDefault or FilterInCode

Ha módosítani szeretné a mintát a ExpandDefault forgatókönyv futtatásához, adja meg a ExpandDefault szimbólumot, és hagyja megjegyzésben a többi szimbólumot:

#define ExpandDefault // TemplateCode or LogFromMain or FilterInCode

További információ a C# előfeldolgozási irányelveknek a kódszakaszok szelektív fordítására való használatával kapcsolatban: #define (C# referencia) és #if (C# referencia).

Régiók a mintakódban

Egyes mintaalkalmazások #region és #endregion C#-irányelvek által körülvett kódszakaszokat tartalmaznak. A dokumentáció összeállítási rendszere ezeket a régiókat a renderelt dokumentációs témakörökbe injektálja.

A régiónevek általában tartalmazzák a "kódrészlet" szót. Az alábbi példa egy következő nevű régiót snippet_WebHostDefaultsmutat be:

#region snippet_WebHostDefaults
Host.CreateDefaultBuilder(args)
    .ConfigureWebHostDefaults(webBuilder =>
    {
        webBuilder.UseStartup<Startup>();
    });
#endregion

Az előző C# kódrészletre a témakör Markdown-fájljában a következő sor hivatkozik:

[!code-csharp[](sample/SampleApp/Program.cs?name=snippet_WebHostDefaults)]

Nyugodtan figyelmen kívül hagyhatja vagy eltávolíthatja a #region kódot körülvevő irányelveket és #endregion irányelveket. Ha a témakörben ismertetett mintaforgatókönyveket szeretné futtatni, ne módosítsa az irányelvekben szereplő kódot.

További információ: Hozzájárulás a ASP.NET dokumentációhoz: Kódrészletek.

További erőforrások

ASP.NET Core Blazor alapjai