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

Questo articolo illustra come aggiornare un progetto ASP.NET Core esistente in .NET 7 a .NET 8.

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 SDK, aggiornare la version proprietà alla versione di .NET 8 SDK installata. Per 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, aggiorna ciascun riferimento Microsoft.AspNetCore.*, Microsoft.EntityFrameworkCore.*, Microsoft.Extensions.* e System.Net.Http.Json del pacchetto all'attributo Version a 8.0.0 o versione successiva. Per 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 con MVC o Razor Pages.

Aggiornare un'app Blazor Server

È consigliabile usare Blazor Web Apps 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 Web Apps non sono disponibili per un'app Blazor Server aggiornata per essere eseguita con .NET 8. Per adottare le nuove funzionalità di .NET 8 Blazor , seguire le indicazioni riportate in una delle sezioni seguenti:

Adottare tutte le Blazor Web App convenzioni

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

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

Le nuove funzionalità di .NET 8 sono descritte in Novità di ASP.NET Core in .NET 8. Quando si aggiorna un'app da .NET 6 o versioni precedenti, consulta le note sulla migrazione e sulla versione (articoli «Novità») relative alle versioni intermedie.

Convertire un'app Blazor Server in un Blazor Web App

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'equivalente .NET 8 Blazor Web App, 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 .NET 8 Blazor Web App. Per adottare tutte le nuove Blazor Web App convenzioni, seguire le indicazioni riportate nella sezione Adottare tutte le Blazor Web App convenzioni .

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

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

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

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

    Annotazioni

    Nell'esempio seguente lo spazio dei nomi del progetto è BlazorServerApp. Modifica lo spazio dei nomi in modo che corrisponda al tuo 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 il Tag Helper del componente HeadOutlet e sostituirlo con il componente HeadOutlet.

    Rimuovere la riga seguente:

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

    Sostituire la riga precedente con quanto segue:

    <HeadOutlet @rendermode="InteractiveServer" />

    Rimuovere il Tag Helper del componente App e sostituirlo con il componente Routes.

    Rimuovere la riga seguente:

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

    Sostituire la riga precedente con quanto segue:

    <Routes @rendermode="InteractiveServer" />

    Annotazioni

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

    Rimuovi i Tag Helper Environment per l'interfaccia utente degli errori e sostituiscili con il seguente codice di markup 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:

    Annotazioni

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

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

    using BlazorServerApp;

    Sostituire AddServerSideBlazor con AddRazorComponents e con una chiamata concatenata a AddInteractiveServerComponents.

    Rimuovere la riga seguente:

    - builder.Services.AddServerSideBlazor();

    Sostituire la riga precedente con Razor i servizi componente e componenti server interattivi. La chiamata a AddRazorComponents aggiunge per impostazione predefinita i servizi antifalsificazione (AddAntiforgery).

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

    Rimuovere la riga seguente:

    - app.MapBlazorHub();

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

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

    Rimuovere la riga seguente:

    - app.MapFallbackToPage("/_Host");

    Rimuovi il middleware di instradamento:

    - app.UseRouting();

    Aggiungere il middleware antiforgery alla pipeline di elaborazione delle richieste subito dopo la riga che aggiunge il middleware di reindirizzamento HTTPS (app.UseHttpsRedirection):

    app.UseAntiforgery();

    La chiamata precedente a app.UseAntiforgery deve essere inserita dopo le chiamate, se presenti, a app.UseAuthentication e app.UseAuthorization. Non è necessario aggiungere esplicitamente i servizi anti-contraffazione (builder.Services.AddAntiforgery), perché vengono aggiunti automaticamente da AddRazorComponents, di cui si è già parlato in precedenza.

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

    Modificare il valore dell'attributo della direttiva @rendermode per entrambi i componenti HeadOutlet e Routes per disabilitare il pre-rendering:

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

    Per ulteriori informazioni, vedere Modalità di rendering di ASP.NET CoreBlazor.

Aggiornare un'app Blazor WebAssembly

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

Per le app che adottano il caricamento differito degli assembly, modificare l'estensione del file da .dll a .wasm nell'implementazione dell'app in modo da riflettere l'adozione da parte di Blazor WebAssembly del packaging Webcil degli assembly.

Prima del rilascio di .NET 8, le linee guida in "Deployment layout for ASP.NET Core hostedBlazor WebAssembly apps" affrontano gli ambienti che bloccano i client dallo scaricare ed eseguire DLL con un approccio di bundle multipart. In .NET 8 o versioni successive Blazor usa il formato di file Webcil per risolvere il problema. La creazione di bundle in più parti con il pacchetto NuGet sperimentale, come descritto nell'articolo "WebAssembly Deployment Layout", non è supportata per le app .NET 8 e successive. Se si vuole continuare a usare il pacchetto bundle multipart nelle app .NET 8 o successive, è possibile usare le indicazioni contenute nell'articolo per creare un pacchetto NuGet multipart bundling, ma non sarà supportato da Microsoft.

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

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 .NET 8 Blazor Web Appequivalente, che rende disponibili tutte le nuove funzionalità di .NET 8.

