översikt över grunderna i ASP.NET Core

Den här artikeln innehåller en översikt över grunderna för att skapa ASP.NET Core-appar, inklusive beroendeinmatning (DI), konfiguration, mellanprogram med mera.

Vägledning för Blazor-grunder, som kompletterar eller ersätter vägledningen i den här artikeln, finns i ASP.NET Core-grunder Blazor.

Program.cs

ASP.NET Core-appar som skapats med webbmallarna innehåller programmets startkod i filen Program.cs. Filen Program.cs är där.

• Tjänster som krävs av appen konfigureras.
• Appens pipeline för hantering av begäranden definieras som en serie mellanprogramkomponenter.

Följande appstartkod stöder flera apptyper:

• Blazor Web Apps
• Razor sidor
• MVC-styrenheter med vyer
• webb-API med kontrollanter
• Minimala webb-API:er

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

Beroendeinmatning (tjänster)

ASP.NET Core har inbyggd beroendeinjektion (DI) som gör konfigurerade tjänster tillgängliga överallt i en app. Tjänster läggs till i DI-containern med WebApplicationBuilder.Services, builder.Services i föregående kod. När WebApplicationBuilder instansieras läggs många ramverkstjänster till automatiskt. builder är en WebApplicationBuilder i följande kod:

var builder = WebApplication.CreateBuilder(args);

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

var app = builder.Build();

I föregående kod lägger CreateBuilder till konfiguration, loggning och många andra tjänster till DI-containern. DI-ramverket tillhandahåller en instans av en begärd tjänst vid körningstid.

Följande kod lägger till en anpassad DbContext- och Blazor-komponenter i DI-containern:

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

Under Blazor Web Apps löses tjänster ofta med DI vid körning genom att använda direktivet @inject i en Razor-komponent, som visas i följande exempel.

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

I föregående kod:

• Direktivet @inject används.
• Tjänsten löses i OnInitialized-metoden och tilldelas till variabeln context.
• context-tjänsten skapar FilteredMovie-listan.

Ett annat sätt att lösa en tjänst från DI är att använda konstruktorinmatning. Följande Razor Pages-kod använder konstruktorinmatning för att lösa databaskontexten och en loggare från DI:

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

I föregående kod tar konstruktorn IndexModel en parameter av typen RazorPagesMovieContext, som löses vid körning till variabeln _context. Kontextobjektet används för att skapa en lista över filmer i metoden OnGetAsync.

Mer information finns i ASP.NET Core Blazor beroendeinmatning och Beroendeinmatning i ASP.NET Core.

Mellanprogram

Pipelinen för hantering av begäranden består av en serie mellanprogramskomponenter. Varje komponent utför åtgärder på en HttpContext och anropar antingen nästa mellanprogram i pipelinen eller avslutar begäran.

Enligt konventionen läggs en mellanprogramskomponent till i pipelinen genom att en Use{Feature} tilläggsmetod anropas. Användningen av metoder med namnet Use{Feature} för att lägga till mellanprogram i en app visas i följande kod:

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

Mer information finns i ASP.NET Core Middleware.

Värd

När en ASP.NET Core-app startar bygger den en värd. Värden kapslar in alla appens resurser, till exempel:

• En HTTP-serverimplementering
• Mellanprogramskomponenter
• Skogsavverkning
• Tjänster för beroendeinjektion
• Konfiguration

Det finns tre olika värdar som kan köra en ASP.NET Core-app:

• ASP.NET Core WebApplication, även kallat minimal värd
• .NET Generic Host i kombination med ASP.NET Cores ConfigureWebHostDefaults
• ASP.NET Core WebHost

Typerna ASP.NET Core WebApplication och WebApplicationBuilder rekommenderas och används i alla ASP.NET Core-mallar. WebApplication fungerar på samma sätt som generiska .NET-värden och exponerar många av gränssnitten, men kräver färre återanrop för att konfigurera. ASP.NET Core WebHost är endast tillgänglig för bakåtkompatibilitet.

Följande exempel instansierar en WebApplication och tilldelar den till en variabel med namnet app:

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

Metoden WebApplicationBuilder.Build konfigurerar en värd med en uppsättning standardalternativ, till exempel:

• Använd Kestrel som webbserver och aktivera IIS-integrering.
• Läs in konfiguration från appsettings.json, miljövariabler, kommandoradsargument och andra konfigurationskällor.
• Skicka loggutdata till konsolen och debuggproviders.

Scenarier som inte är webb

Med den generiska värden kan andra typer av appar använda övergripande ramverkstillägg, till exempel loggning, beroendeinmatning (DI), konfiguration och hantering av appens livslängd. För mer information, se .NET Generisk Värd i ASP.NET Core och Backgrundsuppgifter med värdtjänster i ASP.NET Core.

Servrar

En ASP.NET Core-app använder en HTTP-serverimplementering för att lyssna efter HTTP-begäranden. Servern visar begäranden till appen som en uppsättning begärandefunktioner sammansatta i en HttpContext.

Mer information finns i webbserverimplementeringar i ASP.NET Core.

Konfiguration

