Overzicht van basisinformatie over ASP.NET Core

Dit artikel bevat een overzicht van de basisprincipes voor het bouwen van ASP.NET Core-apps, waaronder afhankelijkheidsinjectie (DI), configuratie en middleware.

Zie voor fundamentele richtlijnen over Blazor, die de richtlijnen in dit artikel aanvullen of vervangen, ASP.NET Core basisprincipes Blazor.

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

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

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

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

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

Zie App opstarten in ASP.NET Core en ASP.NET Core Blazor opstarten voor meer informatie.

Afhankelijkheidsinjectie (diensten)

ASP.NET Core beschikt over ingebouwde afhankelijkheidsinjectie (DI) waarmee geconfigureerde services beschikbaar zijn in een app voor Inversion of Control (IoC).

var builder = WebApplication.CreateBuilder(args);

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

builder.Services.AddServerSideBlazor();

@inject NavigationManager Navigation

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

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

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

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

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

public void ConfigureServices(IServiceCollection services)
{
    services.AddControllersWithViews();
    services.AddRazorPages();
}

Als de ingebouwde DI-container niet aan uw behoeften voldoet, kan in plaats daarvan een IoC-container van derden worden gebruikt.

Zie Afhankelijkheidsinjectie in ASP.NET Core en ASP.NET Core Blazor afhankelijkheidsinjectie voor meer informatie.

Environments

Uitvoeringsomgevingen zijn beschikbaar in ASP.NET Core, zoals:

• Development: Wanneer de app zich in lokale ontwikkeling bevindt.
• Staging: Wanneer de app is klaargezet voor uitrol.
• Production: Wanneer de liveversie van de app draait voor gebruikers.

Geef de omgeving op waarin een app wordt uitgevoerd door de ASPNETCORE_ENVIRONMENT omgevingsvariabele in te stellen op de host waarop de app wordt uitgevoerd. ASP.NET Core leest de omgevingsvariabele bij het opstarten van de app en slaat de waarde op om de uitvoering van code rond de app te beheren.

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

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

    ...
}

Zie ASP.NET Core runtime-omgevingen en ASP.NET Core Blazor omgevingen voor meer informatie.

Middleware

De pijplijn voor het verwerken van aanvragen is samengesteld als een reeks middlewareonderdelen. Elk onderdeel voert bewerkingen uit op een HttpContext en roept de volgende middleware in de pijplijn aan of beëindigt de aanvraag.

Volgens de conventie worden middleware-onderdelen toegevoegd aan de pijplijn door een extensiemethode aan te roepen die begint met '.Use' In het volgende voorbeeld dat een deel van een aanvraagverwerkingspijplijn vertegenwoordigt, worden middleware voor uitzonderingsafhandeling (UseExceptionHandler), HET HSTS-protocolUseHsts (HTTP Strict Transport Security) en HTTPS-omleiding (UseHttpsRedirection) aangeroepen. Twee middlewares worden alleen geactiveerd wanneer de app niet onder lokale ontwikkeling in de Development omgeving valt, bijvoorbeeld wanneer de app is gefaseerd voor implementatie (de Staging omgeving) of in productie (de Production omgeving):

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 bevat een uitgebreide set ingebouwde middleware. U kunt ook aangepaste middlewareonderdelen maken om te voldoen aan de speciale aanvraagverwerkingsspecificaties van een app. Zie ASP.NET Core middleware voor meer informatie.

Host

Bij het opstarten bouwt een ASP.NET Core-app een host. De host bevat alle resources van de app, zoals:

• Een HTTP-server-implementatie
• Middlewareonderdelen
• Logging
• Afhankelijkheidsinjectie-diensten (DI)
• Configuration

var builder = WebApplication.CreateBuilder(args);

...

var app = builder.Build();

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

Zie de volgende bronnen voor meer informatie:

• .NET Generic Host in ASP.NET Core (Aanbevolen)
• ASP.NET Core webhost (voor achterwaartse compatibiliteit)

