Migrieren von ASP.NET Core 5.0 zu 6.0

In diesem Artikel wird erläutert, wie Sie ein vorhandenes ASP.NET Core 5.0-Projekt auf ASP.NET Core 6.0 aktualisieren. Anweisungen zum Migrieren von ASP.NET Core 3.1 zu ASP.NET Core 6.0 finden Sie unter Migrieren von ASP.NET Core 3.1 zu 6.0.

Voraussetzungen

Aktualisieren der .NET SDK-Version in global.json

Wenn Sie auf eine Datei angewiesen sind, um auf global.json eine bestimmte .NET SDK-Version zu abzielen, aktualisieren Sie die version Eigenschaft auf die installierte .NET 6.0 SDK-Version. Beispiel:

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

Aktualisieren des Zielframeworks

Aktualisieren sie die Target Framework Moniker (TFM) der Projektdatei auf net6.0:

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

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

</Project>

Aktualisieren von Paketverweisen

Aktualisieren Sie in der Projektdatei das Attribut jedes Microsoft.AspNetCore.* Paketverweis Microsoft.Extensions.*Version auf 6.0.0 oder höher. Beispiel:

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

Neues Hostingmodell

Für ASP.NET Core Apps sind nur eine Datei und einige Codezeilen erforderlich, die das neue .NET 6-Minimalhostingmodell für ASP.NET Core-Apps erfordert. Apps, die zu 6.0 migrieren, müssen das neue minimale Hostingmodell nicht verwenden. Weitere Informationen finden Sie unter Apps, die zu 6.0 migrieren, müssen das neue minimale Hostingmodell im folgenden Abschnitt nicht verwenden.

Der folgende Code aus der leeren vorlage ASP.NET Core erstellt eine App mit dem neuen minimalen Hostingmodell:

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

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

app.Run();

Das minimale Hostingmodell:

  • Sie führt zu einer erheblich geringeren Anzahl der Dateien und Codezeilen, die zum Erstellen einer App erforderlich sind. Es ist nur eine Datei mit vier Codezeilen erforderlich.
  • Sie vereinheitlicht Startup.cs und Program.cs in einer einzigen Program.cs-Datei.
  • Sie verwendet Anweisungen der obersten Ebene, um den für eine App erforderlichen Code zu minimieren.
  • Sie verwendet globale using-Anweisungen, um die Anzahl der erforderlichen Zeilen in einer using-Anweisung zu beseitigen oder zu minimieren.

Der folgende Code zeigt die Startup.cs dateien Program.cs aus einer ASP.NET Core 5 Web App-Vorlage (Razor Seiten) mit nicht verwendeten using Anweisungen an:

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 6 wird der vorherige Code durch folgendes ersetzt:

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

Im vorherigen ASP.NET Core 6-Beispiel wird gezeigt, wie:

Ausführliche Beispiele für die Migration von ASP.NET Core 5 Startup Code zu ASP.NET Core 6 mithilfe des minimalen Hostingmodells werden weiter unten in diesem Dokument bereitgestellt.

Es gibt einige Änderungen an den anderen Dateien, die für die Web App-Vorlage generiert wurden:

  • Index.cshtml und Privacy.cshtml die nicht verwendeten using Anweisungen wurden entfernt.
  • RequestId in Error.cshtml wird als nullabler Bezugstyp (NRT) deklariert:
- public string RequestId { get; set; }
+ public string? RequestId { get; set; }
  • Standardeinstellungen auf Protokollebene wurden geändert und appsettings.jsonappsettings.Development.json:
- "Microsoft": "Warning",
- "Microsoft.Hosting.Lifetime": "Information"
+ "Microsoft.AspNetCore": "Warning"

Im vorherigen ASP.NET Core Vorlagencode "Microsoft": "Warning" wurde in "Microsoft.AspNetCore": "Warning". Diese Änderung führt dazu, dass alle Informationsnachrichten aus dem MicrosoftNamespaceMicrosoft.AspNetCore protokolliert werden. Beispielsweise wird Microsoft.EntityFrameworkCore jetzt auf der Informationsebene protokolliert.