ASP.NET Core tillhandahåller ett konfigurationsramverk som hämtar inställningar som namn/värde-par från en ordnad uppsättning konfigurationsproviders. Inbyggda konfigurationsprovidrar är tillgängliga för en mängd olika källor, till exempel .json filer, .xml filer, miljövariabler och kommandoradsargument. Skriv anpassade konfigurationsprovidrar för att stödja andra källor.

Som standardär ASP.NET Core-appar konfigurerade för att läsa från appsettings.json, miljövariabler, kommandoraden med mera. När appens konfiguration läses in åsidosätter värden från miljövariabler värden från appsettings.json.

För att hantera konfidentiella konfigurationsdata, till exempel lösenord i utvecklingsmiljön, tillhandahåller .NET Core Secret Manager-. För produktionshemligheter rekommenderar vi Azure Key Vault-.

Mer information finns i Configuration i ASP.NET Core.

Miljöer

Exekveringsmiljöer, till exempel Development, Stagingoch Production, är tillgängliga i ASP.NET Core. Ange den miljö som en app körs i genom att ange ASPNETCORE_ENVIRONMENT miljövariabeln. ASP.NET Core läser miljövariabeln vid appstart och lagrar värdet i en IWebHostEnvironment implementering. Den här implementeringen är tillgänglig var som helst i en app via beroendeinmatning (DI).

I följande exempel konfigureras undantagshanteraren och HTTP Strict Transport Security Protocol (HSTS) mellanprogram när inte körs i Development miljö:

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

Mer information finns i Använda flera miljöer i ASP.NET Core.

Skogsavverkning

ASP.NET Core stöder ett loggnings-API som fungerar med en mängd olika inbyggda och tredje parts loggningsproviders. Tillgängliga leverantörer är:

• Konsol
• Felsöka
• Händelsespårning i Windows
• Windows-händelselogg
• TraceSource
• Azure App Service
• Azure Application Insights

Om du vill skapa loggar löser du en ILogger<TCategoryName>-tjänst från beroendeinmatning (DI) och anropar loggningsmetoder som LogInformation. I följande exempel visas hur du hämtar och använder en loggare i en .razor fil för en sida i en Blazor Web App. Ett loggningsobjekt och en konsolprovider för det lagras automatiskt i DI-containern när CreateBuilder-metoden anropas i Program.cs.

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

Mer information finns i Loggning i .NET Core och ASP.NET Core.

Routning

Routning i ASP.NET Core är en mekanism som mappar inkommande begäranden till specifika slutpunkter i ett program. Det gör att du kan definiera URL-mönster som motsvarar olika komponenter, till exempel Blazor komponenter, Razor sidor, MVC-kontrollantåtgärder eller mellanprogram.

Metoden UseRouting(IApplicationBuilder) lägger till mellanprogram för routning i begärandepipelinen. Det här mellanprogrammet bearbetar routningsinformationen och avgör lämplig slutpunkt för varje begäran. Du behöver inte uttryckligen anropa UseRouting om du inte vill ändra i vilken ordning mellanprogrammet bearbetas.

För mer information, se Routing i ASP.NET Core och ASP.NET Core Blazor routing och navigering.

Felhantering

ASP.NET Core har inbyggda funktioner för att hantera fel, till exempel:

• En undantagssida för utvecklare
• Anpassade felsidor
• Statiska statuskodsidor
• Undantagshantering vid start

Mer information finns i Hantera fel i ASP.NET Core.

Att göra HTTP-förfrågningar

En implementering av IHttpClientFactory är tillgänglig för att skapa HttpClient instanser. Fabriken:

• Tillhandahåller en central plats för att namnge och konfigurera logiska HttpClient instanser. Du kan till exempel registrera och konfigurera en github--klient för åtkomst till GitHub. Registrera och konfigurera en standardklient för andra ändamål.
• Stöder registrering och länkning av flera delegerande hanterare för att skapa en pipeline för mellanprogram för utgående begäran. Det här mönstret liknar ASP.NET Cores inkommande mellanprogramspipeline. Mönstret ger en mekanism för att hantera övergripande problem för HTTP-begäranden, inklusive cachelagring, felhantering, serialisering och loggning.
• Integrerar med Polly, ett populärt bibliotek från tredje part för tillfällig felhantering.
• Hanterar pooler och livslängden för underliggande HttpClientHandler instanser för att undvika vanliga DNS-problem som uppstår vid hantering av HttpClient livslängd manuellt.
• Lägger till en konfigurerbar loggningsupplevelse via ILogger för alla begäranden som skickas via klienter som skapats av fabriken.

Mer information finns i Gör HTTP-begäranden med IHttpClientFactory i ASP.NET Core.

Innehållsrot

Innehållsroten är bassökvägen för:

• Det körbara programmet som kör appen (.exe).
• Kompilerade sammansättningar som utgör appen (.dll).
• Innehållsfiler som används av appen, till exempel:
  • Razor filer (.cshtml, .razor)
  • Konfigurationsfiler (.json, .xml)
  • Datafiler (.db)
• Den webbroten, vanligtvis mappen wwwroot.

