Eseguire la migrazione da ASP.NET Core 3.1 a .NET 5

Questo articolo illustra come aggiornare un progetto ASP.NET Core 3.1 esistente a ASP.NET Core in .NET 5. Per istruzioni su come eseguire la migrazione da ASP.NET Core 3.1 a ASP.NET Core in .NET 6, vedere Eseguire la migrazione da ASP.NET Core 3.1 a .NET 6.

Prerequisites

Visual Studio 2019 16.8 o versione successiva con il carico di lavoro Sviluppo ASP.NET e Web
.NET 5 SDK

Aggiornare la versione di .NET SDK in global.json

Se si fa affidamento su un global.json file per specificare una versione specifica di .NET SDK, aggiornare la version proprietà alla versione di .NET 5 SDK installata. Per esempio:

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

Aggiornare il framework di destinazione

Se si aggiorna un progetto Blazor WebAssembly, passare alla sezione Aggiornare i progetti Blazor WebAssembly. Per qualsiasi altro tipo di progetto ASP.NET Core, aggiornare il file di progetto Moniker del framework di destinazione (TFM) in net5.0:

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

  <PropertyGroup>
-    <TargetFramework>netcoreapp3.1</TargetFramework>
+    <TargetFramework>net5.0</TargetFramework>
  </PropertyGroup>

</Project>

Eliminare `bin` e `obj` cartelle

Potrebbe essere necessario eliminare le bin cartelle e obj . Eseguire dotnet nuget locals --clear all per cancellare la cache dei pacchetti NuGet.

Modifiche alla Blazor logica di routing delle app nella versione 5.0.1 e versioni successive di .NET 5.x fino a .NET 6

Il calcolo della precedenza della route è stato modificato nella versione della patch 5.0.1. Questo potrebbe interessarti se hai definito route catch-all o route con parametri facoltativi.

Comportamento precedente

Con il comportamento precedente 5.0.0 o versioni precedenti, le route con precedenza inferiore, ad esempio {*slug}, vengono confrontate prima delle route con precedenza superiore, ad esempio /customer/{id}.

Nuovo comportamento

Il nuovo comportamento nella versione 5.0.1 o successiva corrisponde più strettamente al comportamento di routing definito nelle app ASP.NET Core, in cui il framework calcola e stabilisce la precedenza di route per ogni segmento per primo e usa solo la lunghezza della route per interrompere i legami come criteri secondari.

Motivo della modifica

Il comportamento originale è considerato un bug nell'implementazione perché l'obiettivo è che il Blazor sistema di routing si comporti allo stesso modo del sistema di routing ASP.NET Core per il subset di funzionalità supportate dal Blazor routing.

Azione consigliata

Aggiungi l'attributo PreferExactMatches al componente Router nel file App.razor per abilitare esplicitamente il comportamento corretto:

<Router AppAssembly="@typeof(Program).Assembly" PreferExactMatches="@true">

Quando PreferExactMatches è impostato su @true, l'abbinamento delle route preferisce corrispondenze esatte rispetto ai caratteri jolly.

Important

Tutte le app devono essere impostate in modo esplicito su PreferExactMatches@true.

La possibilità di impostare PreferExactMatches@false o lasciare non impostato è disponibile solo per la compatibilità con le versioni precedenti.

Quando viene rilasciato .NET 6, il router preferisce sempre corrispondenze esatte e l'opzione PreferExactMatches non sarà disponibile.

Aggiornare Blazor WebAssembly e Blazor Server progetti

Le indicazioni contenute in questa sezione si applicano a entrambi Blazor i modelli di hosting. Le sezioni successive a questa forniscono indicazioni aggiuntive specifiche sui modelli di hosting e sui tipi di app. Applicare le indicazioni di tutte le sezioni pertinenti all'app.

In wwwroot/index.html di un'app Blazor WebAssembly o in Pages/_Host.cshtml di un'app Blazor Server, aggiungere un elemento <link> all'elemento <head> per gli stili. Nei valori di attributo dell'elemento <link> seguentihref, il segnaposto {ASSEMBLY NAME} è il nome dell'assembly dell'app.
```
+<link href="{ASSEMBLY NAME}.styles.css" rel="stylesheet" />
```
Esempio di solo Blazor WebAssembly o Blazor Server:
```
+<link href="BlazorSample.styles.css" rel="stylesheet" />
```
Client progetto di un esempio di soluzione ospitata Blazor WebAssembly :
```
+<link href="BlazorSample.Client.styles.css" rel="stylesheet" />
```

