ASP.NET Alapvető alapismeretek áttekintése

Cikk
12/15/2024

Jegyzet

Ez nem a cikk legújabb verziója. Az aktuális kiadáshoz tekintse meg a jelen cikk .NET 9-es verzióját.

Figyelmeztetés

A ASP.NET Core ezen verziója már nem támogatott. További információ: .NET és .NET Core támogatási szabályzat. A jelenlegi kiadáshoz lásd ennek a cikknek a .NET 9-es verzióját .

Fontos

Ezek az információk egy olyan előzetes termékre vonatkoznak, amelyet a kereskedelmi forgalomba kerülés előtt jelentősen módosíthatnak. A Microsoft nem vállal kifejezett vagy hallgatólagos szavatosságot az itt megadott információkra vonatkozóan.

Nézze meg az aktuális kiadást ennek a cikknek a .NET 9-es verziójában .

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:

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.

Köztes szoftver

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.

Házigazda

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
Fakitermelés
Függőséginjektálási (DI-) szolgáltatások
Konfiguráció

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.

Szerverek

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.

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 és ú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.

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

Konfiguráció

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örnyezetben lévő jelszavak kezeléséhez a .NET Core biztosítja a Secret Manager. 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.

Környezetek

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óért lásd: Több környezet használata az ASP.NET Core-ban.

Fakitermelés

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:

Konzol
Hibakeresés
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ókért lásd: Naplózás a .NET Core és az ASP.NET Core rendszerben.

Útválasztás

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 Web 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éralap elérési útja is. 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útvonal alapértelmezés szerint {content root}/wwwroot. 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.

Megakadályozza a wwwroot fájlok közzétételét a projektfájlban a <tartalom> projektelem használatával. Az alábbi példa megakadályozza a tartalom közzétételét a wwwroot/local é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.

További erőforrások

ASP.NET Core Blazor alapjai

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.

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 támogatja:

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

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

ASP.NET Core függőséginjektálást (DI) tartalmaz, 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 lesz hozzáadva. 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ő kiemelt kódban builder konfigurációval, naplózással és számos más szolgáltatással rendelkezik, hozzáadva a DI-tárolóhoz.

A következő kód hozzáadja a Razor oldalakat, a nézetekkel rendelkező MVC-vezérlőket és egy egyéni DbContext-et a DI-tárolóhoz.

using Microsoft.EntityFrameworkCore;
using RazorPagesMovie.Data;
var builder = WebApplication.CreateBuilder(args);

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

builder.Services.AddDbContext<RazorPagesMovieContext>(options =>
   options.UseSqlServer(builder.Configuration.GetConnectionString("RPMovieContext")));

var app = builder.Build();

A szolgáltatások általában konstruktorinjektálással oldódnak fel a DI-ből. A DI-keretrendszer futtatókörnyezetben biztosítja a szolgáltatás egy példányát.

Az alábbi kód konstruktorinjektálással oldja fel az adatbázis-környezetet és a 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();
    }
}

Köztes szoftver

A kérelemkezelési folyamat köztes szoftverösszetevők sorozataként áll össze. Minden összetevő műveleteket hajt végre egy HttpContext-án, és vagy meghívja a következő köztes réteget a folyamatban, vagy leállítja 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. Az alkalmazáshoz hozzáadott köztes szoftver a következő kódban van kiemelve:

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

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

Házigazda

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
Fakitermelés
Függőséginjektálási (DI-) szolgáltatások
Konfiguráció

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

ASP.NET Core webalkalmazás, más néven Minimal Host
.NET Általános Host kombinálva az ASP.NET Core-ral ConfigureWebHostDefaults
ASP.NET Core WebHost

A ASP.NET Core-WebApplication és WebApplicationBuilder típusok ajánlottak és használhatók az ASP.NET Core-sablonokban. 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 egy WebApplicationpéldányosítását mutatja be:

var builder = WebApplication.CreateBuilder(args);

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

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 a konfigurációs fájlt a appsettings.json, a 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 gazdagép lehetővé teszi, hogy más típusú alkalmazások többszintű keretrendszerbővítményeket 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óért lásd: .NET Általános Kiszolgáló az ASP.NET Core és Háttérfeladatok hosztolt szolgáltatásokkal az ASP.NET Core-ban.

Szerverek

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

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.

További információkért lásd: webkiszolgáló-implementációk az ASP.NET Core-ban.

