översikt över grunderna i ASP.NET Core

Note

Det här är inte den senaste versionen av den här artikeln. Den aktuella versionen finns i .NET 10-versionen av den här artikeln.

Warning

Den här versionen av ASP.NET Core stöds inte längre. Mer information finns i .NET och .NET Core Support Policy. Den aktuella versionen finns i .NET 10-versionen av den här artikeln.

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

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.

Filen `Program`

ASP.NET Core appar som skapats från ramverkets projektmallar innehåller startkod i Program filen (Program.cs). Filen Program ä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 två apptyper:

// Initialize a new instance of the WebApplicationBuilder class 
// with preconfigured defaults
var builder = WebApplication.CreateBuilder(args);

// Add services for Blazor (Razor components)
builder.Services.AddRazorComponents()
    .AddInteractiveServerComponents();

// Build the app
var app = builder.Build();

// Use exception-handling middleware and HSTS middleware
// when in the Development environment
if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Error");
    app.UseHsts();
}

app.UseStatusCodePagesWithReExecute("/not-found", createScopeForStatusCodePages: true);

// Use HTTPS redirection middleware to automatically
// redirect requests from HTTP to HTTPS
app.UseHttpsRedirection();

// Map static assets endpoints
app.MapStaticAssets();

// Map a Minimal API endpoint for requests to '/hi'
app.MapGet("/hi", () => "Hello!");

// Add endpoints for Blazor
app.MapRazorComponents<App>()
    .AddInteractiveServerRenderMode();

// Run the app
app.Run();

Note

Med ytterligare konfiguration i Program filen kan ASP.NET Core appar stödja Razor Pages, MVC och webb-API med kontrollanter.

Följande appstartkod stöder två apptyper:

// Initialize a new instance of the WebApplicationBuilder class 
// with preconfigured defaults
var builder = WebApplication.CreateBuilder(args);

// Add services for Blazor (Razor components)
builder.Services.AddRazorComponents()
    .AddInteractiveServerComponents();

// Build the app
var app = builder.Build();

// Use exception-handling middleware and HSTS middleware
// when in the Development environment
if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Error");
    app.UseHsts();
}

app.UseStatusCodePagesWithReExecute("/not-found", createScopeForStatusCodePages: true);

// Use HTTPS redirection middleware to automatically
// redirect requests from HTTP to HTTPS
app.UseHttpsRedirection();

// Add antiforgery middleware
app.UseAntiforgery();

// Map static assets endpoints
app.MapStaticAssets();

// Map a Minimal API endpoint for requests to '/hi'
app.MapGet("/hi", () => "Hello!");

// Add endpoints for Blazor
app.MapRazorComponents<App>()
    .AddInteractiveServerRenderMode();

// Run the app
app.Run();

Note

Med ytterligare konfiguration i Program filen kan ASP.NET Core appar stödja Razor Pages, MVC och webb-API med kontrollanter.

Följande appstartkod stöder flera apptyper:

// Initialize a new instance of the WebApplicationBuilder class 
// with preconfigured defaults
var builder = WebApplication.CreateBuilder(args);

// Add services for Blazor (Razor components), Razor Pages, and MVC
builder.Services.AddRazorComponents()
    .AddInteractiveServerComponents();
builder.Services.AddRazorPages();
builder.Services.AddControllersWithViews();

// Build the app
var app = builder.Build();

// Configure the HTTP request pipeline

// Use exception-handling middleware and HSTS middleware
// when in the Development environment
if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Error");
    app.UseHsts();
}

// Use HTTPS redirection middleware to automatically
// redirect requests from HTTP to HTTPS
app.UseHttpsRedirection();

// Use static files middleware to serve static assets
app.UseStaticFiles();

// Use authorization middleware
app.UseAuthorization();

// Add antiforgery middleware
app.UseAntiforgery();

// Map a Minimal API endpoint for requests to '/hi'
app.MapGet("/hi", () => "Hello!");

// Configures the standard conventional route for MVC
app.MapDefaultControllerRoute();

// Add endpoints for Razor Pages
app.MapRazorPages();