Includi un nuovo namespace nel file delle importazioni dell'app (_Imports.razor) per la virtualizzazione dei componenti, Microsoft.AspNetCore.Components.Web.Virtualization. I seguenti file di importazione mostrano i namespace predefiniti nelle app generate dai modelli di progetto Blazor. Il segnaposto {ASSEMBLY NAME} è il nome dell'assembly dell'applicazione.

Blazor WebAssembly (_Imports.razor):

@using System.Net.Http
@using System.Net.Http.Json
@using Microsoft.AspNetCore.Components.Forms
@using Microsoft.AspNetCore.Components.Routing
@using Microsoft.AspNetCore.Components.Web
@using Microsoft.AspNetCore.Components.Web.Virtualization
@using Microsoft.AspNetCore.Components.WebAssembly.Http
@using Microsoft.JSInterop
@using {ASSEMBLY NAME}
@using {ASSEMBLY NAME}.Shared

Blazor Server (_Imports.razor):

@using System.Net.Http
@using Microsoft.AspNetCore.Authorization
@using Microsoft.AspNetCore.Components.Authorization
@using Microsoft.AspNetCore.Components.Forms
@using Microsoft.AspNetCore.Components.Routing
@using Microsoft.AspNetCore.Components.Web
@using Microsoft.AspNetCore.Components.Web.Virtualization
@using Microsoft.JSInterop
@using {ASSEMBLY NAME}
@using {ASSEMBLY NAME}.Shared

Nel componente MainLayout (Shared/MainLayout.razor), racchiudi il markup HTML del componente in un elemento <div> con l'attributo class impostato su page:
```
<div class="page">

    ...

</div>
```

Aggiungere i file seguenti alla Shared cartella :

MainLayout.razor.css:

.page {
    position: relative;
    display: flex;
    flex-direction: column;
}

.main {
    flex: 1;
}

.sidebar {
    background-image: linear-gradient(180deg, rgb(5, 39, 103) 0%, #3a0647 70%);
}

.top-row {
    background-color: #f7f7f7;
    border-bottom: 1px solid #d6d5d5;
    justify-content: flex-end;
    height: 3.5rem;
    display: flex;
    align-items: center;
}

    .top-row ::deep a, .top-row .btn-link {
        white-space: nowrap;
        margin-left: 1.5rem;
    }

    .top-row a:first-child {
        overflow: hidden;
        text-overflow: ellipsis;
    }

@media (max-width: 767.98px) {
    .top-row:not(.auth) {
        display: none;
    }

    .top-row.auth {
        justify-content: space-between;
    }

    .top-row a, .top-row .btn-link {
        margin-left: 0;
    }
}

@media (min-width: 768px) {
    .page {
        flex-direction: row;
    }

    .sidebar {
        width: 250px;
        height: 100vh;
        position: sticky;
        top: 0;
    }

    .top-row {
        position: sticky;
        top: 0;
        z-index: 1;
    }

    .main > div {
        padding-left: 2rem !important;
        padding-right: 1.5rem !important;
    }
}

NavMenu.razor.css:

.navbar-toggler {
    background-color: rgba(255, 255, 255, 0.1);
}

.top-row {
    height: 3.5rem;
    background-color: rgba(0,0,0,0.4);
}

.navbar-brand {
    font-size: 1.1rem;
}

.oi {
    width: 2rem;
    font-size: 1.1rem;
    vertical-align: text-top;
    top: -2px;
}

.nav-item {
    font-size: 0.9rem;
    padding-bottom: 0.5rem;
}

    .nav-item:first-of-type {
        padding-top: 1rem;
    }

    .nav-item:last-of-type {
        padding-bottom: 1rem;
    }

    .nav-item ::deep a {
        color: #d7d7d7;
        border-radius: 4px;
        height: 3rem;
        display: flex;
        align-items: center;
        line-height: 3rem;
    }

.nav-item ::deep a.active {
    background-color: rgba(255,255,255,0.25);
    color: white;
}

.nav-item ::deep a:hover {
    background-color: rgba(255,255,255,0.1);
    color: white;
}

@media (min-width: 768px) {
    .navbar-toggler {
        display: none;
    }

    .collapse {
        /* Never collapse the sidebar for wide screens */
        display: block;
    }
}

Il file di base wwwroot/css/app.css più recente di un'app Blazor WebAssembly o il file wwwroot/css/site.css di un'app Blazor Server include i seguenti stili. Rimuovere gli stili aggiuntivi lasciando gli stili seguenti e gli eventuali elementi aggiunti all'app.

Il foglio di stile seguente include solo gli stili di base e non include gli stili personalizzati aggiunti dallo sviluppatore:

html, body {
    font-family: 'Helvetica Neue', Helvetica, Arial, sans-serif;
}

a, .btn-link {
    color: #0366d6;
}

.btn-primary {
    color: #fff;
    background-color: #1b6ec2;
    border-color: #1861ac;
}

.content {
    padding-top: 1.1rem;
}

.valid.modified:not([type=checkbox]) {
    outline: 1px solid #26b050;
}

.invalid {
    outline: 1px solid red;
}

.validation-message {
    color: red;
}

#blazor-error-ui {
    background: lightyellow;
    bottom: 0;
    box-shadow: 0 -1px 2px rgba(0, 0, 0, 0.2);
    display: none;
    left: 0;
    padding: 0.6rem 1.25rem 0.7rem 1.25rem;
    position: fixed;
    width: 100%;
    z-index: 1000;
}