Importante

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

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

    Importante

    Seguendo le indicazioni precedenti, aggiornare i progetti .Client, .Server e .Shared della soluzione.

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

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

    Anche nel file di progetto .Client, rimuovi il riferimento al pacchetto Microsoft.AspNetCore.Components.WebAssembly.DevServer:

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

  3. Sposta il contenuto del file .Client/wwwroot/index.html in un nuovo file di componente App (App.razor), creato nella directory radice del progetto .Server. 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 file imports (_Imports.razor) per rendere disponibili le modalità di rendering abbreviate per l'app:

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

    Creare una copia del .Client file di importazione del progetto (_Imports.razor) e aggiungerlo al .Server progetto.

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

    Sostituire il titolo predefinito del sito web (<title>...</title>) con un componente HeadOutlet. Prendi nota del titolo del sito web da utilizzare in seguito e rimuovi i tag title e il 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)" />

    Modifica il bundle di stili 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 seguente markup HTML <div>...</div>:

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

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

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

    Aggiorna lo script blazor.webassembly.js a 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>

    Annotazioni

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

    Per ulteriori informazioni, vedere Blazor.

  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 il componente Razor e i servizi per componenti WebAssembly interattivi al progetto. Chiamare AddRazorComponents con una chiamata concatenata a AddInteractiveWebAssemblyComponents. La chiamata a AddRazorComponents aggiunge per impostazione predefinita i servizi antifalsificazione (AddAntiforgery).

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

    Aggiungere middleware antiforgery alla pipeline di elaborazione delle richieste.

    Inserire la riga successiva dopo la chiamata a app.UseHttpsRedirection. La chiamata a app.UseAntiforgery deve essere effettuata dopo le chiamate, se presenti, a app.UseAuthentication e app.UseAuthorization. Non è necessario aggiungere esplicitamente i servizi anti-contraffazione (builder.Services.AddAntiforgery), perché vengono aggiunti automaticamente da AddRazorComponents, di cui si è già parlato 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 componente App come tipo di componente radice e aggiungendo chiamate concatenate a AddInteractiveWebAssemblyRenderMode e AddAdditionalAssemblies:

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

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

  9. Eseguire la soluzione dal progetto .Server:

    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.

Aggiornamento della configurazione delle opzioni del servizio e dell'endpoint

Con il rilascio di Blazor Web Apps in .NET 8, la configurazione delle opzioni di servizio e degli endpoint di Blazor viene aggiornata con l'introduzione di nuove API per i servizi per componenti interattivi e la configurazione degli endpoint dei componenti.

Le indicazioni sulla configurazione aggiornate vengono visualizzate nei percorsi seguenti:

Eliminare Blazor Server con il workaround di routing di 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:

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

Eseguire la migrazione della BlazorEnableCompression proprietà MSBuild

Per le app Blazor WebAssembly che disabilitano la compressione e hanno come destinazione .NET 7 o versioni precedenti, ma sono compilate con l'SDK .NET 8, la proprietà MSBuild BlazorEnableCompression è stata cambiata in CompressionEnabled:

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

Quando si utilizza il comando publish della CLI di .NET, usare la nuova proprietà:

dotnet publish -p:CompressionEnabled=false

Per altre informazioni, vedere le risorse seguenti:

Esegui la migrazione del componente <CascadingAuthenticationState> ai servizi di stato di autenticazione a cascata

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>

Invece, aggiungere i servizi di stato di autenticazione a cascata alla raccolta servizi chiamando AddCascadingAuthenticationState nel file Program:

builder.Services.AddCascadingAuthenticationState();

Per altre informazioni, vedere le risorse seguenti:

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 ulteriori informazioni, vedere Evitare i problemi di caching HTTP durante l'aggiornamento delle applicazioni Blazor ASP.NET Core.

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

È stato aggiunto un nuovo articolo che illustra la creazione delle librerie di componenti nelle Razor librerie di classi (RCL) con il rendering statico lato server (SSR statico).

Per ulteriori informazioni, vedere le librerie di classi ASP.NET Core Razor con rendering statico lato server (static SSR).

Scoprire i componenti da assiemi aggiuntivi

Quando si esegue la migrazione da un'app Blazor Server a un Blazor Web App, accedere alle linee guida su il routing di ASP.NET Core Blazor se l'app utilizza componenti che possono essere instradati da assembly aggiuntivi, come 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 del criterio di fallback dello 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 file statici (UseStaticFiles) nella pipeline di elaborazione delle richieste prima della chiamata al middleware di autorizzazione (UseAuthorization) è sufficiente nelle app .NET 7 per fornire lo script Blazor agli utenti anonimi.

In .NET 8, lo Blazor Serverscript viene servito dal proprio endpoint, usando il 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.
  • La politica di autorizzazione di fallback ha requisiti che verificano le rivendicazioni tramite l'identità aggiuntiva.

Le richieste per il file di script Blazor (blazor.server.js) vengono servite tramite /_framework/blazor.server.js, che è codificato in modo statico 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 MapRazorComponents non funzionante con FallbackPolicy RequireAuthenticatedUser (dotnet/aspnetcore 51836), attualmente prevista per il rilascio di .NET 9 a 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 file imports (_Imports.razor) per applicarlo a tutti i componenti dell'app. Per gli endpoint non blazor, usare in modo esplicito [Authorize] o RequireAuthorization.

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

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

  • Registrare un AuthorizationHandler personalizzato che controlla il HttpContext per consentire il passaggio del file /_framework/blazor.server.js.

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

- 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, vedere:

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.

  • Last updated on