Under utvecklingen är innehållsroten som standard i projektets rotkatalog. Den här katalogen är också bassökvägen för både appens innehållsfiler och webbroten. Ange en annan innehållsrot genom att ange sökvägen när att skapa värden. Mer information finns i Innehållsrot.

Webbrotsplats

Webbroten är bassökvägen för offentliga, statiska resursfiler, till exempel:

• Formatmallar (.css)
• JavaScript (.js)
• Bilder (.png, .jpg)

Som standard hanteras statiska filer endast från webbrotkatalogen och dess underkataloger. Webbrotsökvägen är som standard {content root}/wwwroot. Ange en annan webbroten genom att ange dess sökväg när du bygger värden . Mer information finns i Web Root.

Förhindra publicering av filer i wwwroot- med projektobjektet <Innehåll> i projektfilen. I följande exempel förhindras publicering av innehåll i wwwroot/lokal och dess underkataloger:

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

I filer märkta Razor.cshtml pekar ~/ på webbrooten. En sökväg som börjar med ~/ kallas för en virtuell sökväg.

För mer information, se statiska filer i ASP.NET Core.

Ytterligare resurser

• grunderna i ASP.NET Core Blazor

Den här artikeln innehåller en översikt över grunderna för att skapa ASP.NET Core-appar, inklusive beroendeinmatning (DI), konfiguration, mellanprogram med mera.

Program.cs

ASP.NET Core-appar som skapats med webbmallarna innehåller programmets startkod i filen Program.cs. Den Program.cs filen är där:

• Tjänster som krävs av appen konfigureras.
• Appens pipeline för hantering av begäranden definieras som en serie mellanprogramkomponenter.

Följande appstartkod stöder:

• Razor sidor
• MVC-styrenheter med vyer
• webb-API med kontrollanter
• Minimala webb-API:er

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

Beroendeinjektion (tjänster)

ASP.NET Core innehåller beroendeinjektion (DI) som gör konfigurerade tjänster tillgängliga genom en app. Tjänster läggs till i DI-containern med WebApplicationBuilder.Services, builder.Services i föregående kod. När WebApplicationBuilder instansieras läggs många ramverkstjänster till. builder är en WebApplicationBuilder i följande kod:

var builder = WebApplication.CreateBuilder(args);

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

var app = builder.Build();

I den markerade koden ovan har builder konfiguration, loggning och många andra tjänster lagts till i DI-containern.

Följande kod lägger till Razor Pages, MVC-styrenheter med vyer och en anpassad DbContext till DI-containern:

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

Tjänster löses vanligtvis från DI med konstruktorinmatning. DI-ramverket tillhandahåller en instans av den här tjänsten under körning.

I följande kod används konstruktorinmatning för att lösa databaskontexten och loggaren från DI:

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

Mellanprogram

Pipelinen för hantering av begäranden består av en serie mellanprogramskomponenter. Varje komponent utför åtgärder på en HttpContext och anropar antingen nästa mellanprogram i pipelinen eller avslutar begäran.

Enligt konventionen läggs en mellanprogramskomponent till i pipelinen genom att en Use{Feature} tilläggsmetod anropas. Mellanprogram som läggs till i appen är markerat i följande kod:

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

Mer information finns i ASP.NET Core Middleware.

Värd

Vid start av en ASP.NET Core-app skapas en värd. Värden kapslar in alla appens resurser, till exempel:

• En HTTP-server-implementering
• Mellanprogramskomponenter
• Skogsavverkning
• Dependency Injection (DI)-tjänster (beroendeinjektion)
• Konfiguration

Det finns tre olika värdar som kan köra en ASP.NET Core-app:

• ASP.NET Core WebApplication, även kallad Minimal Host
• .NET Generic Host kombineras med ASP.NET Cores ConfigureWebHostDefaults
• ASP.NET Core WebHost

Typerna ASP.NET Core WebApplication och WebApplicationBuilder rekommenderas och används i alla ASP.NET Core-mallar. WebApplication fungerar på samma sätt som .NET Generic Hosten och exponerar många av samma gränssnitt, men kräver färre callback-funktioner för att konfigurera. ASP.NET Core WebHost är endast tillgänglig för bakåtkompatibilitet.

I följande exempel instansieras en WebApplication:

var builder = WebApplication.CreateBuilder(args);

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

var app = builder.Build();

Metoden WebApplicationBuilder.Build konfigurerar en värd med en uppsättning standardalternativ, till exempel:

• Använd Kestrel som webbserver och aktivera IIS-integrering.
• Läs in konfiguration från appsettings.json, miljövariabler, kommandoradsargument och andra konfigurationskällor.
• Skicka loggningsutdata till konsolen och felsökningsleverantörer.

Scenarier som inte är webb

Med den generiska värden kan andra typer av appar använda övergripande ramverkstillägg, till exempel loggning, beroendeinmatning (DI), konfiguration och hantering av appens livslängd. Mer information finns i .NET Generic Host i ASP.NET Core och Bakgrundsuppgifter med värdtjänster i ASP.NET Core.

Servrar

En ASP.NET Core-app använder en HTTP-serverimplementering för att lyssna efter HTTP-begäranden. Servern presenterar begäranden till appen som en uppsättning frågeattribut sammansatta i en HttpContext.