#blazor-error-ui .dismiss {
    cursor: pointer;
    position: absolute;
    right: 0.75rem;
    top: 0.5rem;
}

Note

L'esempio precedente non mostra la @import direttiva per le icone Open Iconic (open-iconic-bootstrap.css), fornita dal modello di Blazor progetto. Open Iconic è stato abbandonato dai suoi gestori.

Aggiornare progetti Blazor WebAssembly

Seguire le indicazioni nella precedente sezione Aggiornare i progetti Blazor WebAssembly e Blazor Server.

Per un progetto Blazor WebAssembly, compreso il progetto Client di una soluzione Blazor ospitata, applica le modifiche seguenti al file di progetto:

Aggiornare l'SDK da Microsoft.NET.Sdk.Web a Microsoft.NET.Sdk.BlazorWebAssembly:
```
- <Project Sdk="Microsoft.NET.Sdk.Web">
+ <Project Sdk="Microsoft.NET.Sdk.BlazorWebAssembly">
```
Note

Questo aggiornamento si applica solo ai progetti autonomi Blazor WebAssembly e ai Client progetti di soluzioni ospitate Blazor .

Aggiornare le proprietà seguenti:

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

  <PropertyGroup>
-     <TargetFramework>netstandard2.1</TargetFramework>
-     <RazorLangVersion>3.0</RazorLangVersion>
+     <TargetFramework>net5.0</TargetFramework>
  </PropertyGroup>

Rimuovere il riferimento al pacchetto a Microsoft.AspNetCore.Components.WebAssembly.Build:

<ItemGroup>
-    <PackageReference Include="Microsoft.AspNetCore.Components.WebAssembly.Build" Version="3.2.1" PrivateAssets="all" />

Aggiornare altri pacchetti alle versioni più recenti. Le versioni più recenti sono disponibili in NuGet.org.
In wwwroot/index.html, modificare l'elemento che carica il componente App con un elemento <div> con un attributo id impostato su app:
```
-<app>Loading...</app>
+<div id="app">Loading...</div>
```
In Program.Main (Program.cs), modificare il riferimento all'elemento <app> in un selettore CSS aggiungendo un hash # al selettore:
```
-builder.RootComponents.Add<App>("app");
+builder.RootComponents.Add<App>("#app");
```

In Program.Main (Program.cs), modificare una registrazione temporanea HttpClient predefinita impostando come ambito, se presente:

-builder.Services.AddTransient(sp => new HttpClient 
-    { BaseAddress = new Uri(builder.HostEnvironment.BaseAddress) });
+builder.Services.AddScoped(sp => new HttpClient 
+    { BaseAddress = new Uri(builder.HostEnvironment.BaseAddress) });

