Condividi tramite

Eseguire la migrazione da ASP.NET Core in .NET 7 a .NET 8

  • Articolo

Questo articolo illustra come aggiornare un progetto ASP.NET Core 7.0 esistente a ASP.NET Core 8.0.

Prerequisiti

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 Core SDK, aggiornare la version proprietà alla versione di .NET 8.0 SDK installata. Ad esempio:

{
  "sdk": {
-    "version": "7.0.100"
+    "version": "8.0.100"
  }
}

Aggiornare il framework di destinazione

Aggiornare il moniker del framework di destinazione del file di progetto (TFM) a net8.0:

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

  <PropertyGroup>
-    <TargetFramework>net7.0</TargetFramework>
+    <TargetFramework>net8.0</TargetFramework>
  </PropertyGroup>

</Project>

Aggiornare i riferimenti del pacchetto

Nel file di progetto aggiornare ogni Microsoft.AspNetCore.*attributo di riferimento al pacchetto Version , Microsoft.EntityFrameworkCore.*Microsoft.Extensions.*, e System.Net.Http.Json a 8.00 o versione successiva. Ad esempio:

<ItemGroup>
-   <PackageReference Include="Microsoft.AspNetCore.JsonPatch" Version="7.0.12" />
-   <PackageReference Include="Microsoft.EntityFrameworkCore.Tools" Version="7.0.12" />
-   <PackageReference Include="Microsoft.Extensions.Caching.Abstractions" Version="7.0.0" />
-   <PackageReference Include="System.Net.Http.Json" Version="7.0.1" />
+   <PackageReference Include="Microsoft.AspNetCore.JsonPatch" Version="8.0.0" />
+   <PackageReference Include="Microsoft.EntityFrameworkCore.Tools" Version="8.0.0" />
+   <PackageReference Include="Microsoft.Extensions.Caching.Abstractions" Version="8.0.0" />
+   <PackageReference Include="System.Net.Http.Json" Version="8.0.0" />
</ItemGroup>

Blazor

Vengono illustrati gli scenari di migrazione seguenti:

Per indicazioni sull'aggiunta Blazor del supporto a un'app ASP.NET Core, vedere Integrare componenti ASP.NET Core Razor in app ASP.NET Core.

Aggiornare un'app Blazor Server

È consigliabile usare Blazor App Web in .NET 8, ma Blazor Server è supportato. Per continuare a usare Blazor Server con .NET 8, seguire le indicazioni riportate nelle prime tre sezioni di questo articolo:

Le nuove Blazor funzionalità introdotte per Blazor App Web non sono disponibili per un'app Blazor Server aggiornata per l'esecuzione in .NET 8. Per adottare le nuove funzionalità di .NET 8 Blazor , seguire le indicazioni riportate in una delle sezioni seguenti:

Adottare tutte le Blazor convenzioni di app Web

Per adottare facoltativamente tutte le nuove Blazor convenzioni dell'app Web, è consigliabile eseguire il processo seguente:

  • Creare una nuova app dal modello di Blazor progetto App Web. Per altre informazioni, vedere Strumenti per ASP.NET Core Blazor.
  • Spostare i componenti e il codice dell'app nella nuova Blazor app Web, apportando modifiche per adottare nuove funzionalità.
  • Aggiornare il layout e gli stili dell'app Blazor Web.

Le nuove funzionalità di .NET 8 sono illustrate in Novità di ASP.NET Core 8.0. Quando si aggiorna un'app da .NET 6 o versioni precedenti, vedere le note sulla migrazione e sulla versione (articoli novità ) per le versioni intermedie.

Convertire un'app Blazor Server in un'app Blazor Web

Blazor Server Le app sono supportate in .NET 8 senza modifiche al codice. Usare le indicazioni seguenti per convertire un'app Blazor Server in un'app Web .NET 8 Blazor equivalente, che rende disponibili tutte le nuove funzionalità di .NET 8.

Importante