Konfiguráció

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. Egyéni konfigurációszolgáltatók írása más források támogatásához.

A bizalmas konfigurációs adatok, például jelszavak kezeléséhez a .NET Core biztosítja a Secret Manager. A gyártási titkok esetében az Azure Key Vaultjavasoljuk.

További információkért lásd a "Konfiguráció az ASP.NET Core-ban" részt.

Környezetek

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:

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

További információkért lásd: Több környezet használata az ASP.NET Core-ban.

Fakitermelés

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:

Konzol
Hibakeresés
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 függetlenül az injektált függőségektől (DI), és hívja meg például a LogInformationnaplózási módszereket. Például:

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

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

Útválasztás

A útvonal egy kezelőhöz hozzárendelt URL-minta. A kezelő általában egy Razor lap, egy MVC-vezérlő műveletmetódusa vagy köztes szoftver. ASP.NET Core-útválasztással szabályozhatja az alkalmazás által használt URL-címeket.

A ASP.NET Core-webalkalmazás-sablon által létrehozott következő kód meghívja UseRouting:

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddRazorPages();

var app = builder.Build();

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

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

app.UseRouting();

app.UseAuthorization();

app.MapRazorPages();

app.Run();

További információkért lásd: Útvonalkezelés az ASP.NET Core-ban.

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ó az ASP.NET Core bejövő köztes szoftver csővezetékéhez. 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 a Polly, amely egy népszerű külső könyvtár az átmeneti hibakezeléshez.
Kezeli az alapul szolgáló HttpClientHandler példányok gyűjtését és élettartamát, elkerülendő a gyakori DNS-problémákat, amelyek a HttpClient élettartam manuális kezelésekor merülnek fel.
Konfigurálható naplózási felületet nyújt a ILogger-n keresztül a gyár által létrehozott kliensen keresztül küldött összes kéréshez.

Az ASP.NET Core keretében további információért tekintse meg a HTTP-kérések létrehozása az IHttpClientFactory használatávaldokumentumot.

Tartalomgyökér

A tartalomgyökér a kiinduló elérési út a következőhöz:

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 mappát.

A fejlesztés során a tartalomgyökér alapértelmezés szerint a projekt gyökérkönyvtárában lesz. Ez a könyvtár az alkalmazás tartalomfájljainak és a webgyökéralap elérési útja is. 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ókért lásd a tartalomgyökér-t.

Webhely gyökérkönyvtára

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útvonal alapértelmezés szerint {content root}/wwwroot. Adjon meg egy másik webgyökeret úgy, hogy létrehozásakor beállítja az útvonalát a gazdagépalatt. További információért lásd a webgyökér.

A wwwroot fájlok közzétételének megakadályozásához használja a projektfájlban a <tartalmi projektelem> címkét. Az alábbi példa megakadályozza a tartalmak közzétételét wwwroot/helyi és 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óért lásd: Statikus fájlok az ASP.NET Core-ban.

További erőforrások

WebApplicationBuilder forráskód

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.

A Startup osztály

A Startup osztály 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ők sorozataként van definiálva.

Íme egy minta Startup osztály:

public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        services.AddDbContext<RazorPagesMovieContext>(options =>
            options.UseSqlServer(Configuration.GetConnectionString("RazorPagesMovieContext")));

        services.AddControllersWithViews();
        services.AddRazorPages();
    }

    public void Configure(IApplicationBuilder app)
    {
        app.UseHttpsRedirection();
        app.UseStaticFiles();

        app.UseRouting();

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

További információért lásd: Alkalmazás indítása ASP.NET Core.

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

ASP.NET Core tartalmaz egy beépített függőséginjektálási (DI) keretrendszert, amely elérhetővé teszi a konfigurált szolgáltatásokat az alkalmazásokban. A naplózási összetevő például egy szolgáltatás.

A regisztert, valamint a szolgáltatások konfigurálására (vagy regisztrálására) szolgáló kódot hozzáadták a Startup.ConfigureServices metódushoz. Például:

public void ConfigureServices(IServiceCollection services)
{
    services.AddDbContext<RazorPagesMovieContext>(options =>
        options.UseSqlServer(Configuration.GetConnectionString("RazorPagesMovieContext")));

    services.AddControllersWithViews();
    services.AddRazorPages();
}

A szolgáltatások általában konstruktorinjektálással oldódnak fel a DI-ből. Konstruktorinjektálás esetén az osztály egy konstruktorparamétert deklarál a szükséges típusból vagy interfészből. A DI-keretrendszer futtatókörnyezetben biztosítja a szolgáltatás egy példányát.

Az alábbi példa konstruktorinjektálással oldja fel a DI-ből származó RazorPagesMovieContext:

public class IndexModel : PageModel
{
    private readonly RazorPagesMovieContext _context;

    public IndexModel(RazorPagesMovieContext context)
    {
        _context = context;
    }

    // ...

    public async Task OnGetAsync()
    {
        Movies = await _context.Movies.ToListAsync();
    }
}

Ha a beépített Inversion of Control (IoC) tároló nem felel meg egy alkalmazás összes igényének, egy külső IoC-tároló használható helyette.

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

Köztes szoftver

A kérelemkezelési folyamat köztes szoftverösszetevők sorozataként áll össze. Minden összetevő műveleteket hajt végre valamin, mint például egy HttpContext, és vagy meghívja a következő közbenső szoftvert a folyamatban, vagy megszakítja a kérést.

Konvenció szerint egy köztes szoftverösszetevőt ad hozzá a folyamathoz egy Use... bővítménymetódus meghívásával a Startup.Configure metódusban. A statikus fájlok megjelenítésének engedélyezéséhez például hívja meg a UseStaticFiles.

Az alábbi példa egy kérelemkezelési folyamatot konfigurál:

public void Configure(IApplicationBuilder app)
{
    app.UseHttpsRedirection();
    app.UseStaticFiles();

    app.UseRouting();

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

ASP.NET Core beépített köztes szoftvereket tartalmaz. Egyéni köztes szoftverösszetevők is írhatók.

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

Házigazda

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

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

Két különböző szerver van.

.NET Generic Host
ASP.NET Core Web Host

A .NET Generic Host használata ajánlott. A ASP.NET Core Web Host csak a visszamenőleges kompatibilitás érdekében érhető el.

Az alábbi példa létrehoz egy .NET-alapú általános gazdagépet:

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

A CreateDefaultBuilder és ConfigureWebHostDefaults metódusok alapértelmezett beállításokkal konfigurálják a gazdagépeket, például:

Használja a Kestrel webkiszolgálóként, és engedélyezze az IIS-integrációt.
Töltse be a konfigurációt appsettings.json, appsettings.{Environment}.json, 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.

További információ: .NET Generic Host in ASP.NET Core.

Nem webes helyzetek

Az Általános gazdagép lehetővé teszi, hogy más típusú alkalmazások többszintű keretrendszerbővítményeket 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óért lásd: .NET generikus gazda az ASP.NET Core-ban és Háttérfeladatok hosztolt szolgáltatásokkal az ASP.NET Core-ban.

Szerverek

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.

További információ: webkiszolgáló-implementációk ASP.NET Core.

Konfiguráció

ASP.NET Core egy konfigurációs keretrendszert biztosít, amely név-érték párként kapja meg a beállításokat egy rendezett konfigurációszolgáltatótó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.

A kapcsolódó konfigurációs értékek olvasásának elsődleges módja a beállításmintahasználata. További információ: Hierarchikus konfigurációs adatok kötése a beállítási mintával.

A bizalmas konfigurációs adatok, például jelszavak kezeléséhez a .NET Core biztosítja a Secret Manager. A gyártási titkokhoz az Azure Key Vaultjavasoljuk.

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

Környezetek

A végrehajtási környezetek, például Development, Stagingés Production, első osztályú fogalmak a ASP.NET Core-ban. 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 úgy konfigurálja az alkalmazást, hogy részletes hibainformációkat adjon meg a Development környezetben való futtatáskor:

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.MapDefaultControllerRoute();
        endpoints.MapRazorPages();
    });
}

További információért lásd ASP.NET Core több környezet használata.

Fakitermelés

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:

Konzol
Hibakeresés
Eseménykövetés Windows rendszeren
Windows eseménynapló
Nyomkövetési Forrás
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ó rendszerből (DI), és hívja meg az olyan naplózási módszereket, mint a LogInformation. Például:

public class TodoController : ControllerBase
{
    private readonly ILogger _logger;

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

