Migreren van ASP.NET Core in .NET 5 naar .NET 6

2025-05-28

In dit artikel wordt uitgelegd hoe u een bestaande ASP.NET Core in .NET 5-project bijwerkt naar .NET 6. Zie Migreren van ASP.NET Core 3.1 naar .NET 6 voor instructies over het migreren van ASP.NET Core 3.1 naar .NET 6.

Vereiste voorwaarden

Visual Studio 2022 met de workload voor ASP.NET en webontwikkeling.
.NET 6 SDK

.NET SDK-versie bijwerken in global.json

Als u afhankelijk bent van een global.json bestand om een specifieke .NET SDK-versie te targeten, werkt u de version eigenschap bij naar de .NET 6 SDK-versie die is geïnstalleerd. Voorbeeld:

{
  "sdk": {
-    "version": "5.0.100"
+    "version": "6.0.100"
  }
}

Het doelframework bijwerken

Werk de Target Framework Moniker (TFM)- van het projectbestand bij naar net6.0:

<Project Sdk="Microsoft.NET.Sdk.Web">

  <PropertyGroup>
-    <TargetFramework>net5.0</TargetFramework>
+    <TargetFramework>net6.0</TargetFramework>
  </PropertyGroup>

</Project>

Pakketverwijzingen bijwerken

Werk in het projectbestand elke pakketreferentie op door het kenmerk Microsoft.AspNetCore.* van de referenties Microsoft.Extensions.* en Version bij te werken naar 6.0.0 of hoger. Voorbeeld:

<ItemGroup>
-    <PackageReference Include="Microsoft.AspNetCore.JsonPatch" Version="5.0.3" />
-    <PackageReference Include="Microsoft.Extensions.Caching.Abstractions" Version="5.0.0" />
+    <PackageReference Include="Microsoft.AspNetCore.JsonPatch" Version="6.0.0" />
+    <PackageReference Include="Microsoft.Extensions.Caching.Abstractions" Version="6.0.0" />
</ItemGroup>

Nieuw hostingmodel

Voor het nieuwe minimale .NET 6-hostingmodel voor ASP.NET Core-apps is slechts één bestand en een paar regels code vereist. Apps die migreren naar .NET 6 hoeven niet het nieuwe minimale hostingmodel te gebruiken. Voor meer informatie, zie Apps die migreren naar .NET 6 hoeven het nieuwe minimale hostingmodel niet te gebruiken in de volgende sectie.

Met de volgende code van de lege ASP.NET Core-sjabloon wordt een app gemaakt met behulp van het nieuwe minimale hostingmodel:

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

app.MapGet("/", () => "Hello World!");

app.Run();

Het minimale hostingmodel:

Vermindert aanzienlijk het aantal bestanden en coderegels dat nodig is om een app te maken. Er is slechts één bestand nodig met vier regels code.
Startup.cs Wordt samengevoegd tot Program.cs één Program.cs bestand.
Maakt gebruik van instructies op het hoogste niveau om de code te minimaliseren die vereist is voor een app.
Maakt gebruik van globale using instructies om het aantal using vereiste instructieregels te elimineren of te minimaliseren.