Questa sezione è incentrata sulle modifiche minime necessarie per convertire un'app .NET 7 Blazor Server in un'app Web .NET 8 Blazor . Per adottare tutte le nuove Blazor convenzioni dell'app Web, seguire le indicazioni riportate nella sezione Adottare tutte le Blazor convenzioni di app Web.

  1. Seguire le indicazioni riportate nelle prime tre sezioni di questo articolo:

  2. Spostare il contenuto del App componente () in un nuovo Routes file di componente (Routes.razorApp.razor) aggiunto alla cartella radice del progetto. Lasciare il file vuoto App.razor nell'app nella cartella radice del progetto.

  3. Aggiungere una voce al _Imports.razor file per rendere disponibili le modalità di rendering abbreviate per l'app:

    @using static Microsoft.AspNetCore.Components.Web.RenderMode

  4. Spostare il contenuto nella _Host pagina (Pages/_Host.cshtml) nel file vuoto App.razor . Procedere con le modifiche seguenti al App componente.

    Nota

    Nell'esempio seguente lo spazio dei nomi del progetto è BlazorServerApp. Modificare lo spazio dei nomi in modo che corrisponda al progetto.

    Rimuovere le righe seguenti dall'inizio del file:

    - @page "/"
- @using Microsoft.AspNetCore.Components.Web
- @namespace BlazorServerApp.Pages
- @addTagHelper *, Microsoft.AspNetCore.Mvc.TagHelpers

    Sostituire le righe precedenti con una riga che inserisce un'istanza IHostEnvironment :

    @inject IHostEnvironment Env

    Rimuovere la tilde (~) dal href tag e sostituire con il percorso di base per l'app <base> :

    - <base href="~/" />
+ <base href="/" />

    Rimuovere l'helper tag del componente per il HeadOutlet componente e sostituirlo con il HeadOutlet componente .

    Rimuovere la riga seguente:

    - <component type="typeof(HeadOutlet)" render-mode="ServerPrerendered" />

    Sostituire la riga precedente con quanto segue:

    <HeadOutlet @rendermode="InteractiveServer" />

    Rimuovere l'helper tag del componente per il App componente e sostituirlo con il Routes componente .

    Rimuovere la riga seguente:

    - <component type="typeof(App)" render-mode="ServerPrerendered" />

    Sostituire la riga precedente con quanto segue:

    <Routes @rendermode="InteractiveServer" />

    Nota

    La configurazione precedente presuppone che i componenti dell'app adottino il rendering interattivo del server. Per altre informazioni, tra cui come adottare il rendering lato server statico (SSR), vedere ASP.NET modalità di rendering coreBlazor.

    Rimuovere gli helper tag di ambiente per l'interfaccia utente degli errori e sostituirli con il markup seguente Razor .

    Rimuovere le righe seguenti:

    - <environment include="Staging,Production">
-     An error has occurred. This application may no longer respond until reloaded.
- </environment>
- <environment include="Development">
-     An unhandled exception has occurred. See browser dev tools for details.
- </environment>

    Sostituire le righe precedenti con quanto segue:

    @if (Env.IsDevelopment())
{
    <text>
        An unhandled exception has occurred. See browser dev tools for details.
    </text>
}
else
{
    <text>
        An error has occurred. This app may no longer respond until reloaded.
    </text>
}

    Modificare lo Blazor script da blazor.server.js a blazor.web.js:

    - <script src="_framework/blazor.server.js"></script>
+ <script src="_framework/blazor.web.js"></script>

  5. Eliminare il file Pages/_Host.cshtml.

  6. AggiornamentoProgram.cs:

    Nota

    Nell'esempio seguente lo spazio dei nomi del progetto è BlazorServerApp. Modificare lo spazio dei nomi in modo che corrisponda al progetto.

    Aggiungere un'istruzione using all'inizio del file per lo spazio dei nomi del progetto:

    using BlazorServerApp;

    Sostituire AddServerSideBlazor con AddRazorComponents e una chiamata concatenato a AddInteractiveServerComponents.

    Rimuovere la riga seguente:

    - builder.Services.AddServerSideBlazor();

    Sostituire la riga precedente con Razor i servizi componente e componenti server interattivi. La chiamata AddRazorComponents aggiunge servizi antiforgery () perAddAntiforgery impostazione predefinita.

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

    Rimuovere la riga seguente:

    - app.MapBlazorHub();

    Sostituire la riga precedente con una chiamata a MapRazorComponents, specificando il App componente come tipo di componente radice e aggiungendo una chiamata concatenato a AddInteractiveServerRenderMode:

    app.MapRazorComponents<App>()
    .AddInteractiveServerRenderMode();

    Rimuovere la riga seguente:

    - app.MapFallbackToPage("/_Host");

    Aggiungere il middleware antiforgery alla pipeline di elaborazione delle richieste dopo la chiamata a app.UseRouting. Se sono presenti chiamate a app.UseRouting e app.UseEndpoints, la chiamata a app.UseAntiforgery deve passare tra di esse. Una chiamata a app.UseAntiforgery deve essere effettuata dopo le chiamate a app.UseAuthentication e app.UseAuthorization. Non è necessario aggiungere servizi antiforgery (builder.Services.AddAntiforgery()), perché vengono aggiunti automaticamente da AddRazorComponents, che è stato trattato in precedenza.

    app.UseAntiforgery();

  7. Se l'app Blazor Server è stata configurata per disabilitare il prerendering, è possibile continuare a disabilitare la prerendering per l'app aggiornata. App Nel componente modificare il valore assegnato agli attributi della @rendermodeRazor direttiva per i HeadOutlet componenti e Routes .

    Modificare il valore dell'attributo @rendermode di direttiva per entrambi i componenti e Routes per disabilitare la HeadOutlet prerendering:

    - @rendermode="InteractiveServer"