Weitere Informationen zum neuen Hostingmodell finden Sie im Abschnitt " Häufig gestellte Fragen ". Weitere Informationen zur Einführung von NRTs und .NET-Compiler-Null-Zustandsanalyse finden Sie im Abschnitt zur statischen Analyse von NULL-Zustanden (Nullable Reference Types, NRTs) und .NET Compiler null-state static analysis .

Apps, die zu 6.0 migrieren, müssen nicht das neue minimale Hostingmodell verwenden.

Die Verwendung Startup und der generische Host, der von den vorlagen ASP.NET Core 3.1 und 5.0 verwendet wird, wird vollständig unterstützt.

Verwenden des Startvorgangs mit dem neuen minimalen Hostingmodell

ASP.NET Core 3.1- und 5.0-Apps können ihren Startup Code mit dem neuen minimalen Hostingmodell verwenden. Berücksichtigen Sie den folgenden Code, der von der Vorlage ASP.NET Core 3.1 oder 5.0 Razor Seiten generiert wird:

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

Der vorherige Code wurde zum neuen minimalen Hostingmodell migriert:

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

Im vorherigen Code wird der if (env.IsDevelopment()) Block entfernt, da im Entwicklungsmodus standardmäßig die Middleware der Entwickler-Ausnahmeseite aktiviert ist. Weitere Informationen finden Sie unter Unterschiede zwischen den ASP.NET Core 5 und 6 Hostingmodellen im nächsten Abschnitt.

Fügen Sie beim Verwenden eines benutzerdefinierten Abhängigkeitsinjektionscontainers (DI) den folgenden hervorgehobenen Code hinzu:

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

Bei Verwendung des minimalen Hostingmodells umschließt die Endpunktrouting-Middleware die gesamte Middlewarepipeline, daher müssen keine expliziten Aufrufe UseRouting an oder UseEndpoints zum Registrieren von Routen vorhanden sein. UseRouting Kann weiterhin verwendet werden, um anzugeben, wo der Routenabgleich erfolgt, aber UseRouting nicht explizit aufgerufen werden muss, wenn Routen am Anfang der Middlewarepipeline übereinstimmen sollen.

Im folgenden Code werden die Aufrufe UseRouting und UseEndpoints entfernt von Startup. MapRazorPages wird 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();

Beachten Sie bei der Verwendung Startup mit dem neuen minimalen Hostingmodell den folgenden Unterschied:

  • Program.cs steuert die Instanziierung und Lebensdauer der Startup Klasse.
  • Alle zusätzlichen Dienste, die in die Configure Methode eingefügt wurden, müssen von der Program Klasse manuell aufgelöst werden.

Unterschiede zwischen den ASP.NET Core 5- und 6-Hostingmodellen

  • Im Entwicklungsmodus ist die Middleware der Entwickler-Ausnahmeseite standardmäßig aktiviert.
  • Der App-Name ist standardmäßig auf den Namen der Einstiegspunktassembly festgelegt: Assembly.GetEntryAssembly().GetName().FullName. Wenn Sie die WebApplicationBuilder Bibliothek verwenden, ändern Sie den App-Namen explizit in die Assembly der Bibliothek, damit die Anwendungsteilermittlung von MVC funktioniert. Ausführliche Anweisungen finden Sie unter Ändern des Inhaltsstamms, des App-Namens und der Umgebung in diesem Dokument.
  • Die Endpunktrouting-Middleware umschließt die gesamte Middlewarepipeline, daher müssen keine expliziten Aufrufe an UseRouting oder UseEndpoints zum Registrieren von Routen erforderlich sein. UseRouting Kann weiterhin verwendet werden, um anzugeben, wo der Routenabgleich erfolgt, aber UseRouting nicht explizit aufgerufen werden muss, wenn Routen am Anfang der Middlewarepipeline übereinstimmen sollen.
  • Die Pipeline wird vor jeder IStartupFilter Ausführung erstellt, daher sind Ausnahmen, die beim Erstellen der Pipeline verursacht wurden, nicht für die IStartupFilter Anrufkette sichtbar.
  • Einige Tools, z. B. EF-Migrationen, verwenden Program.CreateHostBuilder , um auf die App IServiceProvider zuzugreifen, um benutzerdefinierte Logik im Kontext der App auszuführen. Diese Tools wurden aktualisiert, um eine neue Technik zum Ausführen von benutzerdefinierter Logik im Kontext der App zu verwenden. Entity Framework-Migrationen sind ein Beispiel für ein Tool, das auf diese Weise verwendet wird Program.CreateHostBuilder . Wir arbeiten daran, sicherzustellen, dass Tools aktualisiert werden, um das neue Modell zu verwenden.
  • Es ist nicht möglich , hosteinstellungen wie App-Name, Umgebung oder den Inhaltsstamm nach der Erstellung des WebApplicationBuilderInhaltsstamms zu ändern. Ausführliche Anweisungen zum Ändern von Hosteinstellungen finden Sie unter Anpassen oder Anpassen IHostBuilder oder IWebHostBuilder. Die folgenden hervorgehobenen APIs lösen eine Ausnahme aus:
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();
  • Die Startup Klasse kann nicht von oder WebApplicationBuilder.WebHostaus WebApplicationBuilder.Host verwendet werden. Der folgende hervorgehobene Code löst eine Ausnahme aus:

    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();
    
  • Die IHostBuilder Implementierung auf WebApplicationBuilder (WebApplicationBuilder.Host), verzögert die Ausführung der ConfigureServicesMethoden ConfigureAppConfigurationoder ConfigureHostConfiguration Methoden nicht. Die Ausführung wird nicht zurückgestellt, sodass Code WebApplicationBuilder Änderungen beobachten kann, die an dem IServiceCollection und dem .IConfiguration Das folgende Beispiel fügt Service1 nur als :IService

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