De volgende code bevat de Startup.cs en Program.cs bestanden van een .NET 5 Web App-sjabloon (Razor Pagina's) met ongebruikte using instructies die zijn verwijderd:

using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
// Unused usings removed.

namespace WebAppRPv5
{
    public class Startup
    {
        public Startup(IConfiguration configuration)
        {
            Configuration = configuration;
        }

        public IConfiguration Configuration { get; }

        // This method gets called by the runtime. Use this method to add services to the container.
        public void ConfigureServices(IServiceCollection services)
        {
            services.AddRazorPages();
        }

        // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
        public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
        {
            if (env.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();
            }
            else
            {
                app.UseExceptionHandler("/Error");
                // The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
                app.UseHsts();
            }

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

            app.UseRouting();

            app.UseAuthorization();

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

using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.Hosting;
// Unused usings removed.

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

In ASP.NET Core in .NET 6 wordt de voorgaande code vervangen door het volgende:

var builder = WebApplication.CreateBuilder(args);

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

var app = builder.Build();

// Configure the HTTP request pipeline.
if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Error");
    // The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
    app.UseHsts();
}

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

app.UseRouting();

app.UseAuthorization();

app.MapRazorPages();

app.Run();

In het voorgaande ASP.NET Core in .NET 6-voorbeeld ziet u hoe:

ConfigureServices wordt vervangen door WebApplication.Services.
builder.Build() retourneert een geconfigureerde WebApplication naar de variabele app. Configure wordt vervangen door configuratie-aanroepen naar dezelfde services met behulp van app.

Gedetailleerde voorbeelden van het migreren van ASP.NET Core in .NET 5-code Startup naar .NET 6 met behulp van het minimale hostingmodel worden verderop in dit document gegeven.

Er zijn enkele wijzigingen in de andere bestanden die zijn gegenereerd voor de web-app-sjabloon:

Index.cshtml en Privacy.cshtml hebben de ongebruikte using-instructies verwijderd.
RequestId wordt in Error.cshtml gedeclareerd als een nulbare referentietype (NRT):

- public string RequestId { get; set; }
+ public string? RequestId { get; set; }

Standaardwaarden op logboekniveau zijn gewijzigd in appsettings.json en appsettings.Development.json:

- "Microsoft": "Warning",
- "Microsoft.Hosting.Lifetime": "Information"
+ "Microsoft.AspNetCore": "Warning"

In de voorgaande ASP.NET Core-sjablooncode is "Microsoft": "Warning" gewijzigd in "Microsoft.AspNetCore": "Warning". Deze wijziging resulteert in het vastleggen van alle informatieve berichten uit de Microsoft naamruimte , behalveMicrosoft.AspNetCore. Bijvoorbeeld, Microsoft.EntityFrameworkCore wordt nu geregistreerd op een informatieniveau.

Zie de sectie Veelgestelde vragen voor meer informatie over het nieuwe hostingmodel. Zie de sectie Nullable reference types (NRTs) en .NET compiler null-state statische analyse voor meer informatie over de adoptie van NRT's en .NET compiler null-state analyse.

Apps die migreren naar of gebruikmaken van 6.0 of hoger hoeven niet het nieuwe minimale hostingmodel te gebruiken

Het gebruik Startup en de algemene host die door de ASP.NET Core 3.1- en 5.0-sjablonen wordt gebruikt, wordt volledig ondersteund.

Gebruik Startup met het nieuwe minimale hostingmodel

ASP.NET Core 3.1- en 5.0-apps kunnen hun Startup code gebruiken met het nieuwe minimale hostingmodel. Het gebruik Startup met het minimale hostingmodel heeft de volgende voordelen:

Er wordt geen verborgen weerspiegeling gebruikt om de Startup klas aan te roepen.
Asynchrone code kan worden geschreven door de ontwikkelaar die de aanroep van Startup beheert.
Code kan worden geschreven die ConfigureServices en Configure door elkaar weeft.

Een kleine beperking bij het gebruik van Startup code met het nieuwe minimale hostingmodel is dat om een afhankelijkheid in Configure in te voegen, de service in Program.cs handmatig moet worden opgelost.

Bekijk de volgende code die is gegenereerd door de sjabloon ASP.NET Core 3.1 of 5.0 Razor Pages:

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

public class Startup
{
    public Startup(IConfiguration configuration)
    {
        Configuration = configuration;
    }

    public IConfiguration Configuration { get; }

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

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

De voorgaande code is gemigreerd naar het nieuwe minimale hostingmodel:

using Microsoft.AspNetCore.Builder;

var builder = WebApplication.CreateBuilder(args);

var startup = new Startup(builder.Configuration);

startup.ConfigureServices(builder.Services);

var app = builder.Build();

startup.Configure(app, app.Environment);

app.Run();

public class Startup
{
    public Startup(IConfiguration configuration)
    {
        Configuration = configuration;
    }

    public IConfiguration Configuration { get; }

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

    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
    {
        if (!env.IsDevelopment())
        {
            app.UseExceptionHandler("/Error");
            app.UseHsts();
        }

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

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

In de voorgaande code wordt het if (env.IsDevelopment()) blok verwijderd omdat in de ontwikkelmodus de middleware voor de uitzonderingspagina voor ontwikkelaars standaard is ingeschakeld. Zie Verschillen tussen de ASP.NET Core in .NET 5- en .NET 6-hostingmodellen in de volgende sectie voor meer informatie.

Wanneer u een aangepaste afhankelijkheidsinjectiecontainer (DI) gebruikt, voegt u de volgende gemarkeerde code toe:

using Autofac;
using Autofac.Extensions.DependencyInjection;
using Microsoft.AspNetCore.Builder;
using Microsoft.Extensions.Hosting;

var builder = WebApplication.CreateBuilder(args);

var startup = new Startup(builder.Configuration);

startup.ConfigureServices(builder.Services);

// Using a custom DI container.
builder.Host.UseServiceProviderFactory(new AutofacServiceProviderFactory());
builder.Host.ConfigureContainer<ContainerBuilder>(startup.ConfigureContainer);

var app = builder.Build();

startup.Configure(app, app.Environment);

app.Run();

using Autofac;
public class Startup
{
    public Startup(IConfiguration configuration)
    {
        Configuration = configuration;
    }

    public IConfiguration Configuration { get; }

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

    //  Using a custom DI container
    public void ConfigureContainer(ContainerBuilder builder)
    {
        // Configure custom container.
    }

    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
    {
        if (!env.IsDevelopment())
        {
            app.UseExceptionHandler("/Error");
            app.UseHsts();
        }

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

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

Wanneer u het minimale hostingmodel gebruikt, verpakt de middleware voor eindpuntroutering de volledige middleware-pijplijn. Daarom is het niet nodig om expliciete aanroepen naar UseRouting of UseEndpoints om routes te registreren. UseRouting kan nog steeds worden gebruikt om op te geven waar routekoppeling plaatsvindt, maar UseRouting hoeft niet expliciet te worden aangeroepen als routes moeten worden vergeleken aan het begin van de middleware-pijplijn.

In de volgende code worden de aanroepen van UseRouting en UseEndpoints verwijderd uit Startup. MapRazorPages wordt aangeroepen in Program.cs:

public class Startup
{
    public Startup(IConfiguration configuration)
    {
        Configuration = configuration;
    }

    public IConfiguration Configuration { get; }

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

    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
    {
        if (!env.IsDevelopment())
        {
            app.UseExceptionHandler("/Error");
            app.UseHsts();
        }

        app.UseHttpsRedirection();
        app.UseStaticFiles();
        //app.UseRouting();

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

using Microsoft.AspNetCore.Builder;

var builder = WebApplication.CreateBuilder(args);

var startup = new Startup(builder.Configuration);

startup.ConfigureServices(builder.Services);

var app = builder.Build();

startup.Configure(app, app.Environment);

app.MapRazorPages();

app.Run();

Houd rekening met het volgende verschil wanneer u het nieuwe minimale hostingmodel met Startup gebruikt:

Program.cs bepaalt de instantiëring en levensduur van de Startup klasse.
Eventuele extra services die in de Configure methode worden geïnjecteerd, moeten handmatig worden opgelost door de Program klasse.

Verschillen tussen de ASP.NET Core in .NET 5- en .NET 6-hostingmodellen

In de ontwikkelingsmodus is de middleware voor de uitzonderingspagina voor ontwikkelaars standaard ingeschakeld.
De naam van de app wordt standaard ingesteld op de naam van de assembly van het toegangspunt: Assembly.GetEntryAssembly().GetName().FullName. Wanneer u de WebApplicationBuilder in een bibliotheek gebruikt, wijzigt u expliciet de naam van de app in de assembly van de bibliotheek, zodat detectie van toepassingsonderdelen van MVC werkt. Zie Wijzig de hoofdmap, app-naam en omgeving in dit document voor gedetailleerde instructies.
De middleware voor eindpuntroutering verpakt de volledige middleware-pijplijn, daarom hoeft u geen expliciete aanroepen naar UseRouting of UseEndpoints om routes te registreren. UseRouting kan nog steeds worden gebruikt om op te geven waar routekoppeling plaatsvindt, maar UseRouting hoeft niet expliciet te worden aangeroepen als routes moeten worden vergeleken aan het begin van de middleware-pijplijn.
De pijplijn wordt gemaakt voordat er uitvoeringen IStartupFilter plaatsvinden. Daardoor zijn uitzonderingen die tijdens het bouwen van de pijplijn worden veroorzaakt, niet zichtbaar voor de IStartupFilter oproepketen.
Sommige hulpprogramma's, zoals EF-migraties, gebruiken Program.CreateHostBuilder om toegang te krijgen tot de IServiceProvider van de app om aangepaste logica uit te voeren in de context van de app. Deze hulpprogramma's zijn bijgewerkt om een nieuwe techniek te gebruiken om aangepaste logica uit te voeren in de context van de app. Entity Framework Migrations is een voorbeeld van een hulpprogramma dat op deze manier wordt gebruikt Program.CreateHostBuilder . We werken eraan om ervoor te zorgen dat hulpprogramma's worden bijgewerkt om het nieuwe model te gebruiken.
In tegenstelling tot de Startup klasse configureert de minimale host niet automatisch een DI-bereik bij het instantiëren van de serviceprovider. Voor contexten waarin een bereik is vereist, is het nodig om aan te roepen IServiceScope met IServiceScopeFactory.CreateScope om een nieuw bereik te instantiëren. Zie voor meer informatie hoe u een service kunt oplossen bij het opstarten van de app.
Het is niet mogelijk om hostinstellingen zoals app-naam, omgeving of de inhoudshoofdmap te wijzigen na het maken van de WebApplicationBuilder. Zie Aanpassen IHostBuilder of IWebHostBuilderwijzigen voor gedetailleerde instructies over het wijzigen van hostinstellingen. De volgende gemarkeerde API's genereren een uitzondering.

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddRazorPages();

// WebHost

try
{
    builder.WebHost.UseContentRoot(Directory.GetCurrentDirectory());
}
catch (Exception ex)
{
    Console.WriteLine(ex.Message);
}

try
{
    builder.WebHost.UseEnvironment(Environments.Staging);
}
catch (Exception ex)
{
    Console.WriteLine(ex.Message);
}

try
{
    builder.WebHost.UseSetting(WebHostDefaults.ApplicationKey, "ApplicationName2");
}
catch (Exception ex)
{
    Console.WriteLine(ex.Message);
}

try
{
    builder.WebHost.UseSetting(WebHostDefaults.ContentRootKey, Directory.GetCurrentDirectory());
}
catch (Exception ex)
{
    Console.WriteLine(ex.Message);
}

try
{
    builder.WebHost.UseSetting(WebHostDefaults.EnvironmentKey, Environments.Staging);
}
catch (Exception ex)
{
    Console.WriteLine(ex.Message);
}

// Host
try
{
    builder.Host.UseEnvironment(Environments.Staging);
}
catch (Exception ex)
{
    Console.WriteLine(ex.Message);
}

try
{
    // TODO: This does not throw
    builder.Host.UseContentRoot(Directory.GetCurrentDirectory());
}
catch (Exception ex)
{
    Console.WriteLine(ex.Message);
}

var app = builder.Build();

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

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

app.UseRouting();

app.UseAuthorization();

app.MapRazorPages();

app.Run();

De Startup klasse kan niet worden gebruikt van WebApplicationBuilder.Host of WebApplicationBuilder.WebHost. Met de volgende gemarkeerde code wordt een uitzondering gegenereerd:

var builder = WebApplication.CreateBuilder(args);

try
{
    builder.Host.ConfigureWebHostDefaults(webHostBuilder =>
    {
        webHostBuilder.UseStartup<Startup>();
    });
}
catch (Exception ex)
{
    Console.WriteLine(ex.Message);
    throw;    
}

builder.Services.AddRazorPages();

var app = builder.Build();

var builder = WebApplication.CreateBuilder(args);

try
{
    builder.WebHost.UseStartup<Startup>();
}
catch (Exception ex)
{
    Console.WriteLine(ex.Message);
    throw;    
}

builder.Services.AddRazorPages();

var app = builder.Build();

De IHostBuilder implementatie op WebApplicationBuilder (WebApplicationBuilder.Host), stelt de uitvoering van de ConfigureServices, ConfigureAppConfigurationof ConfigureHostConfiguration methoden niet uit. Door de uitvoering niet uit te stellen, kan code die WebApplicationBuilder gebruikt, wijzigingen in de IServiceCollection en IConfiguration observeren. In het volgende voorbeeld wordt Service1 alleen als een IService toegevoegd.

using Microsoft.Extensions.DependencyInjection.Extensions;

var builder = WebApplication.CreateBuilder(args);

builder.Host.ConfigureServices(services =>
{
    services.TryAddSingleton<IService, Service1>();
});

builder.Services.TryAddSingleton<IService, Service2>();

var app = builder.Build();

// Displays Service1 only.
Console.WriteLine(app.Services.GetRequiredService<IService>());

app.Run();

class Service1 : IService
{
}

class Service2 : IService
{
}

interface IService
{
}

In de voorgaande code wordt de builder.Host.ConfigureServices callback onmiddellijk aangeroepen, in plaats van dat het wordt uitgesteld totdat builder.Build wordt aangeroepen. Dit betekent dat Service1 aan IServiceCollection wordt toegevoegd voor Service2 en resulteert in dat Service1 wordt opgelost voor IService.

Bibliotheken bouwen voor ASP.NET Core in .NET 6

Het bestaande .NET-ecosysteem heeft de uitbreidbaarheid rond IServiceCollection, IHostBuilder en IWebHostBuilder gebouwd. Deze eigenschappen zijn beschikbaar als WebApplicationBuilderServices, Hosten WebHost.

WebApplication implementeert zowel Microsoft.AspNetCore.Builder.IApplicationBuilder als Microsoft.AspNetCore.Routing.IEndpointRouteBuilder.

We verwachten dat bibliotheekauteurs zich blijven richten op IHostBuilder, IWebHostBuilderen IApplicationBuilderIEndpointRouteBuilder bij het bouwen van ASP.NET Kernspecifieke onderdelen. Dit zorgt ervoor dat uw middleware, routehandler of andere uitbreidbaarheidspunten blijven werken in verschillende hostingmodellen.

Veelgestelde vragen (FAQ)

Is het nieuwe minimale hostingmodel minder geschikt?

Nee. Het nieuwe hostingmodel is functioneel gelijkwaardig voor 98% scenario's die worden ondersteund door IHostBuilder en de IWebHostBuilder. Er zijn enkele geavanceerde scenario's waarvoor specifieke tijdelijke oplossingen IHostBuildernodig zijn, maar we verwachten dat deze uiterst zeldzaam zijn.
Is het algemene hostingmodel afgeschaft?

Nee. Het algemene hostingmodel is een alternatief model dat voor onbepaalde tijd wordt ondersteund. De algemene host onderbouwt het nieuwe hostingmodel en is nog steeds de primaire manier om toepassingen op basis van werkrollen te hosten.
Moet ik migreren naar het nieuwe hostingmodel?

Nee. Het nieuwe hostingmodel is de voorkeurswijze voor het hosten van nieuwe apps met .NET 6 of hoger, maar u bent niet gedwongen om de projectindeling in bestaande apps te wijzigen. Dit betekent dat apps kunnen upgraden van .NET 5 naar .NET 6 door het doelframework in het projectbestand te wijzigen van net5.0 in net6.0. Zie de sectie Het doelframework bijwerken in dit artikel voor meer informatie. We raden echter aan apps te migreren naar het nieuwe hostingmodel om te profiteren van nieuwe functies die alleen beschikbaar zijn voor het nieuwe hostingmodel.
Moet ik instructies op het hoogste niveau gebruiken?

Nee. De nieuwe projectsjablonen gebruiken allemaal instructies op het hoogste niveau, maar de nieuwe hosting-API's kunnen worden gebruikt in elke .NET 6-app om een webserver of web-app te hosten.
Waar plaats ik de toestand die als velden is opgeslagen in mijn Program of Startup klasse?

We raden u ten zeerste aan afhankelijkheidsinjectie (DI) te gebruiken om de status door te geven in ASP.NET Core-applicaties.

Er zijn twee benaderingen voor het opslaan van de status buiten DI:
- Sla de status op in een andere klasse. Bij opslaan in een klasse wordt ervan uitgegaan dat er een statische status beschikbaar is vanaf elke locatie in de app.
- Gebruik de Program klasse die wordt gegenereerd door instructies op het hoogste niveau om de status op te slaan. Het gebruik Program om de status op te slaan is de semantische benadering:
```
var builder = WebApplication.CreateBuilder(args);

ConfigurationValue = builder.Configuration["SomeKey"] ?? "Hello";

var app = builder.Build();

app.MapGet("/", () => ConfigurationValue);

app.Run();

partial class Program
{
    public static string? ConfigurationValue { get; private set; }
}
```
Wat gebeurt er als ik een aangepaste container voor afhankelijkheidsinjectie gebruikte?

Aangepaste DI-containers worden ondersteund. Zie de container Aangepaste afhankelijkheidsinjectie (DI) voor een voorbeeld.
Werken WebApplicationFactory en TestServer nog steeds?

Ja. WebApplicationFactory<TEntryPoint> is de manier om het nieuwe hostingmodel te testen. Zie Testen met WebApplicationFactory of TestServervoor een voorbeeld.

Blazor

Nadat u de richtlijnen eerder in dit artikel hebt gevolgd om een app bij te werken naar .NET 6, gebruikt u specifieke functies door de koppelingen te volgen in Wat is er nieuw in ASP.NET Core in .NET 6.

Als u alle nieuwe 6.0-functies voor Blazor apps wilt gebruiken, raden we het volgende proces aan:

Maak een nieuw 6.0-project Blazor op basis van een van de Blazor projectsjablonen. Zie Hulpprogramma's voor ASP.NET Core Blazorvoor meer informatie.
Verplaats de onderdelen en code van de app naar de 6.0-app die wijzigingen aanbrengt om de nieuwe .NET 6-functies te gebruiken.

SPA-projecten migreren

Angular-apps migreren vanuit spa-extensies

Bekijk dit GitHub-probleem

React-apps migreren van SPA-extensies

Zie React-toepassingen migreren vanuit spa-extensies in dit GitHub-probleem

Docker-installatiekopieën bijwerken

Werk uw Dockerfile-instructies en -scripts bij voor apps die DockerfileFROM gebruiken. Gebruik een basisinstallatiekopie met de ASP.NET Core in .NET 6 runtime. Houd rekening met het volgende docker pull opdrachtverschil tussen ASP.NET Core in .NET 5 en .NET 6:

- docker pull mcr.microsoft.com/dotnet/aspnet:5.0
+ docker pull mcr.microsoft.com/dotnet/aspnet:6.0

Zie GitHub-issue Breaking Change: standaard console logger formaat ingesteld op JSON.

Wijzigingen in de ASP.NET Core Razor SDK

De Razor compiler maakt nu gebruik van de nieuwe brongeneratorfunctie om gecompileerde C#-bestanden te genereren op basis van de Razor weergaven en pagina's in een project. In eerdere versies:

De compilatie was afhankelijk van de RazorGenerate- en RazorCompile-doelen om de gegenereerde code te produceren. Deze doelen zijn niet meer geldig. In .NET 6 worden zowel codegeneratie als compilatie ondersteund door één aanroep naar de compiler. RazorComponentGenerateDependsOn wordt nog steeds ondersteund om afhankelijkheden op te geven die vereist zijn voordat de build wordt uitgevoerd.
Er is een afzonderlijke Razor assembly AppName.Views.dllgegenereerd die de gecompileerde weergavetypen in een toepassing bevatte. Dit gedrag is afgeschaft en er wordt één assembly AppName.dll geproduceerd die zowel de app-typen als de gegenereerde weergaven bevat.
De app-typen waren AppName.Views.dll openbaar. In .NET 6 bevinden de app-typen zich in AppName.dll maar wel internal sealed. Apps die typedetectie AppName.Views.dll uitvoeren, kunnen geen typedetectie uitvoeren op AppName.dll. Hieronder ziet u de API-wijziging:

- public class Views_Home_Index : global::Microsoft.AspNetCore.Mvc.Razor.RazorPage<dynamic>
+ internal sealed class Views_Home_Index : global::Microsoft.AspNetCore.Mvc.Razor.RazorPage<dynamic>

Breng de volgende wijzigingen aan:

De volgende eigenschappen zijn niet meer van toepassing op het compilatiemodel met één stap.
- RazorTargetAssemblyAttribute
- RazorTargetName
- EnableDefaultRazorTargetAssemblyInfoAttributes
- UseRazorBuildServer
- GenerateRazorTargetAssemblyInfo
- GenerateMvcApplicationPartsAssemblyAttributes

Voor meer informatie, zie Razor compiler produceert geen weergave-assembly meer.

Projectsjablonen maken gebruik van Duende Identity Server

Projectsjablonen maken nu gebruik van Duende Identity Server.

Belangrijk

Duende Identity Server is een opensource-product met een wederzijdse licentieovereenkomst. Als u Van plan bent Duende Server in productie te gebruiken, moet u mogelijk een commerciële licentie van Identity Software verkrijgen en een licentiekosten betalen. Zie Duende Software: Licenties voor meer informatie.

Zie ) voor meer informatie over het gebruik van Identity voor ASP.NET CoreIdentity.

Voeg een DbSet<Key> eigenschap genaamd Keys toe aan elk IdentityDbContext om te voldoen aan een nieuwe vereiste van de bijgewerkte versie van IPersistedGrantDbContext. De sleutels zijn vereist als onderdeel van het contract met de winkels van Duende Identity Server.

public DbSet<Key> Keys { get; set; }

Opmerking

Bestaande migraties moeten opnieuw worden gemaakt voor Duende Identity Server.

Codevoorbeelden die zijn gemigreerd naar ASP.NET Core in .NET 6

Codevoorbeelden gemigreerd naar het nieuwe minimale hostingmodel in 6.0

Brekende wijzigingen bekijken

Zie de volgende bronnen:

Identity: De standaard Bootstrap-versie van de gebruikersinterface is gewijzigd
Belangrijke wijzigingen voor migratie van versie .NET 5 naar .NET 6: bevat ASP.NET Core en Entity Framework Core.
Aankondigingen gitHub-opslagplaats (aspnet/aankondigingen, 6.0.0 label): bevat belangrijke en niet-belangrijke informatie.

Nullable reference types (NRTs) en .NET compiler null-state static analysis

ASP.NET Core-projectsjablonen maken gebruik van null-referentietypen (NRT's) en voert de .NET-compiler statische analyse met null-status uit. Deze functies zijn uitgebracht met C# 8 en zijn standaard ingeschakeld voor apps die worden gegenereerd met behulp van ASP.NET Core in .NET 6 (C# 10) of hoger.

De statische analysewaarschuwingen van de .NET-compiler met null-status kunnen fungeren als richtlijn voor het lokaal bijwerken van een documentatievoorbeeld of voorbeeld-app of worden genegeerd. Statische analyse met null-status kan worden uitgeschakeld door in het projectbestand van de app in te Nullablestellendisable. Dit wordt alleen aanbevolen voor documentatievoorbeelden en voorbeeld-apps als de compilerwaarschuwingen afleiden tijdens het leren over .NET. Het is niet raadzaam om null-statuscontrole in productieprojecten uit te schakelen.

Zie de volgende bronnen in de C#-documentatie voor meer informatie over NRT's, de eigenschap MSBuild Nullable en het bijwerken van apps (inclusief #pragma richtlijnen):

ASP.NET Core Module (ANCM)

Als de ASP.NET Core Module (ANCM) geen geselecteerd onderdeel was toen Visual Studio werd geïnstalleerd of als er een eerdere versie van de ANCM op het systeem was geïnstalleerd, downloadt u de meest recente .NET Core Hosting Bundle Installer (direct downloaden) en voert u het installatieprogramma uit. Zie Hosting Bundlevoor meer informatie.

Naam van de applicatie wijzigen

In .NET 6 WebApplicationBuilder normaliseert u het hoofdpad van de inhoud om te eindigen met een DirectorySeparatorChar. De meeste apps die worden gemigreerd van HostBuilder of WebHostBuilder hebben niet dezelfde app-naam omdat ze niet zijn genormaliseerd. Zie SetApplicationName voor meer informatie

Aanvullende bronnen

Codevoorbeelden gemigreerd naar het nieuwe minimale hostingmodel in 6.0