Eseguire la migrazione da ASP.NET Core 3.1 a 5.0

Di Scott Addie

Questo articolo illustra come aggiornare un progetto ASP.NET Core 3.1 esistente ASP.NET Core 5.0.

Prerequisiti

Aggiornare la versione di .NET Core SDK in global.json

Se si fa affidamento su unglobal.js su file per una versione di .NET Core SDK specifica, aggiornare la proprietà alla versione di version .NET 5.0 SDK installata. Esempio:

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

Aggiornare il framework di destinazione

Se si aggiorna Blazor WebAssembly un progetto, passare alla sezione Aggiorna Blazor WebAssembly progetti. Per qualsiasi altro ASP.NET di progetto Core, aggiornare il moniker del framework di destinazione (TFM) del file di progetto su 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 obj e . 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 altre versioni 5.x fino alla 6.0

Il calcolo della precedenza della route è stato modificato nella ASP.NET della patch core 5.0.1. Ciò potrebbe influire se sono stati definiti route catch-all o route con parametri facoltativi.

Comportamento precedente

Con il comportamento precedente in ASP.NET Core 5.0.0 o versioni precedenti, le route con precedenza inferiore, ad esempio , vengono abbinate prima delle route con precedenza maggiore, ad esempio {*slug} /customer/{id} .

Nuovo comportamento

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

Motivo della modifica

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

Aggiungere PreferExactMatches l'attributo Router al componente nel file per App.razor acconsentire esplicitamente al comportamento corretto:

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

Quando PreferExactMatches è impostato su , la corrispondenza delle route preferisce le @true corrispondenze esatte rispetto ai caratteri jolly.

Importante

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

La possibilità di impostare su o lasciarla non impostata viene fornita solo per la compatibilità PreferExactMatches @false con le versioni precedenti.

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

Aggiornare Blazor WebAssembly i Blazor Server progetti e

Le indicazioni fornite in questa sezione si applicano a entrambi i Blazor modelli di hosting. Le sezioni che seguono questa sezione forniscono indicazioni aggiuntive specifiche per l'hosting di modelli e tipi di app. Applicare all'app le indicazioni di tutte le sezioni pertinenti.

  1. In wwwroot/index.html di Blazor WebAssembly un'app o di Pages/_Host.cshtml Blazor Server un'app aggiungere un <link> elemento all'elemento per gli <head> stili. Nei valori di <link> attributo href dell'elemento seguenti il segnaposto {ASSEMBLY NAME} è il nome dell'assembly dell'app.

    +<link href="{ASSEMBLY NAME}.styles.css" rel="stylesheet" />
    

    Autonomo o Blazor WebAssembly Blazor Server di esempio:

    +<link href="BlazorSample.styles.css" rel="stylesheet" />
    

    Client Progetto di un esempio di Blazor WebAssembly soluzione ospitata:

    +<link href="BlazorSample.Client.styles.css" rel="stylesheet" />
    
  2. Includere un nuovo spazio dei nomi nel file dell'app _Imports.razor per la virtualizzazione dei componenti, Microsoft.AspNetCore.Components.Web.Virtualization . I file _Imports.razor seguenti mostrano gli spazi dei nomi predefiniti nelle app generate dai modelli di Blazor progetto. Il {ASSEMBLY NAME} segnaposto è il nome dell'assembly dell'app.

    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
    
  3. Nel componente MainLayout ( ) racchiudere il markup HTML del componente con un elemento Shared/MainLayout.razor con un attributo impostato su <div> class page :

    <div class="page">
    
        ...
    
    </div>
    
  4. 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;
        }
    }
    
  5. Il file di base wwwroot/css/app.css più recente di Blazor WebAssembly un'app wwwroot/css/site.css o di un file di Blazor Server un'app include gli stili seguenti. Rimuovere gli stili aggiuntivi lasciando gli stili seguenti e tutti gli stili aggiunti all'app.

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

    @import url('open-iconic/font/css/open-iconic-bootstrap.min.css');
    
    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;
    }
    

Aggiornare Blazor WebAssembly i progetti

Seguire le indicazioni riportate nella sezione Precedente Blazor WebAssembly Aggiornare Blazor Server e progetti.

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

  1. 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">
    

    Nota

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

  2. Aggiornare le proprietà seguenti:

    <Project Sdk="Microsoft.NET.Sdk.BlazorWebAssembly">
    
      <PropertyGroup>
    -     <TargetFramework>netstandard2.1</TargetFramework>
    -     <RazorLangVersion>3.0</RazorLangVersion>
    +     <TargetFramework>net5.0</TargetFramework>
      </PropertyGroup>
    
  3. 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" />
    
  4. Aggiornare gli altri pacchetti alle versioni più recenti. Le versioni più recenti sono disponibili in NuGet.org.

  5. In wwwroot/index.html modificare l'elemento che carica il App componente in un elemento con un oggetto impostato su <div> id app :

    -<app>Loading...</app>
    +<div id="app">Loading...</div>
    
  6. In Program.Main ( ) modificare il riferimento Program.cs <app> all'elemento in un selettore CSS aggiungendo un # hash:

    -builder.RootComponents.Add<App>("app");
    +builder.RootComponents.Add<App>("#app");
    
  7. In Program.Main ( ) modificare una registrazione temporanea predefinita in con Program.cs HttpClient 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) });
    
  8. In Program.Main ( Program.cs ) Client dell'app di soluzioni Blazor ospitate:

    • Facoltativamente, sostituire builder.HostEnvironment.BaseAddress gli indirizzi di base del client stringa.
    • Modificare le registrazioni di client factory temporanee denominate in con ambito.
    -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 è lo spazio {APP NAMESPACE} dei nomi dell'app.