    [HttpGet("{id}", Name = "GetTodo")]
    public ActionResult<TodoItem> GetById(string id)
    {
        _logger.LogInformation(LoggingEvents.GetItem, "Getting item {Id}", id);
        
        // Item lookup code removed.
        
        if (item == null)
        {
            _logger.LogWarning(LoggingEvents.GetItemNotFound, "GetById({Id}) NOT FOUND", id);
            return NotFound();
        }
        
        return item;
    }
}

Az olyan naplózási módszerek, mint a LogInformation, tetszőleges számú mezőt támogatnak. Ezeket a mezőket gyakran használják üzenet stringlétrehozására, de egyes naplózási szolgáltatók külön mezőkként küldik el ezeket az adattárakba. Ez a funkció lehetővé teszi, hogy a naplózási szolgáltatók szemantikai naplózást, más néven strukturált naplózásiimplementáljanak.

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

Útválasztás

További információért lásd: Útvonalválasztás az ASP.NET Core-ban.

Hibakezelés

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

Fejlesztői kivételoldal
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 több delegáló kezelő regisztrációját és láncolását egy kimenő kérés közvetítői lánc létrehozásához. Ez a minta hasonló az ASP.NET Core bejövő middleware csatornájához. 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 a Pollykönyvtárral, amely népszerű külső könyvtár az átmeneti hibakezeléshez.
Kezeli az alapul szolgáló HttpClientHandler példányok készletezé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 lehetőséget ad a ILogger-on keresztül a gyár által létrehozott kliensen keresztül küldött összes kéréshez.

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

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 mappát.

A fejlesztés során a tartalomgyökér alapértelmezés szerint a projekt gyökérkönyvtárában lesz. Ez a könyvtár az alkalmazás tartalomfájljainak és a webes gyökéralap elérési útja is. 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: tartalomgyökér.

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útvonal alapértelmezés szerint {content root}/wwwroot. Adjon meg egy másik webgyökereket a gazdagéplétrehozásakor megadott elérési út beállításával. További információ: webes gyökér.

A wwwroot fájlok közzétételének megakadályozása érdekében használja a projektfájlban található <Tartalom> projektelem-t. Az alábbi példa megakadályozza a tartalom közzétételét a wwwroot/local és az alkönyvtáraiban:

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

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

További információért lásd: Statikus fájlok az ASP.NET Core.

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.

Blazor alapjairól szóló útmutatásért, amely kiegészíti vagy felülírja a csomópont útmutatását, tekintse meg ASP.NET Core Blazor alapjait.

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 támogatja:

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

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

ASP.NET Core függőséginjektálást (DI) tartalmaz, 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 kerül hozzáadásra. 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ő kiemelt kódban builder konfigurációval, naplózással és számos más szolgáltatással rendelkezik, hozzáadva a DI-tárolóhoz.

A következő kód Razor lapokat, MVC-vezérlőket nézetekkel és egy egyéni DbContext-et ad hozzá a DI-tárolóhoz.

using Microsoft.EntityFrameworkCore;
using RazorPagesMovie.Data;
var builder = WebApplication.CreateBuilder(args);

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

builder.Services.AddDbContext<RazorPagesMovieContext>(options =>
   options.UseSqlServer(builder.Configuration.GetConnectionString("RPMovieContext")));

var app = builder.Build();

A szolgáltatások általában konstruktorinjektálással oldódnak fel a DI-ből. A DI-keretrendszer futtatókörnyezetben biztosítja a szolgáltatás egy példányát.

Az alábbi kód konstruktorinjektálással oldja fel az adatbázis-környezetet és a 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();
    }
}

Köztes szoftver

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

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

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

Házigazda

Egy ASP.NET Core-alkalmazás indításkor létrehoz egy gazdagépet. A szerver 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
Fakitermelés
Függőséginjektálási (DI-) szolgáltatások
Konfiguráció

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 a Minimális kiszolgáló
.NET Generic Host az ASP.NET Core-ral kombinálva ConfigureWebHostDefaults
ASP.NET Core WebHost

Az alábbi példa bemutat egy WebApplicationpéldányt:

var builder = WebApplication.CreateBuilder(args);

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

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.
A konfiguráció töltése a appsettings.json, környezeti változók, parancssori argumentumok és egyéb konfigurációs források alapján.
Naplózási kimenet küldése a konzolnak és hibakeresési szolgáltatóknak.

Nem webes forgatókönyvek