Nella Program.Main (Program.cs) dell'app Client delle soluzioni ospitate Blazor:

Facoltativamente, sostituire le stringhe degli indirizzi di base client con builder.HostEnvironment.BaseAddress.
Cambiare in scoped tutte le registrazioni denominate della factory client transient.

-builder.Services.AddHttpClient("{APP NAMESPACE}.ServerAPI", 
-    client => client.BaseAddress = new Uri("https://localhost:5001"))
-    .AddHttpMessageHandler<BaseAddressAuthorizationMessageHandler>();
-builder.Services.AddTransient(sp => sp.GetRequiredService<IHttpClientFactory>()
-    .CreateClient("{APP NAMESPACE}.ServerAPI"));
+builder.Services.AddHttpClient("{APP NAMESPACE}.ServerAPI", 
+    client => client.BaseAddress = new Uri(builder.HostEnvironment.BaseAddress))
+    .AddHttpMessageHandler<BaseAddressAuthorizationMessageHandler>();
+builder.Services.AddScoped(sp => sp.GetRequiredService<IHttpClientFactory>()
+    .CreateClient("{APP NAMESPACE}.ServerAPI"));

Nel codice precedente, il segnaposto {APP NAMESPACE} è lo spazio dei nomi dell'app.

App indipendente Blazor WebAssembly con gli account Microsoft

Attenersi alle indicazioni riportate nelle precedenti sezioni Aggiornare i progetti Blazor WebAssembly e Blazor Server e Aggiornare i progetti Blazor WebAssembly.

Per un'app autonoma Blazor WebAssembly registrata nel portale di Azure usare Microsoft Entra ID (ME-ID) per gli account Microsoft:

L'app richiede gli openid ambiti e offline_access :

options.ProviderOptions.DefaultAccessTokenScopes.Add("openid");
options.ProviderOptions.DefaultAccessTokenScopes.Add("offline_access");

Nella sezione Authentication della registrazione dell'app nel portale di Azure:
1. Rimuovere la configurazione della piattaforma Web .
2. Aggiungi una configurazione della piattaforma Single-page application con l'URI di reindirizzamento dell'app.
3. Disabilitare la concessione implicita per token di accesso e token ID.

Per altre informazioni, vedere Proteggere un'app autonoma di ASP.NET Core Blazor WebAssembly con gli account Microsoft.

App indipendente Blazor WebAssembly con Microsoft Entra ID (ME-ID)

Seguire le indicazioni riportate nelle sezioni precedenti Aggiornare i progetti Blazor WebAssembly e Blazor Server e Aggiornare i progetti Blazor WebAssembly.

Per un'app autonoma Blazor WebAssembly registrata nel portale di Azure usare Microsoft Entra ID (ME-ID):

L'app richiede l'ambito https://graph.microsoft.com/User.Read :

options.ProviderOptions.DefaultAccessTokenScopes
    .Add("https://graph.microsoft.com/User.Read");

Nel pannello Authentication della registrazione dell'app nel portale di Azure:
1. Rimuovere la configurazione della piattaforma Web .
2. Aggiungi una configurazione della piattaforma Applicazione a pagina singola con l'URI di reindirizzamento dell'app.
3. Disabilitare la concessione implicita per token di accesso e token ID.

Per altre informazioni, vedere Proteggere un'app autonoma di ASP.NET Core Blazor WebAssembly con Microsoft Entra ID.

App autonoma Blazor WebAssembly con Azure Active Directory (AAD) B2C

Seguire le indicazioni nelle sezioni precedenti Aggiornare i progetti Blazor WebAssembly e Blazor Server e Aggiornare i progetti Blazor WebAssembly.

Per un'app autonoma Blazor WebAssembly registrata nel portale di Azure usare Azure Active Directory (AAD) B2C:

L'app richiede gli openid ambiti e offline_access :

options.ProviderOptions.DefaultAccessTokenScopes.Add("openid");
options.ProviderOptions.DefaultAccessTokenScopes.Add("offline_access");

Nel pannello Autenticazione della registrazione dell'app nel portale di Azure:
1. Rimuovere la configurazione della piattaforma Web .
2. Aggiungere una configurazione della piattaforma dell'applicazione a pagina singola con l'URI di reindirizzamento dell'app.
3. Disabilitare la concessione implicita per token di accesso e token ID.