Mer information finns i webbserverimplementeringar i ASP.NET Core.

Konfiguration

ASP.NET Core tillhandahåller ett konfigurationsramverk som hämtar inställningar som namn/värde-par från en ordnad uppsättning konfigurationsproviders. Inbyggda konfigurationsprovidrar är tillgängliga för en mängd olika källor, till exempel .json filer, .xml filer, miljövariabler och kommandoradsargument. Skriv anpassade konfigurationsleverantörer för att stödja andra källor.

Som standardär ASP.NET Core-appar konfigurerade för att läsa från appsettings.json, miljövariabler, kommandoraden med mera. När appens konfiguration läses in åsidosätter värden från miljövariabler värden från appsettings.json.

För att hantera konfidentiella konfigurationsdata, till exempel lösenord, tillhandahåller .NET Core Secret Manager-. För produktionshemligheter rekommenderar vi Azure Key Vault-.

Mer information finns i Configuration i ASP.NET Core.

Miljöer

Körningsmiljöer, till exempel Development, Staging, och Production, är tillgängliga i ASP.NET Core. Ange den miljö som en app körs i genom att ange ASPNETCORE_ENVIRONMENT miljövariabeln. ASP.NET Core läser miljövariabeln vid appstart och lagrar värdet i en IWebHostEnvironment implementering. Den här implementeringen är tillgänglig var som helst i en app via beroendeinmatning (DI).

I följande exempel konfigureras undantagshanteraren och HTTP Strict Transport Security Protocol (HSTS) mellanprogram när inte körs i Development miljö:

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

Mer information finns i Använda flera miljöer i ASP.NET Core.

Skogsavverkning

ASP.NET Core stöder ett loggnings-API som fungerar med en mängd olika inbyggda och tredje parts loggningsproviders. Tillgängliga leverantörer är:

• Konsol
• Felsöka
• Händelsespårning i Windows
• Windows-händelselogg
• TraceSource
• Azure App Service
• Azure Application Insights

Om du vill skapa loggar löser du en ILogger<TCategoryName>-tjänst från beroendeinmatning (DI) och anropar loggningsmetoder som LogInformation. Till exempel:

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

Mer information finns i Loggning i .NET Core och ASP.NET Core.

Routning

En rutt är en URL-mall som mappas till en hanterare. Hanteraren är vanligtvis en Razor sida, en åtgärdsmetod i en MVC-styrenhet eller ett mellanprogram. ASP.NET Core-routning ger dig kontroll över de URL:er som används av din app.

Följande kod, som genereras av webbprogrammallen ASP.NET Core, anropar 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();

Mer information finns i Routning i ASP.NET Core.

Felhantering

ASP.NET Core har inbyggda funktioner för att hantera fel, till exempel:

• En undantagssida för utvecklare
• anpassade felsidor
• Statiska statuskodsidor
• Undantagshantering vid start

Mer information finns i Hantera fel i ASP.NET Core.

Att göra HTTP-begäranden

En implementering av IHttpClientFactory är tillgänglig för att skapa HttpClient instanser. Fabriken:

• Tillhandahåller en central plats för att namnge och konfigurera logiska HttpClient instanser. Du kan till exempel registrera och konfigurera en github--klient för åtkomst till GitHub. Registrera och konfigurera en standardklient för andra ändamål.
• Stöder registrering och länkning av flera delegerande hanterare för att skapa en pipeline för mellanprogram för utgående begäran. Det här mönstret liknar ASP.NET Cores inkommande mellanprogramspipeline. Mönstret ger en mekanism för att hantera övergripande problem för HTTP-begäranden, inklusive cachelagring, felhantering, serialisering och loggning.
• Integrerar med Polly, ett populärt bibliotek från tredje part för tillfällig felhantering.
• Hanterar pooler och livslängden för underliggande HttpClientHandler instanser för att undvika vanliga DNS-problem som uppstår vid hantering av HttpClient livslängd manuellt.
• Lägger till en konfigurerbar loggningsupplevelse via ILogger för alla begäranden som skickas via klienter som skapats av fabriken.

Mer information finns i Gör HTTP-begäranden med IHttpClientFactory i ASP.NET Core.

Innehållsrot

Innehållsroten är bassökvägen för:

• Den exekverbara filen som är värd för appen (.exe).
• Kompilerade sammansättningar som utgör appen (.dll).
• Innehållsfiler som används av appen, till exempel:
  • Razor filer (.cshtml, .razor)
  • Konfigurationsfiler (.json, .xml)
  • Datafiler (.db)
• Den webroot, vanligtvis mappen wwwroot.

Under utvecklingen används projektets rotkatalog som innehållsrot som standard. Den här katalogen är också basvägen för både appens innehållsfiler och webbroten. Ange en annan innehållsrot genom att ange sökvägen när att skapa värden. Mer information finns i Innehållsrot.

Webbrotsmapp

Webbroten är bassökvägen för offentliga, statiska resursfiler, till exempel:

• Formatmallar (.css)
• JavaScript (.js)
• Bilder (.png, .jpg)