+ @rendermode="new InteractiveServerRenderMode(prerender: false)"

    Per altre informazioni, vedere ASP.NET Modalità di rendering coreBlazor.

Aggiornare un'app Blazor WebAssembly

Seguire le indicazioni riportate nelle prime tre sezioni di questo articolo:

Convertire un'app ospitata Blazor WebAssembly in un'app Blazor Web

Blazor WebAssembly Le app sono supportate in .NET 8 senza modifiche al codice. Usare le indicazioni seguenti per convertire un'app ospitata Blazor WebAssembly ASP.NET Core in un'app Web .NET 8 Blazor equivalente, che rende disponibili tutte le nuove funzionalità di .NET 8.

Importante

Questa sezione è incentrata sulle modifiche minime necessarie per convertire un'app ospitata Blazor WebAssembly .NET 7 ASP.NET Core in un'app Web .NET 8 Blazor . Per adottare tutte le nuove Blazor convenzioni dell'app Web, seguire le indicazioni riportate nella sezione Adottare tutte le Blazor convenzioni di app Web.

  1. Seguire le indicazioni riportate nelle prime tre sezioni di questo articolo:

    Importante

    Usando le indicazioni precedenti, aggiornare i .Clientprogetti , .Servere .Shared della soluzione.

  2. Nel file di .Client progetto (.csproj) aggiungere le proprietà MSBuild seguenti:

    <NoDefaultLaunchSettingsFile>true</NoDefaultLaunchSettingsFile>
<StaticWebAssetProjectMode>Default</StaticWebAssetProjectMode>

    Nel file di .Client progetto rimuovere anche il riferimento al Microsoft.AspNetCore.Components.WebAssembly.DevServer pacchetto:

    - <PackageReference Include="Microsoft.AspNetCore.Components.WebAssembly.DevServer"... />

  3. Spostare il contenuto del .Client/wwwroot/index.html file dal file in un nuovo App file componente (App.razor) creato nella radice del .Server progetto. Dopo aver spostato il contenuto del file, eliminare il index.html file.

    Rinominare App.razor nel .Client progetto in Routes.razor.

    In Routes.razoraggiornare il valore dell'attributo AppAssembly in typeof(Program).Assembly.

  4. .Client Nel progetto aggiungere una voce al _Imports.razor file per rendere disponibili le modalità di rendering abbreviate per l'app:

    @using static Microsoft.AspNetCore.Components.Web.RenderMode

    Creare una copia del .Client file del _Imports.razor progetto e aggiungerla al .Server progetto.

  5. Apportare le modifiche seguenti al App.razor file:

    Sostituire il titolo predefinito del sito Web (<title>...</title>) del sito Web con un HeadOutlet componente. Prendere nota del titolo del sito Web da usare in seguito e rimuovere i tag e il titolo del titolo:

    - <title>...</title>

    Dove è stato rimosso il titolo, posizionare un HeadOutlet componente assegnando la modalità di rendering Interactive WebAssembly (prerendering disabilitato):

    <HeadOutlet @rendermode="new InteractiveWebAssemblyRenderMode(prerender: false)" />

    Modificare il bundle di stile CSS:

    - <link href="{CLIENT PROJECT ASSEMBLY NAME}.styles.css" rel="stylesheet">
+ <link href="{SERVER PROJECT ASSEMBLY NAME}.styles.css" rel="stylesheet">

    Segnaposto nel codice precedente:

    • {CLIENT PROJECT ASSEMBLY NAME}: nome dell'assembly del progetto client. Esempio: BlazorSample.Client
    • {SERVER PROJECT ASSEMBLY NAME}: nome dell'assembly del progetto server. Esempio: BlazorSample.Server

    Individuare il markup HTML seguente <div>...</div> :

    - <div id="app">