Niet-webscenario's

Met de Generic Host kunnen andere typen apps gebruikmaken van geavanceerde frameworkextensies, zoals logboekregistratie, afhankelijkheidsinjectie (DI), configuratie en levensduurbeheer van apps. Voor meer informatie, zie .NET Generic Host in ASP.NET Core en Achtergrondtaken met gehoste services in ASP.NET Core.

Servers

Een ASP.NET Core-app maakt gebruik van een HTTP-server-implementatie om te luisteren naar HTTP-aanvragen. De server behandelt aanvragen voor de app als een set aanvraagfuncties samengesteld in een HttpContext.

Zie webserver-implementaties in ASP.NET Corevoor meer informatie.

Windows

ASP.NET Core biedt de volgende server-implementaties:

• Kestrel is een platformoverschrijdende webserver. Kestrel wordt vaak uitgevoerd in een omgekeerde proxyconfiguratie met behulp van IIS-. In ASP.NET Core 2.0 of hoger kan Kestrel worden uitgevoerd als een openbare edge-server die rechtstreeks beschikbaar is voor internet.
• IIS HTTP-server is een server voor Windows die IIS gebruikt. Met deze server worden de ASP.NET Core-app en IIS in hetzelfde proces uitgevoerd.
• HTTP.sys is een server voor Windows die niet wordt gebruikt met IIS.

macOS en Linux

ASP.NET Core biedt de Kestrel-implementatie van een platformoverschrijdende server. In ASP.NET Core 2.0 of hoger kan Kestrel worden uitgevoerd als een openbare edge-server die rechtstreeks beschikbaar is op internet. Kestrel wordt vaak uitgevoerd in een omgekeerde proxyconfiguratie met Nginx- of Apache.

Configuration

ASP.NET Core biedt een configuratieframework waarmee instellingen worden opgehaald als naam-waardeparen van een geordende set configuratieproviders. Ingebouwde configuratieproviders zijn beschikbaar voor verschillende bronnen, zoals JSON-bestanden (), XML-bestanden (.json.xml), omgevingsvariabelen en opdrachtregelargumenten. U kunt aangepaste configuratieproviders maken ter ondersteuning van andere bronnen.

Standaard zijn ASP.NET Core-apps geconfigureerd om te lezen uit app-instellingenbestanden (bijvoorbeeldappsettings.json), omgevingsvariabelen en de opdrachtregel.

Wanneer de configuratie van de app wordt geladen, overschrijven waarden uit omgevingsvariabelen waarden uit app-instellingenbestanden. De Opties-API is beschikbaar voor het lezen van gerelateerde configuratiewaarden.

Voor het beheren van vertrouwelijke configuratiegegevens, zoals wachtwoorden in de Development omgeving, biedt .NET Secret Manager. Voor productiegeheimen raden we u aan Azure Key Vault te gebruiken.

Zie de volgende bronnen voor meer informatie:

• Configuratie in ASP.NET Core
• ASP.NET Core Blazor-configuratie
• Azure Key Vault (documentatie voor ASP.NET Core)

Logging

ASP.NET Core ondersteunt een logboekregistratie-API die werkt met verschillende providers voor logboekregistratie:

• Console
• Debug
• Gebeurtenistracering in Windows
• Windows-gebeurtenislogboek
• TraceSource
• Azure App Service
• Azure-toepassing Insights
• Derde partijen

Als u logboeken wilt maken, moet u een ILogger<TCategoryName> service oplossen op basis van afhankelijkheidsinjectie (DI) en methoden voor het aanroepen van logboekregistratie, zoals LogInformation. Een loggerobject en een consoleprovider voor het logboekobject worden automatisch opgeslagen in de DI-container wanneer de WebApplication.CreateBuilder methode wordt aangeroepen.

In het volgende voorbeeld ziet u hoe u via DI een loggerinstantie verkrijgt en deze gebruikt in een Weather component (Weather.razor) van een Blazor app die weergegevens rapporteert:

@inject ILogger<Weather> Logger

...

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

        ...
    }
}

Zie Logboekregistratie in .NET en ASP.NET Core en ASP.NET Core Blazor logboekregistratie voor meer informatie, waaronder routeringsrichtlijnen voor Razor Pagina's en MVC-apps.

Routing

Routering in ASP.NET Core is een mechanisme waarmee binnenkomende aanvragen worden toegewezen aan specifieke eindpunten in een app. Hiermee kunt u URL-patronen definiëren die overeenkomen met verschillende onderdelen, zoals Razor onderdelen, Razor pagina's, MVC-controlleracties of middleware.

De methode UseRouting voegt routerings-middleware toe aan de aanvraagpijplijn. Deze middleware verwerkt de routeringsinformatie en bepaalt het juiste eindpunt voor elke aanvraag. In apps die de Minimal Host gebruiken, wordt UseRouting niet expliciet aangeroepen in code van de ontwikkelaar, tenzij u de verwerkingsvolgorde van middleware wilt wijzigen.

Zie de volgende bronnen voor meer informatie:

• Routering in ASP.NET Core
• ASP.NET Core-Blazorroutering
• ASP.NET Core Blazor navigatie

Afhandeling van fouten

ASP.NET Core heeft ingebouwde functies voor het afhandelen van fouten, zoals:

• Een uitzonderingspagina voor ontwikkelaars
• Aangepaste foutpagina's
• Pagina's met statische statuscode
• Afhandeling van opstartonderzondering

Zie Fouten afhandelen in ASP.NET Core en fouten afhandelen in ASP.NET Core Blazor apps voor meer informatie.

HTTP-aanvragen maken

Er is een implementatie van IHttpClientFactory beschikbaar voor het maken van HttpClient instanties. De fabriek:

• Biedt een centrale locatie voor het benoemen en configureren van logische HttpClient instanties. Vertrouw bijvoorbeeld op een standaardclient voor de meeste gegevensaanvragen van de app met een web-API en registreer een andere geconfigureerde client voor toegang tot GitHub.
• Ondersteunt registratie en ketening van meerdere delegerende handlers voor het bouwen van een middleware-pijplijn voor uitgaande aanvragen. Dit patroon is vergelijkbaar met de binnenkomende middleware-pijplijn van ASP.NET Core. Het patroon biedt een mechanisme voor het beheren van overschrijdende problemen voor HTTP-aanvragen, waaronder caching, foutafhandeling, serialisatie en logboekregistratie.
• Integreert met Polly, een populaire bibliotheek van een derde partij voor tijdelijke foutafhandeling.
• Beheert de pooling en levensduur van onderliggende HttpClientHandler instanties om veelvoorkomende DNS-problemen te voorkomen die zich voordoen wanneer de levensduur van HttpClient handmatig wordt beheerd.
• Voegt een configureerbare logboekregistratie-ervaring toe via ILogger voor alle aanvragen die worden verzonden via clients die door de fabriek zijn gemaakt.

Zie HTTP-aanvragen met IHttpClientFactory - ASP.NET Core en een web-API aanroepen vanuit een ASP.NET Core-app Blazorvoor meer informatie.

Hoofdmap van inhoud

De inhoudsroot is het basispad voor:

• Het uitvoerbare bestand dat als host fungeert voor de app (.exe).
• Gecompileerde assembly's waaruit de app bestaat (.dll).
• Inhoudsbestanden die door de app worden gebruikt, zoals Razor bestanden (.cshtml, .razor), configuratiebestanden (.json, .xml) en gegevensbestanden (.db).
• De hoofdmap van het web, meestal de wwwroot map.

Tijdens de ontwikkeling wordt de hoofdmap van de inhoud standaard ingesteld op de hoofdmap van het project. Deze map is ook het basispad voor zowel de inhoudsbestanden van de app als de webhoofdmap. Geef een andere inhoudshoofdmap op door het pad in te stellen bij het bouwen van de host.