// Add endpoints for Blazor
app.MapRazorComponents<App>()
    .AddInteractiveServerRenderMode();

// Run the app
app.Run();

Följande appstartkod stöder:

// Initialize a new instance of the WebApplicationBuilder class 
// with preconfigured defaults
var builder = WebApplication.CreateBuilder(args);

// Add services for Razor Pages and MVC
builder.Services.AddRazorPages();
builder.Services.AddControllersWithViews();

// Build the app
var app = builder.Build();

// Configure the HTTP request pipeline

// Use exception-handling middleware and HSTS middleware
// when in the Development environment
if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Error");
    app.UseHsts();
}

// Use HTTPS redirection middleware to automatically
// redirect requests from HTTP to HTTPS
app.UseHttpsRedirection();

// Use static files middleware to serve static assets
app.UseStaticFiles();

// Use authorization middleware
app.UseAuthorization();

// Map a Minimal API endpoint for requests to '/hi'
app.MapGet("/hi", () => "Hello!");

// Configures the standard conventional route for MVC
app.MapDefaultControllerRoute();

// Add endpoints for Razor Pages
app.MapRazorPages();

// Run the app
app.Run();

Klassen `Startup`

Klassen Startup (Startup.cs) är där:

Tjänster som krävs av appen konfigureras i ConfigureServices -metoden.
Appens pipeline för hantering av begäranden definieras i Configure metoden som en serie mellanprogramkomponenter.

Följande appstartkod stöder:

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

Mer information finns i Appstart i ASP.NET Core och ASP.NET Core Blazor start.

Beroendeinmatning (tjänster)

ASP.NET Core har inbyggt stöd för beroendeinjektion (DI), vilket gör konfigurerade tjänster tillgängliga i hela appen för inversion av kontroll (IoC).

När WebApplicationBuilder instansieras genom att anropa WebApplication.CreateBuilder läggs tjänster som tillhandahålls av ramverket automatiskt till, som tjänster för konfiguration och loggning:

var builder = WebApplication.CreateBuilder(args);

Ytterligare tjänster läggs till i DI-containern med WebApplicationBuilder.Services. I följande exempel registreras Blazor tjänster:

builder.Services.AddRazorComponents()
    .AddInteractiveServerComponents();

builder.Services.AddServerSideBlazor();

DI-ramverket tillhandahåller instanser av de begärda tjänsterna under körning. I Blazor appar hämtas tjänster ofta från DI vid körning med hjälp av direktivet @inject i en Razor-komponentfil (.razor). I följande exempel använder komponenten abstraktionen NavigationManager för att hämta en instans av navigeringshanteraren, som används för att fråga och hantera URI-navigering, för att navigera användaren till en sida med produkter när /products knappen har valts:

@inject NavigationManager Navigation

<button @onclick="NavigateToProductList">
    Products
</button>

@code {
    private void NavigateToProductList()
    {
        Navigation.NavigateTo("/products");
    }
}