-     ...
- </div>

    Sostituire il markup HTML precedente <div>...</div> con il Routes componente usando la modalità di rendering Interactive WebAssembly (prerendering disabilitato):

    <Routes @rendermode="new InteractiveWebAssemblyRenderMode(prerender: false)" />

    Aggiornare lo blazor.webassembly.js script in blazor.web.js:

    - <script src="_framework/blazor.webassembly.js"></script>
+ <script src="_framework/blazor.web.js"></script>

  6. Aprire il .Client file di layout del progetto (.Client/Shared/MainLayout.razor) e aggiungere un PageTitle componente con il titolo predefinito del sito Web ({TITLE} segnaposto):

    <PageTitle>{TITLE}</PageTitle>

    Nota

    Anche altri file di layout devono ricevere un PageTitle componente con il titolo predefinito del sito Web.

    Per altre informazioni, vedere Controllare il contenuto head nelle app ASP.NET CoreBlazor.

  7. Rimuovere le righe seguenti da .Client/Program.cs:

    - builder.RootComponents.Add<App>("#app");
- builder.RootComponents.Add<HeadOutlet>("head::after");

  8. Aggiornamento.Server/Program.cs:

    Aggiungere Razor servizi componenti e componenti WebAssembly interattivi al progetto. Chiamare AddRazorComponents con una chiamata concatenata a AddInteractiveWebAssemblyComponents. La chiamata AddRazorComponents aggiunge servizi antiforgery () perAddAntiforgery impostazione predefinita.

    builder.Services.AddRazorComponents()
    .AddInteractiveWebAssemblyComponents();

    Aggiungere il middleware antiforgery alla pipeline di elaborazione delle richieste.

    Inserire il codice seguente:

    • Dopo la chiamata a app.UseRouting.
    • Se sono presenti chiamate a app.UseRouting e app.UseEndpoints, la chiamata a app.UseAntiforgery deve passare tra di esse.
    • La chiamata a app.UseAntiforgery deve essere inserita dopo una chiamata a app.UseAuthorization, se presente.
    • Non è necessario aggiungere servizi antiforgery (builder.Services.AddAntiforgery()), perché vengono aggiunti automaticamente da AddRazorComponents, che è stato trattato in precedenza.
    app.UseAntiforgery();

    Rimuovere la riga seguente:

    - app.UseBlazorFrameworkFiles();

    Rimuovere la riga seguente:

    - app.MapFallbackToFile("index.html");

    Sostituire la riga precedente con una chiamata a MapRazorComponents, specificando il App componente come tipo di componente radice e aggiungendo chiamate concatenati a AddInteractiveWebAssemblyRenderMode e AddAdditionalAssemblies:

    app.MapRazorComponents<App>()
    .AddInteractiveWebAssemblyRenderMode()
    .AddAdditionalAssemblies(typeof({CLIENT APP NAMESPACE}._Imports).Assembly);

    Nell'esempio precedente il {CLIENT APP NAMESPACE} segnaposto è lo spazio dei nomi del .Client progetto , ad esempio HostedBlazorApp.Client.

  9. Eseguire la soluzione dal .Server progetto:

    Per Visual Studio, verificare che il .Server progetto sia selezionato in Esplora soluzioni durante l'esecuzione dell'app.

    Se si usa l'interfaccia della riga di comando di .NET, eseguire il progetto dalla .Server cartella del progetto.

Aggiornare la configurazione dell'opzione del servizio e dell'endpoint

Con il rilascio di App Web in .NET 8, Blazor la configurazione delle Blazor opzioni del servizio e dell'endpoint viene aggiornata con l'introduzione della nuova API per i servizi componenti interattivi e la configurazione dell'endpoint del componente.