App Blazor WebAssembly autonoma con account Microsoft

Seguire le indicazioni nelle sezioni Update Blazor WebAssembly e projects Blazor Server e Update projects Blazor WebAssembly precedenti.

Per Blazor WebAssembly un'app autonoma registrata nel portale di Azure usare Azure Active Directory (AAD) per gli account Microsoft:

  • L'app richiede openid gli offline_access ambiti e :

    options.ProviderOptions.DefaultAccessTokenScopes.Add("openid");
    options.ProviderOptions.DefaultAccessTokenScopes.Add("offline_access");
    
  • Nel pannello autenticazione portale di Azure registrazione dell'app:

    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 i token di accesso e i token ID.

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

App Blazor WebAssembly autonoma con Azure Active Directory (AAD)

Seguire le indicazioni riportate nelle sezioni Update Blazor WebAssembly and projects Blazor Server (Aggiorna e progetti) e Update projects Blazor WebAssembly (Aggiorna progetti).

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

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

    options.ProviderOptions.DefaultAccessTokenScopes
        .Add("https://graph.microsoft.com/User.Read");
    
  • Nel pannello Autenticazione portale di Azure registrazione dell'app:

    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 i token di accesso e i token ID.

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

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

Seguire le indicazioni riportate nelle sezioni Update Blazor WebAssembly and projects Blazor Server (Aggiorna e progetti) e Update projects Blazor WebAssembly (Aggiorna progetti).

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

  • L'app richiede openid gli offline_access ambiti e :

    options.ProviderOptions.DefaultAccessTokenScopes.Add("openid");
    options.ProviderOptions.DefaultAccessTokenScopes.Add("offline_access");
    
  • Nel pannello Autenticazione portale di Azure registrazione dell'app:

    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 i token di accesso e i token ID.

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

App Blazor WebAssembly ospitata con Azure Active Directory (AAD) o AAD B2C

Seguire le indicazioni riportate nelle sezioni Update Blazor WebAssembly and projects Blazor Server (Aggiorna e progetti) e Update projects Blazor WebAssembly (Aggiorna progetti).

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

Nel pannello autenticazione portale di Azure Client registrazione dell'app:

  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 i token di accesso e i token ID.

Per altre informazioni, vedere:

Aggiornare il progetto Server di una soluzione Blazor ospitata

Seguire le indicazioni nelle sezioni precedenti:

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

Inoltre, i progetti che autenticano gli utenti nelle app Server client Blazor WebAssembly con Azure Active Directory (AAD) 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 del pacchetto per i {VERSION} segnaposto NuGet.org:

Nota

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

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

Per altre informazioni, vedere:

Pulire e ricompilare la soluzione

Dopo aver migrato l'app o la soluzione a .NET 5, pulire e ricompilare l'app o la soluzione. Se esistono incompatibilità tra i nuovi riferimenti ai pacchetti e i pacchetti memorizzati nella cache:

  1. Cancellare le cache dei pacchetti NuGet eseguendo il comando dotnet nuget locals seguente in una shell dei comandi:

    dotnet nuget locals --clear all
    
  2. Pulire e ricompilare l'app o la soluzione.

Risolvere problemi

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

App Blazor WebAssembly autonome:

App Blazor WebAssembly ospitate:

Client non autorizzato per Azure Active Directory (AAD)

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

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

Errore di callback di accesso da AAD:

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

Per risolvere l'errore:

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

Aggiornare Blazor un'applicazione Web progressiva

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>

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

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

Aggiornare Razor le librerie di classi (CRL)

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

Per aggiornare un elenco di controllo di accesso destinato ai componenti:

  1. 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>
    
  2. Aggiornare gli altri pacchetti alle versioni più recenti. Le versioni più recenti sono disponibili in NuGet.org.

Per aggiornare un elenco di controllo di accesso con destinazione 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 aggiornare ogni attributo Microsoft.AspNetCore.*, Microsoft.EntityFrameworkCore.*, Microsoft.Extensions.*e System.Net.Http.Js nell'attributo del riferimento al pacchetto alla Version versione 5.0.0 o successiva. 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 Dockerfile. FROM Usare un'immagine di base che include il runtime ASP.NET Core 5.0. Si consideri la differenza di comando docker pull seguente tra ASP.NET Core 3.1 e 5.0:

- 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 spostate dai mcr.microsoft.com/dotnet/core repository a mcr.microsoft.com/dotnet . Per altre informazioni, vedere dotnet/dotnet-docker#1939.

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

I valori DateTime sono associati al modello come ore UTC

In ASP.NET Core 3.1 e versioni precedenti, i valori erano associati al modello come ora locale, in cui il fuso orario era DateTime determinato dal server. DateTime I valori associati dalla formattazione di input (JSON) DateTimeOffset e i valori sono stati associati come fuso orario UTC.

In ASP.NET Core 5.0 e versioni successive, l'associazione di modelli associa in modo coerente i valori DateTime 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 i tipi di record C# 9 dell'associazione dimodelli, ComplexTypeModelBinderProvider è:

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

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

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

UseDatabaseErrorPage obsoleto

I 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 AddDatabaseDeveloperPageExceptionFilter combinazione di 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 di GitHub.

Esaminare le modifiche di rilievo

Per le modifiche di rilievo da .NET Core 3.1 a .NET 5.0, vedere Modifiche di rilievo per la migrazione dalla versione 3.1 alla 5.0. ASP.NET Core e Entity Framework Core sono inclusi nell'elenco.