Ett annat sätt att lösa en tjänst från DI är att använda konstruktorinmatning. I följande exempel tar den primära konstruktorn (C# 12 eller senare) parametrar för typerna AppDbContext och ILogger<OrderProcessor> löser dem vid körning till context variablerna och logger (instanserna av databasen och loggningsabstraktionerna). Databaskontextinstansen används för att bearbeta alla beställningar där IsProcessed fältet finns false i databasen, och varje bearbetad order loggas som information med dess order-ID (OrderId) med hjälp av logger-instansen:

public class OrderProcessor(AppDbContext context, ILogger<OrderProcessor> logger)
{
    public async Task ProcessPendingOrdersAsync()
    {
        var orders = await context.Orders
            .Where(o => !o.IsProcessed)
            .ToListAsync();

        foreach (var order in orders)
        {
            order.IsProcessed = true;
            logger.LogInformation("Processed order ID {OrderId}.", order.Id);
        }

        await context.SaveChangesAsync();
    }
}

Du kan också mata in beroenden direkt i lambda-parametrarna för minimala API-slutpunkter . I följande exempel returneras en lista över att göra-objekt från /todos slutpunkten. En loggerinstans för ILogger<Program> loggar information, och databasinstansen för AppDbContext används för att hämta listan över att göra-poster från databasen till svaret:

app.MapGet("/todos", async (AppDbContext context, ILogger<Program> logger) =>
{
    logger.LogInformation("Fetching todos using inline handler injection.");
    var todos = await context.Todos.ToListAsync();

    return Results.Ok(todos);
});

När Host.CreateDefaultBuilder anropas i filen Program initieras automatiskt en ny instans av klassen HostBuilder med tjänster som tillhandahålls av ramverket, till exempel tjänster för konfiguration och loggning:

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

Ytterligare tjänster läggs till i DI-containerns tjänstsamling (IServiceCollection) i Startup.ConfigureServices metoden (Startup.cs). I följande exempel registreras MVC- och Razor Pages-tjänster:

public void ConfigureServices(IServiceCollection services)
{
    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 tjänsten vid körning.

Om den inbyggda DI-containern inte uppfyller dina behov kan en IoC-container från tredje part användas i stället.

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

Environments

Körningsmiljöer är tillgängliga i ASP.NET Core, till exempel:

Development: När appen är i lokal utveckling.
Staging: När appen förbereds för distribution.
Production: När liveappen körs för användare.

Ange vilken miljö en app körs i genom att ställa in miljövariabeln ASPNETCORE_ENVIRONMENT på den värd där appen körs. ASP.NET Core läser miljövariabeln vid appstart och lagrar värdet för att styra kodkörningen runt appen.

Utvecklarkod kan söka efter en viss miljö. I följande Program filexempel körs koden i körningsblocket bara när appen inte körs i Development miljön:

if (!app.Environment.IsDevelopment())
{
    ...
}

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

    ...
}

Mer information finns i ASP.NET Core körningsmiljöer och ASP.NET Core Blazor miljöer.

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 mellanprogramkomponenter till i pipelinen genom att en tilläggsmetod som börjar med "Useanropas". I följande exempel som representerar en del av en pipeline för bearbetning av förfrågningar anropas mellanprogram för undantagshantering (UseExceptionHandler), HSTS-protokoll (HTTP Strict Transport Security) (UseHsts) och HTTPS-omdirigering (UseHttpsRedirection). Två av mellanprogram utlöses endast när appen inte är under lokal utveckling i Development miljön, till exempel när appen mellanlagras för distribution ( Staging miljön) eller i produktion ( Production miljön):

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

app.UseHttpsRedirection();

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

app.UseHttpsRedirection();

ASP.NET Core innehåller en omfattande uppsättning inbyggda mellanprogram. Du kan också skapa anpassade mellanprogramskomponenter för att uppfylla en apps specifikationer för bearbetning av särskilda begäranden. Mer information finns i ASP.NET Core mellanprogram.

Host

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
Logging
Tjänster för beroendeinjektion
Configuration

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

ASP.NET Core WebApplication (även kallad minimal värdmodell)
.NET allmän värd
ASP.NET Core WebHost

Typerna WebApplication och WebApplicationBuilder rekommenderas och används i alla ASP.NET Core-projektmallar. 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);

...

var app = builder.Build();

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

Använda Kestrel som webbserver och aktivera IIS-integrering.
Läser in konfiguration från appinställningar (till exempel appsettings.json), miljövariabler, kommandoradsargument och andra konfigurationskällor.
Konfigurera loggning och styra loggningsutdata till konsolen och leverantörerna för felsökningsloggning.

Det finns två värdar:

Den generiska .NET-värden rekommenderas. ASP.NET Core Web Host är endast tillgänglig av bakåtkompatibilitetsskäl.

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

Använda Kestrel som webbserver och aktivera IIS-integrering.
Läser in konfiguration från appinställningar (till exempel appsettings.json), miljövariabler, kommandoradsargument och andra konfigurationskällor.
Konfigurera loggning och styra loggningsutdata till konsolen och leverantörerna för felsökningsloggning.

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