Im vorherigen Code wird der builder.Host.ConfigureServices Rückruf anstelle von "Inline" aufgerufen, bis builder.Build er aufgerufen wird. Dies bedeutet, dass Service1IServiceCollection der Vor Service2 - und Ergebnis Service1 der Lösung für IService.

Erstellen von Bibliotheken für ASP.NET Core 6

Das vorhandene .NET-Ökosystem hat die Erweiterbarkeit um IServiceCollection, IHostBuilderund .IWebHostBuilder Diese Eigenschaften sind als WebApplicationBuilderServices, Hostund WebHost.

WebApplicationimplementiert sowohl als Microsoft.AspNetCore.Routing.IEndpointRouteBuilderauch Microsoft.AspNetCore.Builder.IApplicationBuilder .

Wir erwarten, dass Bibliotheksautoren weiterhin zielendIHostBuilderIWebHostBuilder, , IApplicationBuilderund IEndpointRouteBuilder wenn Sie ASP.NET Core spezifischen Komponenten erstellen. Dadurch wird sichergestellt, dass Ihre Middleware, der Routinghandler oder andere Erweiterbarkeitspunkte weiterhin über verschiedene Hostingmodelle hinweg funktionieren.

Häufig gestellte Fragen (FAQ)

  • Ist das neue minimale Hostingmodell weniger fähig?

    Nein. Das neue Hostingmodell entspricht funktionell 98 % der Szenarien, die von IHostBuilder und dem IWebHostBuilderunterstützt werden. Es gibt einige erweiterte Szenarien, die bestimmte Problemumgehungen IHostBuildererfordern, aber wir erwarten, dass diese extrem selten sind.

  • Ist das generische Hostingmodell veraltet?

    Nein. Das generische Hostingmodell ist ein alternatives Modell, das unbegrenzt unterstützt wird. Der generische Host unterstützt das neue Hostingmodell und ist weiterhin die primäre Möglichkeit, arbeitsbasierte Anwendungen zu hosten.

  • Muss ich zum neuen Hostingmodell migrieren?

    Nein. Das neue Hostingmodell ist die bevorzugte Möglichkeit, neue Apps mithilfe von .NET 6 und höher zu hosten, aber Sie sind nicht gezwungen, das Projektlayout in vorhandenen Apps zu ändern. Dies bedeutet, dass Apps von .NET 5 auf .NET 6 aktualisieren können, indem Sie das Zielframework in der Projektdatei von zu net5.0net6.0" ändern. Weitere Informationen finden Sie im Abschnitt "Aktualisieren des Zielframework " in diesem Artikel. Es wird jedoch empfohlen, Apps zum neuen Hostingmodell zu migrieren, um neue Features nur für das neue Hostingmodell zu nutzen.

  • Muss ich Anweisungen auf oberster Ebene verwenden?

    Nein. Die neuen Projektvorlagen verwenden alle Anweisungen auf oberster Ebene, aber die neuen Hosting-APIs können in einer beliebigen .NET 6-App verwendet werden, um einen Webserver oder eine Web-App zu hosten.

  • Wo habe ich den Zustand eingefügt, der als Felder in meinem oder Startup kurs Program gespeichert wurde?

    Wir empfehlen dringend, den Zustand der Abhängigkeitseinführung (DI) in ASP.NET Core Apps zu verwenden.

    Es gibt zwei Ansätze zum Speichern des Zustands außerhalb von DI:

    • Speichern Sie den Zustand in einer anderen Klasse. Beim Speichern in einer Klasse wird ein statischer Zustand vorausgesetzt, auf den von einer beliebigen Stelle in der App zugegriffen werden kann.

    • Verwenden Sie die klasse, die Program von Anweisungen auf oberster Ebene generiert wird, um den Zustand zu speichern. Die Verwendung Program des Speicherzustands ist der semantische Ansatz:

      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; }
      }
      
  • Was ist, wenn ich einen benutzerdefinierten Abhängigkeits-Injektionscontainer verwende?

    Benutzerdefinierte DI-Container werden unterstützt. Ein Beispiel finden Sie unter Benutzerdefinierte Abhängigkeitsinjektion (DI)-Container.

  • Arbeiten WebApplicationFactory Sie noch TestServer ?

    Ja. WebApplicationFactory<TEntryPoint> ist die Möglichkeit, das neue Hostingmodell zu testen. Ein Beispiel finden Sie unter "Testen mit WebApplicationFactory oder TestServer" .