Az Általános gazdagép lehetővé teszi, hogy más típusú alkalmazások többszintű keretrendszerbővítményeket 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ó: .NET Generikus Gazda az ASP.NET Core-ban és Háttérfeladatok üzemeltetett szolgáltatásokkal az ASP.NET Core-ban.

Szerverek

Egy ASP.NET Core-alkalmazás HTTP-kiszolgálói implementációval figyeli a HTTP-kéréseket. A kiszolgáló úgy jeleníti meg az alkalmazáshoz érkező kéréseket, hogy azok egy alkotóelemű kérelemfunkciókészletbe vannak szerkesztve.

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.

További információkért lásd: Webkiszolgáló-implementációk az ASP.NET Core keretrendszerben.

Konfiguráció

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ós 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 megvalósításához.

A bizalmas konfigurációs adatok, például jelszavak kezeléséhez a .NET Core biztosítja a Secret Manager. Gyártási titkok esetén az Azure Key Vaultjavasoljuk.

További információkért lásd az ASP.NET Core Konfiguráció című részét.

Környezetek

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:

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

További információért lásd: Több környezet használata ASP.NET Core.

Fakitermelés

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:

Konzol
Hibakeresés
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ási rendszerből (DI), és hívjon meg naplózási módszereket, például a LogInformation-et. Például:

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

Lásd még: Naplózás a .NET Core-ban és az ASP.NET Core-ban.

Útválasztás

A ASP.NET Core-webalkalmazás-sablon által létrehozott következő kód meghívja UseRouting:

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddRazorPages();

var app = builder.Build();

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

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

app.UseRouting();

app.UseAuthorization();

app.MapRazorPages();

app.Run();

További információért lásd: Útválasztás az ASP.NET Core-ban.

Hibakezelés

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

Fejlesztői kivételoldal
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ó ASP.NET Core bejövő köztes szoftverfolyamatához. 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 a Polly-vel, egy népszerű külső könyvtárral az átmeneti hibakezeléshez.
Kezeli az alapul szolgáló HttpClientHandler példányok készletezését és élettartamát, hogy elkerülje a HttpClient élettartam manuális kezelésekor előforduló gyakori DNS-problémákat.
Konfigurálható naplózási élményt biztosít a ILogger-on keresztül a factory által létrehozott ügyfelek által küldött összes kérés számára.

További információért lásd: HTTP-kérések végrehajtá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 webgyö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 lesz. Ez a könyvtár az alkalmazás tartalomfájljainak és a webes gyökérelérési útjának az alapja is. Adjon meg egy másik tartalomgyökeret az elérési út beállításával a gazdagépépítésekor. A további információkért lásd tartalomgyökér.

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útvonal alapértelmezés szerint {content root}/wwwroot. Adjon meg egy másik webgyökeret a gazdagép létrehozásakor aelérési út beállításával. További információ: webgyökér.

A wwwroot fájlok közzétételének megakadályozása a <Tartalom> projektelem a projektfájlban. Az alábbi példa megakadályozza a tartalmak közzétételét wwwroot/helyi és 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 tájékoztatásért lásd az alábbi oldalon: Statikus fájlok az ASP.NET Core-ban.

További erőforrások

WebApplicationBuilder forráskód

Megosztás a következőn keresztül:

ASP.NET Alapvető alapismeretek áttekintése

Program.cs

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

Köztes szoftver

Házigazda

Nem webes forgatókönyvek

Szerverek

Konfiguráció

Környezetek

Fakitermelés

Útválasztás

Hibakezelés

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

Tartalomgyökér

Webes gyökér

További erőforrások

Program.cs

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

Köztes szoftver

Házigazda

Nem webes forgatókönyvek

Szerverek

Konfiguráció

Környezetek

Fakitermelés

Útválasztás

Hibakezelés

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

Tartalomgyökér

Webhely gyökérkönyvtára

További erőforrások

A Startup osztály

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

Köztes szoftver

Házigazda

Nem webes helyzetek

Szerverek

Konfiguráció

Környezetek

Fakitermelés

Útválasztás

Hibakezelés

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

Tartalomgyökér

Webes gyökér

Program.cs

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

Köztes szoftver

Házigazda

Nem webes forgatókönyvek

Szerverek

Konfiguráció

Környezetek

Fakitermelés

Útválasztás

Hibakezelés

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

Tartalomgyökér

Webes gyökér

További erőforrások

További források