Le indicazioni sulla configurazione aggiornate vengono visualizzate nei percorsi seguenti:

  • Impostazione e lettura dell'ambiente dell'app: contiene indicazioni aggiornate, in particolare nella sezione intitolata Leggi il lato client dell'ambiente in un'app BlazorWeb.
  • Opzioni del gestore del circuito sul lato server: copre la configurazione delle opzioni del BlazorSignalR circuito e dell'hub.
  • Eseguire il rendering Razor dei componenti da JavaScript: illustra la registrazione dinamica dei componenti con RegisterForJavaScript.
  • Blazor elementi personalizzati: Blazor registrazione dell'app Web: copre la registrazione dell'elemento personalizzato del componente radice con RegisterCustomElement.
  • Prefisso per Blazor WebAssembly gli asset: copre il controllo della stringa di percorso che indica il prefisso per Blazor WebAssembly gli asset.
  • Durata della validità dell'URL di reindirizzamento temporaneo: copre il controllo della durata della validità della protezione dei dati per gli URL di reindirizzamento temporanei generati dal Blazor rendering lato server.
  • Errori dettagliati: illustra l'abilitazione di errori dettagliati per il Razor rendering lato server dei componenti.
  • Prerendering della configurazione: il prerendering è abilitato per impostazione predefinita per Blazor App Web. Seguire questo collegamento per indicazioni su come disabilitare la prerendering se si hanno circostanze speciali che richiedono che un'app disabiliti la pre-gestione.
  • Opzioni di associazione del modulo: illustra la configurazione delle opzioni di associazione del modulo.

Eliminare Blazor Server con la soluzione alternativa di routing yarp

Se in precedenza sono state seguite le indicazioni riportate in Abilitare il supporto di ASP.NET Core Blazor Server con Yarp nella migrazione incrementale di un'app Blazor Server con Yarp a .NET 6 o .NET 7, è possibile invertire i passaggi per la soluzione alternativa eseguiti seguendo le indicazioni dell'articolo. Il routing e il deep linking per Blazor Server con Yarp funzionano correttamente in .NET 8.

Eseguire la migrazione dei CascadingValue componenti nei componenti di layout

I parametri a catena non passano i dati tra i limiti della modalità di rendering e i layout vengono sottoposti a rendering statico in app altrimenti interattive. Pertanto, le app che cercano di usare parametri a catena nei componenti di cui è stato eseguito il rendering interattivo non saranno in grado di propagare i valori da un layout.

I due approcci per la migrazione sono:

  • (Consigliato) Passare lo stato come valore a cascata a livello radice. Per altre informazioni, vedere Valori a catena a livello di radice.
  • Eseguire il wrapping del router nel Routes componente con il CascadingValue componente e rendere interattivo il rendering del Routes componente. Per un esempio, vedere CascadingValue componente.

Per altre informazioni, vedere Valori/parametri a catena e limiti della modalità di rendering.

Eseguire la migrazione della BlazorEnableCompression proprietà MSBuild

Per Blazor WebAssembly le app che disabilitano la compressione e la destinazione di .NET 7 o versioni precedenti, ma vengono compilate con .NET 8 SDK, la BlazorEnableCompression proprietà MSBuild è stata modificata in CompressionEnabled:

<PropertyGroup>
-   <BlazorEnableCompression>false</BlazorEnableCompression>
+   <CompressionEnabled>false</CompressionEnabled>
</PropertyGroup>

Quando si usa il comando publish dell'interfaccia della riga di comando di .NET, usare la nuova proprietà :

dotnet publish -p:CompressionEnabled=false

Per ulteriori informazioni, vedi le seguenti risorse:

Eseguire la migrazione del <CascadingAuthenticationState> componente ai servizi di stato di autenticazione a catena

In .NET 7 o versioni precedenti, il CascadingAuthenticationState componente viene incluso in una parte dell'albero dell'interfaccia utente, ad esempio intorno al Blazor router, per fornire lo stato di autenticazione a catena:

<CascadingAuthenticationState>
    <Router ...>
        ...
    </Router>
</CascadingAuthenticationState>

In .NET 8 non usare il CascadingAuthenticationState componente:

- <CascadingAuthenticationState>
      <Router ...>
          ...
      </Router>
- </CascadingAuthenticationState>

Aggiungere invece servizi di stato di autenticazione a catena alla raccolta di servizi chiamando AddCascadingAuthenticationState nel Program file:

builder.Services.AddCascadingAuthenticationState();

Per ulteriori informazioni, vedi le seguenti risorse:

Nuovo articolo sui problemi di memorizzazione nella cache HTTP

È stato aggiunto un nuovo articolo che illustra alcuni dei problemi comuni di memorizzazione nella cache HTTP che possono verificarsi durante l'aggiornamento Blazor delle app tra le versioni principali e come risolvere i problemi di memorizzazione nella cache HTTP.

Per altre informazioni, vedere Evitare problemi di memorizzazione nella cache HTTP durante l'aggiornamento delle app ASP.NET CoreBlazor.

Nuovo articolo sulle librerie di classi con rendering statico lato server (SSR statico)