Som standard hanteras statiska filer endast från webbrotkatalogen och dess underkataloger. Standardvägen till webbrot är {content root}/wwwroot. Ange en alternativ rot för webbplatser genom att ange sökvägen när bygger värden. Mer information finns i Web Root.

Förhindra publicering av filer i wwwroot- med projektobjektet <Innehåll> i projektfilen. I följande exempel förhindras publicering av innehåll i wwwroot/lokal och dess underkataloger:

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

I Razor.cshtml-filer pekar ~/ på webbroten. En sökväg som börjar med ~/ kallas för en virtuell sökväg.

För mer information, se Statiska filer i ASP.NET Core.

Ytterligare resurser

• WebApplicationBuilder-källkod

Den här artikeln innehåller en översikt över grunderna för att skapa ASP.NET Core-appar, inklusive beroendeinmatning (DI), konfiguration, mellanprogram med mera.

Startklassen

Klassen Startup är där:

• Tjänster som krävs av appen konfigureras.
• Appens pipeline för hantering av begäranden definieras som en serie mellanprogramkomponenter.

Här är ett exempel på en Startup-klass:

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

För mer information, se start av app i ASP.NET Core.

Beroendeinjektion (tjänster)

ASP.NET Core innehåller ett inbyggt di-ramverk (dependency injection) som gör konfigurerade tjänster tillgängliga i en app. En loggningskomponent är till exempel en tjänst.

Kod för att konfigurera (eller registrera) tjänster läggs till i metoden Startup.ConfigureServices. Till exempel:

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

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

Tjänster löses vanligtvis från DI med konstruktorinmatning. Med konstruktorinmatning deklarerar en klass en konstruktorparameter av antingen den typ som krävs eller ett gränssnitt. DI-ramverket tillhandahåller en instans av den här tjänsten vid körning.

I följande exempel används konstruktorinmatning för att lösa en RazorPagesMovieContext från DI:

public class IndexModel : PageModel
{
    private readonly RazorPagesMovieContext _context;

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

    // ...

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

Om den inbyggda IoC-containern (Inversion of Control) inte uppfyller alla appbehov kan en IoC-container från tredje part användas i stället.

Mer information finns i Beroendeinmatning i ASP.NET Core.

Middleware

Pipelinen för hantering av begäranden består av en serie mellanprogramskomponenter. Varje komponent utför åtgärder på en HttpContext och anropar antingen nästa mellanprogram i pipelinen eller avslutar begäran.

Enligt konventionen läggs en mellanprogramskomponent till i pipelinen genom att en Use... tilläggsmetod anropas i metoden Startup.Configure. Om du till exempel vill aktivera återgivning av statiska filer anropar du UseStaticFiles.

I följande exempel konfigureras en pipeline för hantering av begäranden:

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