Per altre informazioni, vedere Proteggere un'app autonoma ASP.NET Core Blazor WebAssembly con Azure Active Directory B2C.

App ospitata Blazor WebAssembly con Microsoft Entra ID (ME-ID) o AAD B2C

Seguire le indicazioni fornite nelle sezioni precedenti Aggiornare i progetti Blazor WebAssembly e Blazor Server e Aggiornare i progetti Blazor WebAssembly.

La registrazione dell'applicazione Client di una soluzione ospitata Blazor che usa AAD o AAD B2C per l'autenticazione degli utenti deve usare una configurazione della piattaforma App di Azure per applicazione a pagina singola.

Nel pannello ClientAutenticazione di Registrazione app nel portale di Azure:

Rimuovere la configurazione della piattaforma Web .
Aggiungere una configurazione della piattaforma Single-page application specificando l'URI di reindirizzamento dell'app.
Disabilitare la concessione implicita per token di accesso e token ID.

Per altre informazioni, vedi:

Aggiornare il progetto Server di una soluzione ospitata Blazor

Seguire le indicazioni riportate nelle sezioni precedenti:

Aggiornare Blazor WebAssembly e Blazor Server progetti
Aggiornare Blazor WebAssembly i progetti
Sezione applicabile al provider dell'app con Azure Active Directory:

Aggiornare il progetto Server di una soluzione Blazor ospitata come app di ASP.NET Core, seguendo le indicazioni generali fornite in questo articolo.

Inoltre, Server i progetti che autenticano gli utenti alle app client Blazor WebAssembly con Microsoft Entra ID (ME-ID) o B2C devono adottare nuovi pacchetti Microsoft Identity v2.0:

Per AAD:

-<PackageReference Include="Microsoft.AspNetCore.Authentication.AzureAD.UI" Version="..." />
+<PackageReference Include="Microsoft.Identity.Web" Version="{VERSION}" />
+<PackageReference Include="Microsoft.Identity.Web.UI" Version="{VERSION}" />

Per AAD B2C:

-<PackageReference Include="Microsoft.AspNetCore.Authentication.AzureADB2C.UI" Version="..." />
+<PackageReference Include="Microsoft.Identity.Web" Version="{VERSION}" />
+<PackageReference Include="Microsoft.Identity.Web.UI" Version="{VERSION}" />

Per i riferimenti ai pacchetti precedenti, determinare le versioni dei pacchetti per i segnaposto {VERSION} su NuGet.org:

Note

L'SDK del progetto Server in una soluzione Blazor WebAssembly ospitata rimane Microsoft.NET.Sdk.Web:

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

Per altre informazioni, vedi:

Pulire e ricompilare la soluzione

Dopo la migrazione dell'app o della soluzione a .NET 5, pulire e ricompilare l'app o la soluzione. Se esistono incompatibilità dei pacchetti tra i nuovi riferimenti al pacchetto e i pacchetti memorizzati nella cache:

Cancellare le cache dei pacchetti NuGet eseguendo il comando seguente dotnet nuget locals in una shell dei comandi:
```
dotnet nuget locals --clear all
```
Pulire e ricompilare l'app o la soluzione.

Troubleshoot

Seguire le indicazioni sulla risoluzione dei problemi alla fine dell'argomento Blazor WebAssembly sulla sicurezza applicabile all'app:

App Blazor WebAssembly indipendenti:

App Blazor WebAssembly ospitate:

Client non autorizzato per Microsoft Entra ID (ME-ID)

Dopo l'aggiornamento di un'app Blazor WebAssembly che usa AAD per l'autenticazione, è possibile che venga visualizzato l'errore seguente nel callback di accesso all'app dopo l'accesso dell'utente con AAD:

info: Microsoft.AspNetCore.Authorization.DefaultAuthorizationService[2] Autorizzazione non riuscita. Questi requisiti non sono stati soddisfatti: DenyAnonymousAuthorizationRequirement: richiede un utente autenticato.

Errore nel callback di accesso da AAD:

Errore: unauthorized_client
Description (Descrizione): AADB2C90058: The provided application is not configured to allow public clients.

Per risolvere l'errore:

Nella portale di Azure accedere al manifesto dell'app.
Impostare l'attributo allowPublicClient su null o true.

Aggiornare un'applicazione Blazor Web progressiva (PWA)

Aggiungere l'elemento seguente al file di progetto dell'app PWA:

<ItemGroup>
  <ServiceWorker Include="wwwroot\service-worker.js" 
    PublishedContent="wwwroot\service-worker.published.js" />
</ItemGroup>

Rimuovere il collegamento del foglio di stile per l'isolamento CSS di anteprima

Se il file wwwroot/index.html (Blazor WebAssembly) o Pages/_Host.cshtml (Blazor Server) del progetto contiene un elemento <link> del foglio di stile per scoped.styles.css di una versione di anteprima precedente di 5.0, rimuovere il tag <link>:

-<link href="_framework/scoped.styles.css/" rel="stylesheet" />

Aggiornare Razor le librerie di classi (RCL)

Eseguire la migrazione Razor delle librerie di classi (RCLs) per sfruttare le nuove API o le nuove funzionalità introdotte come parte di ASP.NET Core in .NET 5.

Per aggiornare un RCL destinato ai componenti:

Aggiornare le proprietà seguenti nel file di progetto:

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

  <PropertyGroup>
-     <TargetFramework>netstandard2.0</TargetFramework>
-     <RazorLangVersion>3.0</RazorLangVersion>
+     <TargetFramework>net5.0</TargetFramework>
  </PropertyGroup>

Aggiornare altri pacchetti alle versioni più recenti. Le versioni più recenti sono disponibili in NuGet.org.

Per aggiornare un RCL destinato a MVC, aggiornare le proprietà seguenti nel file di progetto:

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

  <PropertyGroup>
-    <TargetFramework>netcoreapp3.1</TargetFramework>
+    <TargetFramework>net5.0</TargetFramework>
    <AddRazorSupportForMvc>true</AddRazorSupportForMvc>
  </PropertyGroup>

Aggiornare i riferimenti del pacchetto

Nel file di progetto, aggiorna l'attributo di ogni riferimento di pacchetto Microsoft.AspNetCore.*, Microsoft.EntityFrameworkCore.*, Microsoft.Extensions.* e System.Net.Http.Json alla versione 5.0.0 o successiva. Per esempio:

<ItemGroup>
-    <PackageReference Include="Microsoft.AspNetCore.JsonPatch" Version="3.1.6" />
-    <PackageReference Include="Microsoft.EntityFrameworkCore.Tools" Version="3.1.6">
-    <PackageReference Include="Microsoft.Extensions.Caching.Abstractions" Version="3.1.6" />
-    <PackageReference Include="System.Net.Http.Json" Version="3.2.1" />
+    <PackageReference Include="Microsoft.AspNetCore.JsonPatch" Version="5.0.0" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Tools" Version="5.0.0">
+    <PackageReference Include="Microsoft.Extensions.Caching.Abstractions" Version="5.0.0" />
+    <PackageReference Include="System.Net.Http.Json" Version="5.0.0" />
</ItemGroup>

Aggiornare le immagini Docker

Per le app che usano Docker, aggiornare le istruzioni e gli script DockerfileFROM. Usare un'immagine di base che include il runtime .NET 5. Si consideri la differenza di comando seguente docker pull tra ASP.NET Core 3.1 e .NET 5:

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

Come parte del passaggio a ".NET" come nome del prodotto, le immagini Docker sono state spostate dai repository mcr.microsoft.com/dotnet/core a mcr.microsoft.com/dotnet. Per altre informazioni, vedere dotnet/dotnet-docker#1939.

Modifiche all'associazione di modelli in ASP.NET Core MVC e Razor pages

I valori DateTime sono associati al modello come ore UTC

In ASP.NET Core 3.1 o versioni precedenti, DateTime i valori sono associati al modello come ora locale, in cui il fuso orario è stato determinato dal server. DateTime i valori sono stati interpretati in base al formato di input (JSON) e DateTimeOffset i valori sono stati interpretati nel fuso orario UTC.

In .NET 5 o versione successiva, l'associazione di modelli associa in modo coerente i DateTime valori al fuso orario UTC.

Per mantenere il comportamento precedente, rimuovere DateTimeModelBinderProvider in Startup.ConfigureServices:

services.AddControllersWithViews(options => 
    options.ModelBinderProviders.RemoveType<DateTimeModelBinderProvider>());

ComplexObjectModelBinderProvider \ ComplexObjectModelBinder sostituisce ComplexTypeModelBinderProvider \ ComplexTypeModelBinder

Per aggiungere il supporto per l'associazione dei modelli ai tipi record C# 9, ComplexTypeModelBinderProvider è:

Annotato come obsoleto.
Non più registrato per impostazione predefinita.

Le applicazioni che si basano sulla presenza di ComplexTypeModelBinderProvider nella raccolta ModelBinderProviders devono fare riferimento al nuovo provider binder:

- var complexModelBinderProvider = options.ModelBinderProviders.OfType<ComplexTypeModelBinderProvider>();
+ var complexModelBinderProvider = options.ModelBinderProviders.OfType<ComplexObjectModelBinderProvider>();

UseDatabaseErrorPage obsoleto

I modelli ASP.NET Core 3.1 che includono un'opzione per i singoli account utente generano una chiamata a UseDatabaseErrorPage. UseDatabaseErrorPage è ora obsoleto e deve essere sostituito con una combinazione di AddDatabaseDeveloperPageExceptionFilter e UseMigrationsEndPoint, come illustrato nel codice seguente:

public void ConfigureServices(IServiceCollection services)
{
    services.AddDbContext<ApplicationDbContext>(options =>
        options.UseSqlServer(
            Configuration.GetConnectionString("DefaultConnection")));
+   services.AddDatabaseDeveloperPageExceptionFilter();
    services.AddDefaultIdentity<IdentityUser>(options => options.SignIn.RequireConfirmedAccount = true)
        .AddEntityFrameworkStores<ApplicationDbContext>();
    services.AddRazorPages();
}

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    if (env.IsDevelopment())
    {
        app.UseDeveloperExceptionPage();
+       app.UseMigrationsEndPoint();
-       app.UseDatabaseErrorPage();
    }
    else
    {
        app.UseExceptionHandler("/Error");
        app.UseHsts();
    }

Per altre informazioni, vedere questo problema in GitHub.

Modulo ASP.NET Core (ANCM)

Se la ASP.NET Core Module (ANCM) non è un componente selezionato quando Visual Studio è stato installato o se è stata installata una versione precedente di ANCM nel sistema, scaricare l'ultimo programma di installazione del bundle di hosting .NET Core (download diretto) ed eseguire il programma di installazione. Per altre informazioni, vedere Bundle di hosting.

Modifiche di riferimento ai pacchetti che interessano alcuni pacchetti NuGet

Con la migrazione di alcuni Microsoft.Extensions.* pacchetti NuGet dal repository dotnet/extensions a dotnet/runtime, come descritto in Migrazione del contenuto dotnet/extensions a dotnet/runtime e dotnet/aspnetcore (aspnet/Announcements #411), le modifiche alla creazione di pacchetti vengono applicate ad alcuni dei pacchetti migrati. Queste modifiche comportano spesso modifiche dello spazio dei nomi per l'API .NET.

Per cercare ulteriormente le API per le modifiche dello spazio dei nomi delle app durante la migrazione a .NET 5, usare il browser API .NET.

Eseguire la migrazione di Microsoft.IdentityWeb

Le pagine wiki seguenti illustrano come eseguire la migrazione di Microsoft.Identity. Web da ASP.NET Core 3.1 a .NET 5:

Le esercitazioni seguenti illustrano anche la migrazione:

Un'app Web ASP.NET Core che autentica gli utenti con la piattaforma Microsoft Identity nella tua organizzazione. Vedere Opzione 2: Creare l'esempio dalla riga di comando.
Effettuare l'accesso di un utente alla piattaforma Microsoft Identity in un'applicazione desktop macchine virtuali Windows e chiamare un'API Web ASP.NET Core. Vedere Come è stato creato il codice.

Modifiche radicali

Usare gli articoli in Modifiche di rilievo in .NET per trovare modifiche di rilievo che potrebbero essere applicate durante l'aggiornamento di un'app a una versione più recente di .NET.

Commenti e suggerimenti

Questa pagina è stata utile?

Ultimo aggiornamento: 2026-10-10