È stato aggiunto un nuovo articolo che illustra l'autorizzazione della libreria dei componenti nelle Razor librerie di classi (RCL) con il rendering statico lato server (SSR statico).

Per altre informazioni, vedere ASP.NET Librerie di classi core Razor con rendering statico lato server (SSR statico).

Individuare i componenti da assembly aggiuntivi

Quando si esegue la migrazione da un'app Blazor Server a un'app Blazor Web, accedere alle linee guida in ASP.NET routing e navigazione core Blazor se l'app usa componenti instradabili da assembly aggiuntivi, ad esempio librerie di classi dei componenti.

Eliminare [Parameter] l'attributo quando il parametro viene fornito da una stringa di query

L'attributo [Parameter] non è più necessario quando si specifica un parametro dalla stringa di query:

- [Parameter]
  [SupplyParameterFromQuery]

Blazor Server Autorizzazione dei criteri di fallback script

In .NET 7 lo Blazor Server script (blazor.server.js) viene gestito dal middleware dei file statici. L'inserimento della chiamata al middleware per i file statici (UseStaticFiles) nella pipeline di elaborazione delle richieste prima della chiamata al middleware di autorizzazione (UseAuthorization) è sufficiente nelle app .NET 7 per gestire lo Blazor script agli utenti anonimi.

In .NET 8 lo script viene gestito dal proprio endpoint, usando il Blazor Server routing degli endpoint. Questa modifica è stata introdotta dal bug risolto: il passaggio di opzioni a UseStaticFiles interrompe Blazor Server (dotnet/aspnetcore #45897).

Si consideri uno scenario multi-tenant in cui:

  • I criteri predefiniti e di fallback vengono impostati in modo identico.
  • Il tenant viene risolto usando il primo segmento nel percorso della richiesta , ad esempio tld.com/tenant-name/....
  • Le richieste agli endpoint tenant vengono autenticate da uno schema di autenticazione aggiuntivo, che aggiunge un'identità aggiuntiva all'entità richiesta.
  • I criteri di autorizzazione di fallback hanno requisiti che controllano le attestazioni tramite l'identità aggiuntiva.

Le richieste per il Blazor file di script (blazor.server.js) vengono gestite in /_framework/blazor.server.js, hardcoded nel framework. Le richieste per il file non vengono autenticate dallo schema di autenticazione aggiuntivo per i tenant, ma vengono comunque richieste dai criteri di fallback, il che comporta la restituzione di un risultato non autorizzato.

Questo problema è in fase di valutazione per una nuova funzionalità del framework in RazorComponenti mappa interrotti con FallbackPolicy RequireAuthenticatedUser (dotnet/aspnetcore 51836), attualmente pianificato per la versione di .NET 9 di novembre 2024. Fino ad allora, è possibile risolvere questo problema usando uno dei tre approcci seguenti:

  • Non usare criteri di fallback. Applicare l'attributo [Authorize] nel _Imports.razor file per applicarlo a tutti i componenti dell'app. Per gli endpoint non blazor, usare [Authorize] in modo esplicito o RequireAuthorization.

  • Aggiungere [AllowAnonymous] all'endpoint /_framework/blazor.server.js nel Program file:

    app.MapBlazorHub().Add(endpointBuilder =>
{
    if (endpointBuilder is 
        RouteEndpointBuilder
        { 
            RoutePattern: { RawText: "/_framework/blazor.server.js" }
        })
    {
        endpointBuilder.Metadata.Add(new AllowAnonymousAttribute());
    }
});

  • Registrare un oggetto personalizzato AuthorizationHandler che controlla l'oggetto HttpContext per consentire il /_framework/blazor.server.js file.

Docker

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 di ASP.NET Core 8.0. Si consideri la differenza di comando seguente docker pull tra ASP.NET Core 7.0 e 8.0:

- docker pull mcr.microsoft.com/dotnet/aspnet:7.0
+ docker pull mcr.microsoft.com/dotnet/aspnet:8.0

Aggiornare la porta Docker

La porta predefinita ASP.NET Core configurata nelle immagini del contenitore .NET è stata aggiornata dalla porta 80 alla porta 8080.

La nuova ASPNETCORE_HTTP_PORTS variabile di ambiente è stata aggiunta come alternativa più semplice a ASPNETCORE_URLS.

Per altre informazioni, vedi:

Rivedere le modifiche che causano un'interruzione

Per modifiche di rilievo da .NET Core .NET 7.0 a 8.0, vedere Modifiche di rilievo in .NET 8, incluse le sezioni ASP.NET Core e Entity Framework Core .