    app.UseRouting();

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

ASP.NET Core innehåller en omfattande uppsättning inbyggda mellanprogram. Anpassade mellanprogramskomponenter kan också skrivas.

Mer information finns i ASP.NET Core Middleware.

Värd

Vid start skapar en ASP.NET Core-app en värd. Värden kapslar in alla appens resurser, till exempel:

• En HTTP-serverimplementering
• Mellanprogramskomponenter
• Skogsavverkning
• Di-tjänster (Dependency Injection)
• Konfiguration

Det finns två olika värdar:

• Generisk .NET-värd
• ASP.NET Core Web Host

Den generiska .NET-värden rekommenderas. ASP.NET Core Web Host är endast tillgänglig för bakåtkompatibilitet.

I följande exempel skapas en generisk .NET-värd:

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

Metoderna CreateDefaultBuilder och ConfigureWebHostDefaults konfigurerar en värd med en uppsättning standardalternativ, till exempel:

• Använd Kestrel som webbserver och aktivera IIS-integrering.
• Läs in konfiguration från appsettings.json, appsettings.{Environment}.json, miljövariabler, kommandoradsargument och andra konfigurationskällor.
• Skicka loggningsutdata till konsolen och felsökningsprovidrar.

Mer information finns i .NET Generic Host i ASP.NET Core.

Scenarier som inte är webb

Med den generiska värden kan andra typer av appar använda övergripande ramverkstillägg, till exempel loggning, beroendeinmatning (DI), konfiguration och hantering av appens livslängd. För mer information, se .NET Generic Host i ASP.NET Core och Bakgrundsuppgifter med värdbaserade tjänster i ASP.NET Core.

Servrar

En ASP.NET Core-app använder en HTTP-serverimplementering för att lyssna efter HTTP-begäranden. Servern visar begäranden till appen som en uppsättning begärandefunktioner sammansatta i en HttpContext.

Mer information finns i webbserverimplementeringar i ASP.NET Core.

Konfiguration

ASP.NET Core tillhandahåller ett konfigurationsramverk som hämtar inställningar som namn/värde-par från en ordnad uppsättning konfigurationsproviders. Inbyggda konfigurationsprovidrar är tillgängliga för en mängd olika källor, till exempel .json filer, .xml filer, miljövariabler och kommandoradsargument. Skriv anpassade konfigureringsleverantörer för att stödja andra källor.

Som standardär ASP.NET Core-appar konfigurerade för att läsa från appsettings.json, miljövariabler, kommandoraden med mera. När appens konfiguration läses in åsidosätter värden från miljövariabler värden från appsettings.json.

Det bästa sättet att läsa relaterade konfigurationsvärden är att använda mönstret alternativ. Mer information finns i Bind hierarkiska konfigurationsdata med hjälp av alternativmönstret.

För att hantera konfidentiella konfigurationsdata, till exempel lösenord, tillhandahåller .NET Core Secret Manager-. För produktionshemligheter rekommenderar vi Azure Key Vault-.

Mer information finns i Configuration i ASP.NET Core.

Miljöer

Körningsmiljöer, till exempel Development, Stagingoch Production, är ett förstklassigt begrepp i ASP.NET Core. Ange den miljö som en app körs i genom att ange ASPNETCORE_ENVIRONMENT miljövariabeln. ASP.NET Core läser miljövariabeln vid appstart och lagrar värdet i en IWebHostEnvironment implementering. Den här implementeringen är tillgänglig var som helst i en app via beroendeinmatning (DI).

I följande exempel konfigureras appen för att tillhandahålla detaljerad felinformation när den körs i Development-miljön:

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

Mer information finns i Använda flera miljöer i ASP.NET Core.

Skogsavverkning

ASP.NET Core stöder ett loggnings-API som fungerar med en mängd olika inbyggda och tredje parts loggningsproviders. Tillgängliga leverantörer är:

• Konsol
• Felsöka
• Händelsespårning i Windows
• Windows-händelselogg
• TraceSource
• Azure App Service
• Azure Application Insights

Skapa loggar genom att lösa en ILogger<TCategoryName>-tjänst via dependency injection (DI) och anropa loggningsmetoder som LogInformation. Till exempel:

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

Loggningsmetoder som LogInformation stöder valfritt antal fält. Dessa fält används ofta för att skapa ett meddelande string, men vissa loggningsproviders skickar dessa till ett datalager som separata fält. Den här funktionen gör det möjligt för loggningsleverantörer att implementera semantisk loggning, även kallat strukturerad loggning.

Mer information finns i Loggning i .NET Core och ASP.NET Core.

Routning

En rutt är en URL-struktur som kopplas till en hanterare. Hanteraren är vanligtvis en Razor sida, en åtgärdsmetod i en MVC-styrenhet eller ett mellanprogram. ASP.NET Core-routning ger dig kontroll över de URL:er som används av din app.

För mer information, se Routing i ASP.NET Core.

Felhantering

ASP.NET Core har inbyggda funktioner för att hantera fel, till exempel:

• En undantagssida för utvecklare
• Anpassade felsidor
• Statiska statuskodsidor
• Undantagshantering vid start

Mer information finns i Hantera fel i ASP.NET Core.

Skicka HTTP-begäranden

En implementering av IHttpClientFactory är tillgänglig för att skapa HttpClient instanser. Fabriken:

• Tillhandahåller en central plats för att namnge och konfigurera logiska HttpClient instanser. Du kan till exempel registrera och konfigurera en github--klient för åtkomst till GitHub. Registrera och konfigurera en standardklient för andra ändamål.
• Stödjer registrering och sammankoppling av flera delegerande hanterare för att bygga en middleware-pipeline för utgående begäran. Det här mönstret liknar ASP.NET Cores inkommande mellanprogramspipeline. Mönstret ger en mekanism för att hantera övergripande problem för HTTP-begäranden, inklusive cachelagring, felhantering, serialisering och loggning.
• Integrerar med Polly, ett populärt bibliotek från tredje part för tillfällig felhantering.
• Hanterar pooler och livslängden för underliggande HttpClientHandler instanser för att undvika vanliga DNS-problem som uppstår vid hantering av HttpClient livslängd manuellt.
• Lägger till en konfigurerbar loggningsupplevelse via ILogger för alla begäranden som skickas via klienter som skapats av fabriken.

Mer information finns i Gör HTTP-begäranden med IHttpClientFactory i ASP.NET Core.

Innehållsrot

Innehållsroten är bassökvägen för:

• Den körbara filen som är värd för appen (.exe).
• Kompilerade sammansättningar som utgör appen (.dll).
• Innehållsfiler som används av appen, till exempel:
  • Razor filer (.cshtmloch .razor)
  • Konfigurationsfiler (.json, .xml)
  • Datafiler (.db)
• Den webbroten, vanligtvis mappen wwwroot.

Under utvecklingen ställs innehållsroten in som standard till projektets rotkatalog. Den här katalogen är också basvägen för både appens innehållsfiler och webbroten. Ange en annan innehållsrot genom att ange sökvägen när att skapa värden. Mer information finns i Innehållsrot.

Webbrot

Webbroten är bassökvägen för offentliga, statiska resursfiler, till exempel:

• Formatmallar (.css)
• JavaScript (.js)
• Bilder (.png, .jpg)

Som standard hanteras statiska filer endast från webbrotkatalogen och dess underkataloger. Sökvägen till webbplatsens rot mapp är som standard {content root}/wwwroot. Ange en annan webbrot genom att ange sökvägen när att skapa värden. Mer information finns i Web Root.

Förhindra publicering av filer i wwwroot- med projektobjektet <Innehåll> i projektfilen. I följande exempel förhindras publicering av innehåll i wwwroot/lokal och dess underkataloger:

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

I Razor.cshtml filer pekar tilde-slash (~/) till webbrooten. En sökväg som börjar med ~/ kallas för en virtuell sökväg.

Mer information finns i Statiska filer i ASP.NET Core.

Den här artikeln innehåller en översikt över grunderna för att skapa ASP.NET Core-appar, inklusive beroendeinmatning (DI), konfiguration, mellanprogram med mera.

Vägledning för Blazor grunder, som kompletterar eller ersätter vägledningen i den här noden, finns i ASP.NET Core Blazor Core-grunder.

Program.cs

ASP.NET Core-appar som skapats med webbmallarna innehåller programmets startkod i filen Program.cs. Filen Program.cs är där programmet sparar data.

• Tjänster som krävs av appen konfigureras.
• Appens pipeline för hantering av förfrågningar definieras som en serie mellanprogramkomponenter.

Följande appstartkod stöder:

• Razor sidor
• MVC-styrenheter med vyer
• webb-API med kontrollanter
• Minimala webb-API:er

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

Beroendeinmatning (tjänster)

ASP.NET Core innehåller beroendeinjektion (DI) som gör konfigurerade tjänster tillgängliga genom hela appen. Tjänster läggs till i DI-containern med WebApplicationBuilder.Services, builder.Services i föregående kod. När WebApplicationBuilder instansieras läggs ett flertal tjänster från -ramverket till. builder är en WebApplicationBuilder i följande kod:

var builder = WebApplication.CreateBuilder(args);

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

var app = builder.Build();

I föregående markerade kod har builder konfiguration, loggning och många andra tjänster lagts till i DI-containern.

Följande kod lägger till Razor Pages, MVC-styrenheter med vyer och en anpassad DbContext till DI-containern:

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

Tjänster löses vanligtvis från DI med konstruktorinmatning. DI-ramverket tillhandahåller en instans av den här tjänsten vid körning.

I följande kod används konstruktorinmatning för att lösa databaskontexten och loggaren från DI:

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

Mellanprogramvara

Pipelinen för hantering av begäranden består av en serie mellanprogramskomponenter. Varje komponent utför åtgärder på en HttpContext och anropar antingen nästa mellanprogram i pipelinen eller avslutar begäran.

Enligt konventionen läggs en mellanprogramskomponent till i pipelinen genom att en Use{Feature} tilläggsmetod anropas. Mellanprogram som läggs till i appen är markerat i följande kod:

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

Mer information finns i ASP.NET Core Middleware.

Värd

Vid start skapar en ASP.NET Core-app en värd. Värden kapslar in alla appens resurser, till exempel:

• En HTTP-serverimplementering
• Mellanprogramskomponenter
• Skogsavverkning
• Tjänster för beroendeinjektion
• Konfiguration

Det finns tre olika värdar som kan köra en ASP.NET Core-app:

• ASP.NET Core WebApplication, även kallat minimal värd
• .NET Generic Host kombinerat med ASP.NET Cores ConfigureWebHostDefaults
• ASP.NET Core WebHost

Typerna ASP.NET Core WebApplication och WebApplicationBuilder rekommenderas och används i alla ASP.NET Core-mallar. WebApplication fungerar liknande generiska värden i .NET och tillhandahåller många av de samma gränssnitten, men kräver färre återanrop för att konfigurera. ASP.NET Core WebHost är endast tillgänglig för bakåtkompatibilitet.

I följande exempel instansieras en WebApplication:

var builder = WebApplication.CreateBuilder(args);

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

var app = builder.Build();

Metoden WebApplicationBuilder.Build konfigurerar en värd med en uppsättning standardalternativ, till exempel:

• Använd Kestrel som webbserver och aktivera IIS-integrering.
• Läs in -konfiguration från appsettings.json, miljövariabler, kommandoradsargument och andra konfigurationskällor.
• Skicka loggningsutdata till konsolen och felsökningsleverantörer.

Scenarier som inte är webb

Den generiska värden tillåter att andra typer av appar använder övergripande ramverkstillägg, såsom loggning, beroendeinjektion (DI), konfiguration och hantering av appens livslängd. Mer information finns i .NET Generic Host in ASP.NET Core och Background tasks with hosted services in ASP.NET Core.

Servrar

En ASP.NET Core-app använder en HTTP-serverimplementering för att lyssna efter HTTP-begäranden. Servern visar begäranden till appen som en uppsättning begärandefunktioner sammansatta i en HttpContext.

Mer information finns i webbserverimplementeringar i ASP.NET Core.

Konfiguration

ASP.NET Core tillhandahåller ett konfigurationsramverk som hämtar inställningar som namn/värde-par från en ordnad uppsättning konfigurationsproviders. Inbyggda konfigurationsprovidrar är tillgängliga för en mängd olika källor, till exempel .json filer, .xml filer, miljövariabler och kommandoradsargument. Skriv anpassade konfigurationsleverantörer för att stödja andra källor.

Som standardär ASP.NET Core-appar konfigurerade för att läsa från appsettings.json, miljövariabler, kommandoraden med mera. När appens konfiguration läses in åsidosätter värden från miljövariabler värden från appsettings.json.

För att hantera konfidentiella konfigurationsdata, till exempel lösenord, tillhandahåller .NET Core Secret Manager-. För produktionshemligheter rekommenderar vi Azure Key Vault-.

Mer information finns i Configuration i ASP.NET Core.

Miljöer

ASP.NET Core har körningsmiljöer som Development, Stagingoch Productiontillgängliga. Ange den miljö som en app körs i genom att ange ASPNETCORE_ENVIRONMENT miljövariabeln. ASP.NET Core läser miljövariabeln vid appstart och lagrar värdet i en IWebHostEnvironment implementering. Den här implementeringen är tillgänglig var som helst i en app via beroendeinmatning (DI).

I följande exempel konfigureras undantagshanteraren och HTTP Strict Transport Security Protocol (HSTS) mellanprogram när inte körs i Development miljö:

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

Mer information finns i Använda flera miljöer i ASP.NET Core.

Skogsavverkning

ASP.NET Core stöder ett loggnings-API som fungerar med en mängd olika inbyggda och tredje parts loggningsproviders. Tillgängliga leverantörer är:

• Konsol
• Felsöka
• Händelsespårning i Windows
• Windows-händelselogg
• TraceSource
• Azure App Service
• Azure Application Insights

För att skapa loggar löser du en ILogger<TCategoryName>-tjänst från dependency injection (DI) och anropar loggningsmetoder som LogInformation. Till exempel:

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

Mer information finns i Loggning i .NET Core och ASP.NET Core.

Routning

En rutt är ett URL-mönster som mappas till en hanterare. Hanteraren är vanligtvis en Razor sida, en åtgärdsmetod i en MVC-styrenhet eller ett mellanprogram. ASP.NET Core-routning ger dig kontroll över de URL:er som används av din app.

Följande kod, som genereras av webbprogrammallen ASP.NET Core, anropar 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();

Mer information finns i Routning i ASP.NET Core.

Felhantering

ASP.NET Core har inbyggda funktioner för att hantera fel, till exempel:

• En undantagssida för utvecklare
• Anpassade felsidor
• Statiska statuskodsidor
• Undantagshantering vid start

Mer information finns i Hantera fel i ASP.NET Core.

Utföra HTTP-förfrågningar

En implementering av IHttpClientFactory är tillgänglig för att skapa HttpClient instanser. Fabriken:

• Tillhandahåller en central plats för att namnge och konfigurera logiska HttpClient instanser. Du kan till exempel registrera och konfigurera en github--klient för åtkomst till GitHub. Registrera och konfigurera en standardklient för andra ändamål.
• Stöder registrering och länkning av flera delegerande hanterare för att skapa en middleware-pipeline för utgående förfrågningar. Det här mönstret liknar ASP.NET Cores inkommande mellanprogramspipeline. Mönstret ger en mekanism för att hantera övergripande problem för HTTP-begäranden, inklusive cachelagring, felhantering, serialisering och loggning.
• Integrerar med Polly, ett populärt bibliotek från tredje part för tillfällig felhantering.
• Hanterar pooler och livslängden för underliggande HttpClientHandler instanser för att undvika vanliga DNS-problem som uppstår vid hantering av HttpClient livslängd manuellt.
• Lägger till en konfigurerbar loggningsupplevelse via ILogger för alla begäranden som skickas via klienter som skapats av fabriken.

Mer information finns i Gör HTTP-begäranden med IHttpClientFactory i ASP.NET Core.

Innehållsrot

Innehållsroten är bassökvägen för:

• Den körbara filen som är värd för appen (.exe).
• Kompilerade sammansättningar som utgör appen (.dll).
• Innehållsfiler som används av appen, till exempel:
  • Razor filer (.cshtml, .razor)
  • Konfigurationsfiler (.json, .xml)
  • Datafiler (.db)
• Den webbroten, vanligtvis mappen wwwroot.

Under utvecklingsfasen är innehållsroten som standardinställning i projektets rotkatalog. Den här katalogen är också bassökvägen för både appens innehållsfiler och webbroten. Ange en annan innehållsrot genom att ange sökvägen när att skapa värden. Mer information finns i Innehållsrot.

Webbrootkatalog

Webbroten är bassökvägen för offentliga, statiska resursfiler, till exempel:

• Formatmallar (.css)
• JavaScript (.js)
• Bilder (.png, .jpg)

Som standard hanteras statiska filer endast från webbrotkatalogen och dess underkataloger. Webbrotsökvägen ställs in som standard till {content root}/wwwroot. Ange en annan webbroten genom att ange dess sökväg när du bygger värden. Mer information finns i Web Root.

Förhindra publicering av filer i wwwroot- med projektobjektet <Innehåll> i projektfilen. I följande exempel förhindras publicering av innehåll i wwwroot/lokal och dess underkataloger:

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

I Razor.cshtml filerna pekar ~/ till webbroten. En sökväg som börjar med ~/ kallas för en virtuell sökväg.

För mer information, se statiska filer i ASP.NET Core.

Ytterligare resurser

• WebApplicationBuilder-källkod