Zie .NET Generic Host in ASP.NET Core en Serveer statische bestanden in ASP.NET Core-apps voor meer informatie.

Webroot

De webhoofdmap is het basispad voor openbare, statische resourcebestanden, zoals stijlbladen, JavaScript-bestanden en afbeeldingen.

Statische bestanden worden standaard alleen geleverd vanuit de hoofdmap van het web en de bijbehorende submappen. Het webhoofdpad wordt standaard ingesteld op {CONTENT ROOT}/wwwroot, waarbij de {CONTENT ROOT} tijdelijke aanduiding de hoofdmap van de inhoud is. Geef een andere webhoofdmap op door het pad in te stellen wanneer de host bouwt. U kunt ook voorkomen dat bestanden wwwroot worden gepubliceerd met het <Content> projectitem in het projectbestand van de app.

In bestanden Razor.cshtml verwijst ~/ naar de hoofdmap van het web. Een pad dat begint met ~/ wordt een virtueel padgenoemd.

Zie .NET Generic Host in ASP.NET Core en Serveer statische bestanden in ASP.NET Core-apps voor meer informatie.

Een voorbeeld downloaden

Veel van de artikelen en zelfstudies bevatten koppelingen naar voorbeeldcode.

1. Download het zip-bestand van de ASP.NET opslagplaats.
2. Pak het AspNetCore.Docs-main.zip bestand uit.
3. Als u toegang wilt krijgen tot de voorbeeld-app van een artikel in de uitgepakte opslagplaats, gebruikt u de URL in de voorbeeldkoppeling van het artikel om naar de map van het voorbeeld te navigeren. Meestal wordt de voorbeeldkoppeling van een artikel boven aan het artikel weergegeven met de koppelingstekstweergave of download voorbeeldcode.

Om één voorbeeldapp en alleen de laatste commit ervan op te halen, gebruikt u git sparse-checkout.

In het volgende voorbeeld voor de BlazorGitHub-repository met voorbeelden specificeert de git sparse-checkout set-opdracht het pad naar de map met voorbeelden:

• Vervang de {VERSION FOLDER} tijdelijke aanduiding door de versiemap.
• Vervang de {SAMPLE FOLDER}-plaatsaanduiding door de voorbeeldmap.

Navigeer in een opdrachtshell naar de map waarin u het voorbeeld wilt klonen. Voer de volgende opdrachten uit in de opdrachtshell die het pad naar de versie/voorbeeldmap doorgeeft aan de git sparse-checkout set opdracht:

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}

In het volgende PowerShell-voorbeeld wordt het 10.0-voorbeeld Blazor Web App opgehaald en in de map Documenten van de gebruiker geplaatst, met behulp van het ~/documents-pad van PowerShell voor de opdracht (cd) om van map te wisselen:

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

Preprocessor-instructies in voorbeeldcode

Als u meerdere scenario's wilt demonstreren, gebruiken voorbeeld-apps de #define en #if-#else/#elif-#endif preprocessor-instructies om selectief verschillende secties met voorbeeldcode te compileren en uit te voeren. Voor die voorbeelden die gebruikmaken van deze benadering, stelt u de #define instructie bovenaan de C#-bestanden in om het symbool te definiëren dat is gekoppeld aan het scenario dat u wilt uitvoeren. Voor sommige voorbeelden moet het symbool boven aan meerdere bestanden worden gedefinieerd om een scenario uit te voeren.

De volgende #define lijst met symbolen geeft bijvoorbeeld aan dat er vier scenario's beschikbaar zijn (één scenario per symbool). In de huidige voorbeeldconfiguratie wordt het TemplateCode scenario uitgevoerd:

#define TemplateCode // or LogFromMain or ExpandDefault or FilterInCode

Als u het voorbeeld wilt wijzigen om het ExpandDefault scenario uit te voeren, definieert u het ExpandDefault symbool en laat u de resterende symbolen uitgeschakeld:

#define ExpandDefault // TemplateCode or LogFromMain or FilterInCode