Mer information finns i följande resurser:

.NET allmän värd i ASP.NET Core (rekommenderas)
ASP.NET Core webbvärd (för bakåtkompatibilitet)

Scenarier som inte är webb

Generic Host gör det möjligt för andra typer av program att använda ramverksutökningar för tvärgående funktioner, till exempel loggning, beroendeinjektion (DI), konfiguration och hantering av programmets 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.

Servers

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.

Windows

ASP.NET Core tillhandahåller följande serverimplementeringar:

Kestrel är en plattformsoberoende webbserver. Kestrel körs ofta i en omvänd proxykonfiguration med hjälp av IIS-. I ASP.NET Core 2.0 eller senare kan Kestrel köras som en offentlig edge-server som exponeras direkt mot Internet.
IIS HTTP Server är en server för Windows som använder IIS. Med den här servern körs ASP.NET Core-appen och IIS i samma process.
HTTP.sys är en server för Windows som inte används med IIS.

macOS och Linux

ASP.NET Core tillhandahåller Kestrel plattformsoberoende serverimplementering. I ASP.NET Core 2.0 eller senare kan Kestrel köras som en offentlig edge-server som exponeras direkt mot Internet. Kestrel körs ofta i en omvänd proxykonfiguration med Nginx eller Apache.

Configuration

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 (.json), XML-filer (.xml), miljövariabler och kommandoradsargument. Du kan skapa anpassade konfigurationsleverantörer som stöder andra källor.

Som standard är ASP.NET Core appar konfigurerade för att läsa från appinställningarfiler (till exempel appsettings.json), miljövariabler och kommandoraden.

När appens konfiguration läses in åsidosätter värden från miljövariabler värden från appinställningars filer. Options API kan användas för att läsa relaterade konfigurationsvärden.

För att hantera konfidentiella konfigurationsdata, till exempel lösenord i Development miljön, tillhandahåller .NET Secret Manager. För produktionshemligheter rekommenderar vi att du använder Azure Key Vault.

Mer information finns i följande resurser:

Logging

ASP.NET Core stöder ett loggnings-API som fungerar med en mängd olika loggningsproviders:

Console
Debug
Händelsespårning i Windows
Windows-händelselogg
TraceSource
Azure App Service
Azure Application Insights
Tredjepartsleverantörer

Om du vill skapa loggar löser du en ILogger<TCategoryName> tjänst från beroendeinmatning (DI) och anropar loggningsmetoder, till exempel LogInformation. Ett loggerobjekt och en konsolprovider för loggningsobjektet lagras automatiskt i DI-containern när WebApplication.CreateBuilder metoden anropas.

I följande exempel visas hur du hämtar en loggningsinstans från DI och använder den i en Weather komponent (Weather.razor) i en Blazor app som rapporterar väderdata:

@inject ILogger<Weather> Logger

...

@code {
    protected override async Task OnInitializedAsync()
    {
        Logger.LogInformation("OnInitializedAsync method called!");

        ...
    }
}

Mer information, inklusive routningsvägledning för Razor sidor och MVC-appar, finns i Loggning i .NET och ASP.NET Core och ASP.NET Core Blazor loggning.

Routing

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

Metoden UseRouting 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. I appar som använder Minimal Host anropas UseRouting inte uttryckligen i utvecklarens kod, om du inte vill ändra bearbetningsordningen för middleware.

Mer information finns i följande resurser:

Hantering av fel

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 och Hantera fel i ASP.NET Core Blazor appar.

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 förlita dig på en standardklient för de flesta av appens databegäranden med ett webb-API och registrera en annan konfigurerad klient för åtkomst till GitHub.
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 HTTP-begäranden med IHttpClientFactory – ASP.NET Core och Anropa ett webb-API från en ASP.NET Core Blazor app.

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) och datafiler (.db).
webbroten, som vanligtvis är 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 dess sökväg när du skapar värden.

Mer information finns i .NET allmän värd i ASP.NET Core och Hantera statiska filer i ASP.NET Core appar.

Webbrot