Blazor

Nachdem Sie in diesem Artikel zuvor die Anleitung zum Aktualisieren einer App auf 6.0 beschrieben haben, führen Sie bestimmte Features aus, indem Sie den Links unter "Neuerungen" in ASP.NET Core 6.0 folgen.

Um alle neuen 6.0-Features für Blazor Apps zu übernehmen, empfehlen wir den folgenden Prozess:

  • Erstellen Sie ein neues 6.0-Projekt Blazor aus einer der Blazor Projektvorlagen. Weitere Informationen finden Sie unter Tools für ASP.NET Core Blazor.
  • Verschieben Sie die Komponenten und Code der App in die 6.0-App, um die neuen 6.0-Features zu übernehmen.

Aktualisieren von Docker-Bildern

Für Apps mit Docker aktualisieren Sie Ihre Dockerfile-AnweisungenFROM und Skripts. Verwenden Sie ein Basisbild, das die ASP.NET Core 6.0-Laufzeit enthält. Berücksichtigen Sie den folgenden docker pull Befehlsunterschied zwischen ASP.NET Core 5,0 und 6.0:

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

Siehe GitHub-ProblemBruchänderung: Standard-Konsolenprotokollierformat auf JSON festgelegt.

Änderungen am ASP.NET Core Razor SDK

Der Razor Compiler nutzt jetzt die neue Quellgeneratorfunktion , um kompilierte C#-Dateien aus den Razor Ansichten und Seiten in einem Projekt zu generieren. In früheren Versionen:

  • Die Kompilierung basiert auf den RazorGenerate und RazorCompile zielen, um den generierten Code zu erzeugen. Diese Ziele sind nicht mehr gültig. In .NET 6 werden sowohl die Codegenerierung als auch die Kompilierung von einem einzigen Aufruf des Compilers unterstützt. RazorComponentGenerateDependsOn wird weiterhin unterstützt, um Abhängigkeiten anzugeben, die erforderlich sind, bevor der Build ausgeführt wird.
  • Eine separate Razor Assembly wurde generiert, AppName.Views.dlldie die kompilierten Ansichtstypen in einer Anwendung enthalten. Dieses Verhalten wurde veraltet und eine einzelne Assembly AppName.dll wird erstellt, die sowohl die App-Typen als auch die generierten Ansichten enthält.
  • Die App-Typen waren AppName.Views.dll öffentlich. In .NET 6 befinden internal sealedsich die App-Typen jedoch.AppName.dll Apps, die Typ-Erkennung durchführen, können nicht in der Lage sein, die Typ-Erkennung AppName.Views.dll zu AppName.dlltun. Im Folgenden wird die API-Änderung gezeigt:
- 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>