Zie #define (C#-verwijzing) en #if (C#-verwijzing) voor meer informatie over het gebruik van C#-preprocessorrichtlijnen om selectief codesecties te compileren.

Regio's binnen voorbeeldcode

Sommige voorbeeld-apps bevatten secties met code omgeven door #region en #endregion C#-instructies. Het buildsysteem voor documentatie injecteert deze regio's in de weergegeven documentatieonderwerpen.

Regionamen bevatten meestal het woord 'fragment'. In het volgende voorbeeld ziet u een regio met de naam snippet_WebHostDefaults:

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

Naar het voorgaande C#-codefragment wordt verwezen in het Markdown-bestand van het onderwerp met de volgende regel:

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

U kunt de #region en #endregion instructies die de code omringen, veilig negeren of verwijderen. Wijzig de code in deze instructies niet als u van plan bent de voorbeeldscenario's uit te voeren die in het onderwerp worden beschreven.

Zie Bijdragen aan de ASP.NET documentatie: Codefragmenten voor meer informatie.

Document Object Model (DOM)

Verwijzingen naar het documentobjectmodel in deze documentatieset gebruiken de afkorting DOM.

Zie Inleiding tot de DOCUMENTATIE over DOM (MDN) en Document Object Model Specification (W3C) op niveau 1 voor meer informatie.

Byte veelvouden

.NET-bytegrootten maken gebruik van metrische voorvoegsels voor niet-decimale veelvouden van bytes op basis van bevoegdheden van 1024.

Ondersteuningsaanvragen

Alleen problemen met betrekking tot documentatie zijn geschikt voor de dotnet/AspNetCore.Docs opslagplaats. Open geen documentatie-issue voor productondersteuning. Zoek hulp via een of meer van de volgende ondersteuningskanalen:

• Stack Overflow voor ASP.NET Core (gelabeld: asp.net-core)
• Stack Overflow voor Blazor (gelabeld: blazor)
• Algemeen ASP.NET Core Slack-team
• Blazor Gitter

Voor een mogelijke fout in het framework of productfeedback kunt u een issue openen voor de ASP.NET Core-producteenheid op dotnet/aspnetcore issues. Voor foutenrapporten is meestal het volgende vereist:

• Uitleg van het probleem: volg de instructies in de GitHub-probleemsjabloon die door de producteenheid wordt geleverd bij het openen van het probleem.
• Minimaal reproproject: plaats een project op GitHub zodat de ingenieurs van de productgroep deze kunnen downloaden en uitvoeren. Koppel het project aan de openingscommentaar van het probleem.

Als er mogelijk een probleem is met een artikel, meld dan een documentatieprobleem. Als u een documentatiekwestie wilt openen, gebruikt u de Open een documentatiekwestie feedbacklink onderaan het artikel. Metagegevens die aan uw probleem zijn toegevoegd, bieden traceringsgegevens en pingen automatisch de auteur van het artikel. Als het onderwerp met de producteenheid is besproken voordat u het documentatieprobleem opent, plaatst u een kruiskoppeling naar het technische probleem in de openingscommentaar van het documentatieprobleem.

GitHub-problemen voor Blazor documentatie worden automatisch gemarkeerd voor sortering in het Blazor.Docs-project (dotnet/AspNetCore.Docs GitHub-opslagplaats). Een ogenblik geduld voor een reactie, met name in het weekend en op feestdagen. Meestal reageren auteurs van documentatie binnen 24 uur op weekdagen.

Voor problemen of feedback over Visual Studio gebruikt u de Meld een Probleem of Stel een Functie Voor handelingen vanuit Visual Studio, waarmee interne problemen voor Visual Studio worden geopend. Zie Visual Studio Feedback voor meer informatie.

Voor problemen met Visual Studio Code vraagt u om ondersteuning op communityondersteuningsforums. Voor foutrapporten en productfeedback opent u een probleem in de microsoft/vscode GitHub-opslagplaats.

Verwante onderwerpen