Webbroten är bassökvägen för offentliga, statiska resursfiler, till exempel formatmallar, JavaScript-filer och bilder.

Som standard hanteras statiska filer endast från webbrotkatalogen och dess underkataloger. Webbrotsökvägen är som standard {CONTENT ROOT}/wwwroot, där platshållaren {CONTENT ROOT} är innehållsroten. Ange en annan webbroten genom att ange dess sökväg när du bygger värden . Du kan också förhindra att filer publiceras i wwwroot med <Content> projektobjektet i appens projektfil.

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.

Mer information finns i .NET allmän värd i ASP.NET Core och Hantera statiska filer i ASP.NET Core appar.

Så här laddar du ned ett exempel

Många av artiklarna och självstudierna innehåller länkar till exempelkod.

Ladda ner ASP.NET-kodförrådets zip-fil.
Packa upp AspNetCore.Docs-main.zip-filen.
Om du vill komma åt en artikels exempelapp på den uppackade lagringsplatsen använder du URL:en i artikelns exempellänk för att navigera till exempelmappen. Vanligtvis visas en artikels exempellänk överst i artikeln med länktexten Visa eller ladda ned exempelkod.

Om du vill hämta hem en enskild exempelapp och endast den senaste committen använder du git sparse-checkout.

I följande exempel för GitHub-lagringsplatsen för exempelBlazor anger kommandot git sparse-checkout set sökvägen till exempelmappen:

Ersätt platshållaren {VERSION FOLDER} med versionsmappen.
Ersätt platshållaren {SAMPLE FOLDER} med exempelmappen.

I ett kommandogränssnitt navigerar du till mappen där du vill klona exemplet. Kör följande kommandon i kommandoskalet genom att ange sökvägen till mappen version/sample till kommandot git sparse-checkout set:

git clone --depth 1 --filter=blob:none https://github.com/dotnet/blazor-samples.git --sparse
cd blazor-samples
git sparse-checkout init --cone
git sparse-checkout set {VERSION FOLDER}/{SAMPLE FOLDER}

Följande PowerShell-exempel hämtar exemplet 10.0 Blazor Web App och placerar det i användarens dokumentmapp med hjälp av PowerShells ~/documents sökväg för kommandot change directory (cd):

cd "~/documents"
git clone --depth 1 --filter=blob:none https://github.com/dotnet/blazor-samples.git --sparse
cd blazor-samples
git sparse-checkout init --cone
git sparse-checkout set 10.0/BlazorSample_BlazorWebApp

Förprocessordirektiv i exempelkod

För att demonstrera flera scenarier använder exempelappar direktiven #define och #if-#else/#elif-#endif förprocessor för att selektivt kompilera och köra olika delar av exempelkoden. För de exempel som använder den här metoden anger du #define-direktivet överst i C#-filerna för att definiera symbolen som är associerad med det scenario som du vill köra. Vissa exempel kräver att du definierar symbolen överst i flera filer för att kunna köra ett scenario.

Följande #define symbollista anger till exempel att fyra scenarier är tillgängliga (ett scenario per symbol). Aktuell exempelkonfiguration kör scenariot TemplateCode:

#define TemplateCode // or LogFromMain or ExpandDefault or FilterInCode

Om du vill ändra exemplet för att köra ExpandDefault scenariot definierar du ExpandDefault-symbolen och lämnar de återstående symbolerna utkommenterade:

#define ExpandDefault // TemplateCode or LogFromMain or FilterInCode

Mer information om hur du använder C#-förprocessordirektiv för att selektivt kompilera kodavsnitt finns i #define (C#-referens) och #if (C#-referens).

Regioner i exempelkod

Vissa exempelappar innehåller kodavsnitt omgivna av #region - och #endregion C#-direktiv. Dokumentationens byggsystem matar in dessa regioner i de renderade dokumentationsämnena.

Regionnamn innehåller vanligtvis ordet "kodfragment". I följande exempel visas en region med namnet snippet_WebHostDefaults:

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

Det föregående C#-kodfragmentet refereras till i ämnets markdown-fil med följande rad:

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