Nehmen Sie die folgenden Änderungen vor:

  • Die folgenden Eigenschaften gelten nicht mehr für das Einzelschritt-Kompilierungsmodell.
    • RazorTargetAssemblyAttribute
    • RazorTargetName
    • EnableDefaultRazorTargetAssemblyInfoAttributes
    • UseRazorBuildServer
    • GenerateRazorTargetAssemblyInfo
    • GenerateMvcApplicationPartsAssemblyAttributes

Weitere Informationen finden Sie unter Razor Compiler, die keine Views-Assembly mehr erstellt.

Projektvorlagen verwenden Duende Identity Server

Projektvorlagen verwenden jetzt Duende Identity Server. Anleitungen zur Migration finden Sie unter IdentityServer4 v4.1 zu Duende IdentityServer v5.

Wichtig

Duende Identity Server ist ein Open Source Produkt mit einem gegenseitigen Lizenzvertrag. Wenn Sie Den Duende Server in der Produktion verwenden möchten, müssen Sie möglicherweise eine kommerzielle Lizenz von DuendeIdentity Software erhalten und eine Lizenzgebühr bezahlen. Weitere Informationen finden Sie unter Duende Software: Lizenzen.

Informationen zum Verwenden von Microsoft Azure Active Directory für ASP.NET CoreIdentityfinden Sie unter Identity (dotnet/aspnetcore GitHub-Repository).

Fügen Sie jeder Eigenschaft einen Namen IdentityDbContextKeys hinzu, um eine DbSet<Key> neue Anforderung aus der aktualisierten Version von IPersistedGrantDbContext. Die Schlüssel sind im Rahmen des Vertrags mit duende Identity Server-Stores erforderlich.

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

Hinweis

Vorhandene Migrationen müssen für Duende Identity Server neu erstellt werden.

Codebeispiele, die zu ASP.NET Core 6.0 migriert wurden

Codebeispiele, die zum neuen minimalen Hostingmodell in 6.0 migriert wurden

Überprüfen von Änderungsänderungen

Weitere Informationen finden Sie in den folgenden Ressourcen:

Nullable-Verweistypen (NRTs) und statische Analyse des .NET-Compilers mit NULL-Status

ASP.NET Core Projektvorlagen nullable Referenztypen (NRTs) verwenden, und der .NET-Compiler führt null-zustandsstatische Analyse aus. Diese Features wurden mit C# 8 veröffentlicht und sind standardmäßig für Apps aktiviert, die mit ASP.NET Core 6.0 (C# 10) oder höher generiert wurden.

Die NULL-Zustandsanalysewarnungen des .NET-Compilers können entweder als Leitfaden zum Aktualisieren eines Dokumentationsbeispiels oder einer lokalen Beispiel-App dienen oder ignoriert werden. Die statische Analyse mit NULL-Status kann deaktiviert werden, indem in der Projektdatei der App Nullable auf disable festgelegt wird. Dies wird nur für Dokumentationsbeispiele und Beispiel-Apps empfohlen, wenn die Compilerwarnungen beim Lernen der Verwendung von .NET störend sind. Es wird nicht empfohlen, die Null-Zustandsüberprüfung in Produktionsprojekten zu deaktivieren.

Weitere Informationen zu NRTs, zur MSBuild-Eigenschaft Nullable und zum Aktualisieren von Apps (einschließlich #pragma-Anleitungen) finden Sie in den folgenden Ressourcen in der C#-Dokumentation:

ASP.NET Core Modul (ANCM)

Wenn das ASP.NET Core Modul (ANCM) keine ausgewählte Komponente war, wenn Visual Studio installiert wurde oder eine vorherige Version des ANCM-Systems installiert wurde, laden Sie das neueste .NET Core Hosting Bundle Installer (direktes Herunterladen) herunter, und führen Sie das Installationsprogramm aus. Weitere Informationen finden Sie unter Hosting Bundle.

Änderung des Anwendungsnamens

Normalisiert in .NET 6 den Inhaltsstammpfad, um mit einer DirectorySeparatorChar.NET 6 WebApplicationBuilder zu enden. Die meisten Apps, die von HostBuilderWebHostBuilder oder nicht über denselben App-Namen migriert werden, da sie nicht normalisiert sind. Weitere Informationen finden Sie unter SetApplicationName

Zusätzliche Ressourcen