Du kan ignorera eller ta bort direktiven #region och #endregion som omger koden på ett säkert sätt. Ändra inte koden i dessa direktiv om du planerar att köra de exempelscenarier som beskrivs i ämnet.

Mer information finns i Bidra till ASP.NET dokumentation: Kodfragment.

Dokumentobjektmodell (DOM)

Referenser till dokumentobjektmodellen i den här dokumentationsuppsättningen använder förkortningen DOM.

Mer information finns i Introduktion till DOM (MDN-dokumentation) och W3C (Level 1 Document Object Model Specification).

Bytemultipler

.NET-bytestorlekar använder måttprefix för icke-decimala multiplar av byte baserat på 1024-krafter.

Namn (förkortning)	Size	Exempel
Kilobyte (KB)	1 024 byte	1 KB = 1 024 byte
Megabyte (MB)	1 024² bytes	1 MB = 1 048 576 byte
Gigabyte (GB)	1 024³ bytes	1 GB = 1 073 741 824 byte

Supportförfrågningar

Endast dokumentationsrelaterade problem är lämpliga för dotnet/AspNetCore.Docs-repo. För produktsupport ska du inte öppna ett dokumentationsproblem. Sök hjälp via en eller flera av följande supportkanaler:

För en potentiell bugg i ramverket eller produktfeedback öppnar du ett ärende för produktenheten ASP.NET Core på dotnet/aspnetcore ärenden. Felrapporter kräver vanligtvis följande:

Tydlig förklaring av problemet: Följ anvisningarna i GitHub-problemmallen som tillhandahålls av produktenheten när du öppnar problemet.
Minimal repro project: Placera ett projekt på GitHub som produktenhetstekniker kan ladda ned och köra. Korslänka projektet till problemets inledande kommentar.

För ett potentiellt problem med en artikel, öppna ett dokumentationsärende. Om du vill öppna ett dokumentationsproblem använder du länken Öppna ett dokumentationsproblem feedback längst ned i artikeln. Metadata som läggs till i ditt problem ger spårningsdata och pingar automatiskt artikelns författare. Om ämnet diskuterades med produktenheten innan du öppnade dokumentationsproblemet lägger du till en korslänk till det tekniska problemet i dokumentationsproblemets inledande kommentar.

GitHub-ärenden för Blazor-dokumentationen markeras automatiskt för prioritering på projektet Blazor.Docs (dotnet/AspNetCore.Docs GitHub-lagringsplats). Vänta en kort stund på ett svar, särskilt under helger och helgdagar. Vanligtvis svarar dokumentationsförfattare inom 24 timmar på vardagar.

För problem eller feedback på Visual Studio använder du Report a Problem eller Suggest a Feature gester inifrån Visual Studio, vilket öppnar interna problem för Visual Studio. Mer information finns i Visual Studio Feedback.

Om du har problem med Visual Studio Code kan du be om support i community-supportforum. För felrapporter och produktfeedback öppnar du ett problem på microsoft/vscode GitHub-lagringsplatsen.

Ytterligare resurser

Handledningar
grunderna i ASP.NET Core Blazor

Handledningar
- Skapa en Blazor att göra-listapp
- Självstudie: Skapa ett minimalt API med ASP.NET Core
grunderna i ASP.NET Core Blazor

Feedback

Var den här sidan till hjälp?

Last updated on 2026-09-05

översikt över grunderna i ASP.NET Core

Filen Program

Klassen Startup

Beroendeinmatning (tjänster)

Environments

Middleware

Host

Scenarier som inte är webb

Servers

Windows

macOS och Linux

Configuration

Logging

Routing

Hantering av fel

Att göra HTTP-förfrågningar

Innehållsrot

Webbrot

Så här laddar du ned ett exempel

Förprocessordirektiv i exempelkod

Regioner i exempelkod

Dokumentobjektmodell (DOM)

Bytemultipler

Supportförfrågningar

Ytterligare resurser

Feedback

Ytterligare resurser

Filen `Program`

Klassen `Startup`