Sdílet prostřednictvím

Migrace z ASP.NET Core v .NET 7 na .NET 8

  • Článek

Tento článek vysvětluje, jak aktualizovat existující projekt ASP.NET Core 7.0 na ASP.NET Core 8.0.

Požadavky

Aktualizace verze sady .NET SDK v global.json

Pokud se spoléháte na global.json soubor určený pro konkrétní verzi sady .NET Core SDK, aktualizujte version vlastnost na nainstalovanou verzi sady .NET 8.0 SDK. Příklad:

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

Aktualizace cílové architektury

Aktualizujte moniker cílového rozhraní (TFM) souboru projektu nanet8.0:

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

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

</Project>

Aktualizace odkazů na balíčky

V souboru projektu aktualizujte každý Microsoft.AspNetCore.*, Microsoft.EntityFrameworkCore.*, Microsoft.Extensions.*a System.Net.Http.Json balíček odkaz na Version atribut 8.00 nebo novější. Příklad:

<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

Probíráme následující scénáře migrace:

Pokyny k přidání Blazor podpory do aplikace ASP.NET Core najdete v tématu Integrace komponent ASP.NET Core Razor do aplikací ASP.NET Core.

Blazor Server Aktualizace aplikace

Doporučujeme používat Blazor webové aplikace v .NET 8, ale Blazor Server podporuje se. Pokud chcete dál používat Blazor Server rozhraní .NET 8, postupujte podle pokynů v prvních třech částech tohoto článku:

Nové Blazor funkce zavedené pro Blazor Web Apps nejsou dostupné pro aplikaci aktualizovanou Blazor Server tak, aby běžela v .NET 8. Pokud chcete nové funkce .NET 8 Blazor přijmout, postupujte podle pokynů v některé z následujících částí:

Přijetí všech Blazor konvencí webových aplikací

Pokud chcete volitelně přijmout všechny nové Blazor konvence webových aplikací, doporučujeme následující postup:

  • Vytvořte novou aplikaci ze Blazor šablony projektu webové aplikace. Další informace naleznete v tématu Nástroje pro ASP.NET Core Blazor.
  • Přesuňte komponenty a kód aplikace do nové Blazor webové aplikace a upravte nové funkce.
  • Aktualizujte rozložení a styly Blazor webové aplikace.

Nové funkce .NET 8 jsou popsané v novinkách v ASP.NET Core 8.0. Při aktualizaci aplikace z .NET 6 nebo starších si přečtěte poznámky k migraci a vydání verze (články o novinkách ) pro intervenování verzí.

Blazor Server Převod aplikace na webovou Blazor aplikaci

Blazor Server aplikace jsou podporovány v .NET 8 bez jakýchkoli změn kódu. Pomocí následujících doprovodných materiálů převeďte Blazor Server aplikaci na ekvivalentní webovou aplikaci .NET 8 Blazor , která zpřístupňuje všechny nové funkce .NET 8.

Důležité

Tato část se zaměřuje na minimální změny potřebné k převodu aplikace .NET 7 Blazor Server na webovou aplikaci .NET 8 Blazor . Pokud chcete přijmout všechny nové Blazor konvence webových aplikací, postupujte podle pokynů v části Přijmout všechny Blazor konvence webových aplikací.

  1. Postupujte podle pokynů v prvních třech částech tohoto článku:

  2. Přesuňte obsah App komponenty (App.razor) do nového Routes souboru komponenty (Routes.razor) přidaného do kořenové složky projektu. Ponechte prázdný App.razor soubor v aplikaci v kořenové složce projektu.

  3. Přidejte do _Imports.razor souboru položku, aby byly režimy vykreslování zkrácené ruky dostupné pro aplikaci:

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

  4. Přesuňte obsah na _Host stránce (Pages/_Host.cshtml) do prázdného App.razor souboru. Pokračujte provedením následujících změn App komponenty.

    Poznámka:

    V následujícím příkladu je BlazorServerAppobor názvů projektu . Upravte obor názvů tak, aby odpovídal vašemu projektu.

    Odeberte následující řádky z horní části souboru:

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

    Nahraďte předchozí řádky řádkem, který vloží IHostEnvironment instanci:

    @inject IHostEnvironment Env

    Odeberte vlnovku (~) ze href<base> značky a nahraďte základní cestou pro vaši aplikaci:

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

    Odeberte pomocnou rutinu HeadOutlet značky komponenty a nahraďte ji komponentou HeadOutlet .

    Odeberte následující řádek:

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

    Předchozí řádek nahraďte následujícím kódem:

    <HeadOutlet @rendermode="InteractiveServer" />

    Odeberte pomocnou rutinu App značky komponenty a nahraďte ji komponentou Routes .

    Odeberte následující řádek:

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

    Předchozí řádek nahraďte následujícím kódem:

    <Routes @rendermode="InteractiveServer" />

    Poznámka:

    Předchozí konfigurace předpokládá, že komponenty aplikace přijímají interaktivní vykreslování serveru. Další informace, včetně toho, jak přijmout statické vykreslování na straně serveru (SSR), najdete v tématu ASP.NET režimy vykreslování coreBlazor.

    Odeberte pomocné rutiny značek prostředí pro uživatelské rozhraní chyb a nahraďte je následujícím Razor kódem.

    Odeberte následující řádky:

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

    Předchozí řádky nahraďte následujícím kódem:

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

    Blazor Změňte skript z blazor.server.js nablazor.web.js:

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

  5. Pages/_Host.cshtml Odstraňte soubor.

  6. Aktualizace Program.cs:

    Poznámka:

    V následujícím příkladu je BlazorServerAppobor názvů projektu . Upravte obor názvů tak, aby odpovídal vašemu projektu.

    using Na začátek souboru pro obor názvů projektu přidejte příkaz:

    using BlazorServerApp;

    Nahraďte AddServerSideBlazor a zřetězeným voláním AddInteractiveServerComponents.AddRazorComponents

    Odeberte následující řádek:

    - builder.Services.AddServerSideBlazor();

    Nahraďte předchozí řádek komponentami a službami Razor komponent interaktivního serveru. Volání AddRazorComponents ve výchozím nastavení přidává antiforgery služby (AddAntiforgery).

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

    Odeberte následující řádek:

    - app.MapBlazorHub();

    Nahraďte předchozí řádek voláním MapRazorComponents, zadejte komponentu App jako typ kořenové komponenty a přidejte zřetězený volání:AddInteractiveServerRenderMode

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

    Odeberte následující řádek:

    - app.MapFallbackToPage("/_Host");

    Přidat Antiforgery Middleware do kanálu zpracování požadavku po volání app.UseRouting. Pokud existují volání app.UseRouting a app.UseEndpointsvolání musí app.UseAntiforgery jít mezi nimi. Hovor app.UseAntiforgery musí být umístěn po volání a app.UseAuthenticationapp.UseAuthorization. Není nutné přidávat antiforgery služby (builder.Services.AddAntiforgery()), protože se přidávají automaticky AddRazorComponents, což bylo popsáno dříve.

    app.UseAntiforgery();

  7. Blazor Server Pokud byla aplikace nakonfigurovaná tak, aby zakázala předkonenderování, můžete v aktualizované aplikaci pokračovat v zakázání předkončování. V komponentě App změňte hodnotu přiřazenou @rendermodeRazor atributům direktivy pro komponenty HeadOutlet a Routes komponenty.

    Změňte hodnotu atributu @rendermode direktivy pro komponenty a HeadOutletRoutes zakažte předběžné předkreslování:

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

    Další informace najdete v tématu ASP.NET režimy vykreslování coreBlazor.

Blazor WebAssembly Aktualizace aplikace

Postupujte podle pokynů v prvních třech částech tohoto článku:

Převod hostované Blazor WebAssembly aplikace na webovou Blazor aplikaci

Blazor WebAssembly aplikace jsou podporovány v .NET 8 bez jakýchkoli změn kódu. Následující doprovodné materiály použijte k převodu hostované Blazor WebAssembly aplikace ASP.NET Core na ekvivalentní webovou aplikaci .NET 8 Blazor , která zpřístupňuje všechny nové funkce .NET 8.

Důležité

Tato část se zaměřuje na minimální změny potřebné k převodu aplikace hostované Blazor WebAssembly v .NET 7 ASP.NET Core na webovou aplikaci .NET 8 Blazor . Pokud chcete přijmout všechny nové Blazor konvence webových aplikací, postupujte podle pokynů v části Přijmout všechny Blazor konvence webových aplikací.

  1. Postupujte podle pokynů v prvních třech částech tohoto článku:

    Důležité

    Pomocí předchozích pokynů aktualizujte .Clientřešení , .Servera .Shared projekty.

  2. .Client Do souboru projektu (.csproj) přidejte následující vlastnosti nástroje MSBuild:

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

    .Client V souboru projektu odeberte také odkaz na Microsoft.AspNetCore.Components.WebAssembly.DevServer balíček:

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

  3. Přesuňte obsah souboru ze .Client/wwwroot/index.html souboru do nového App souboru komponenty (App.razor) vytvořeného v kořenovém adresáři .Server projektu. Po přesunutí obsahu souboru soubor odstraňte index.html .

    Přejmenujte App.razor v .Client projektu na Routes.razor.

    V Routes.razor, aktualizovat hodnotu atributu AppAssembly na typeof(Program).Assembly.

  4. .Client V projektu přidejte do _Imports.razor souboru položku, aby byly režimy vykreslování zkrácené ruky dostupné pro aplikaci:

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

    Vytvořte kopii .Client souboru projektu _Imports.razor a přidejte ho .Server do projektu.

  5. Proveďte v souboru následující změny App.razor :

    Nahraďte výchozí název webu (<title>...</title>) komponentou HeadOutlet . Poznamenejte si název webu pro pozdější použití a odeberte značky a název nadpisu:

    - <title>...</title>

    Místo, kde jste odebrali název, umístěte komponentu HeadOutlet , která přiřazuje režim vykreslování Interactive WebAssembly (prerendering disabled):

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

    Změna sady stylů CSS:

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

    Zástupné symboly v předchozím kódu:

    • {CLIENT PROJECT ASSEMBLY NAME}: Název sestavení projektu klienta. Příklad: BlazorSample.Client
    • {SERVER PROJECT ASSEMBLY NAME}: Název sestavení projektu serveru. Příklad: BlazorSample.Server

    Vyhledejte následující <div>...</div> kód HTML:

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

    Nahraďte předchozí <div>...</div> kód HTML komponentou Routes pomocí režimu vykreslování Interactive WebAssembly (prerendering disabled):

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

    Aktualizujte skript na blazor.webassembly.jsblazor.web.js:

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

  6. .Client Otevřete soubor rozložení projektu (.Client/Shared/MainLayout.razor) a přidejte komponentu PageTitle s výchozím názvem webu ({TITLE}zástupný symbol):

    <PageTitle>{TITLE}</PageTitle>

    Poznámka:

    Jiné soubory rozložení by také měly obdržet komponentu PageTitle s výchozím názvem webu.

    Další informace najdete v tématu Řízení hlavního obsahu v aplikacích ASP.NET CoreBlazor.

  7. Odeberte následující řádky z .Client/Program.cs:

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

  8. Aktualizace .Server/Program.cs:

    Přidejte Razor do projektu komponenty a interaktivní služby komponent WebAssembly. Volání AddRazorComponents s zřetězeným voláním AddInteractiveWebAssemblyComponents. Volání AddRazorComponents ve výchozím nastavení přidává antiforgery služby (AddAntiforgery).

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

    Přidejte middleware Antiforgery do kanálu zpracování požadavků.

    Umístěte následující kód:

    • Za voláním app.UseRouting.
    • Pokud existují volání app.UseRouting a app.UseEndpointsvolání musí app.UseAntiforgery jít mezi nimi.
    • Hovor app.UseAntiforgery musí být umístěn po volání app.UseAuthorization, pokud je k dispozici.
    • Není nutné přidávat antiforgery služby (builder.Services.AddAntiforgery()), protože se přidávají automaticky AddRazorComponents, což bylo popsáno dříve.
    app.UseAntiforgery();

    Odeberte následující řádek:

    - app.UseBlazorFrameworkFiles();

    Odeberte následující řádek:

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

    Nahraďte předchozí řádek voláním MapRazorComponents, zadejte komponentu App jako typ kořenové komponenty a přidejte zřetězený volání a AddInteractiveWebAssemblyRenderModeAddAdditionalAssemblies:

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

    V předchozím příkladu {CLIENT APP NAMESPACE} je zástupný symbol obor názvů .Client projektu (například HostedBlazorApp.Client).

  9. Spusťte řešení z .Server projektu:

    V sadě Visual Studio ověřte, že .Server je projekt vybraný v Průzkumník řešení při spuštění aplikace.

    Pokud používáte .NET CLI, spusťte projekt ze .Server složky projektu.

Aktualizace konfigurace možností služby a koncového bodu

S vydáním Blazor služby Web Apps v .NET 8 Blazor se aktualizuje konfigurace možností služby a koncového bodu pomocí nového rozhraní API pro interaktivní služby komponent a konfiguraci koncového bodu komponenty.

Aktualizované pokyny ke konfiguraci se zobrazují v následujících umístěních:

  • Nastavení a čtení prostředí aplikace: Obsahuje aktualizované pokyny, zejména v části s názvem Čtení klienta prostředí ve Blazor webové aplikaci.
  • Možnosti obslužné rutiny okruhu na straně serveru: Pokrývá novou BlazorSignalR konfiguraci možností okruhu a rozbočovače.
  • Vykreslovat Razor komponenty z JavaScriptu: Pokrývá dynamickou registraci komponent pomocí RegisterForJavaScript.
  • Blazorcustom elements: Web App registration: Blazor Cover root component custom element registration with RegisterCustomElement.
  • Předpona pro Blazor WebAssembly prostředky: Pokrývá kontrolu nad řetězcem cesty, který označuje předponu pro Blazor WebAssembly prostředky.
  • Doba platnosti dočasné adresy URL přesměrování: Pokrývá kontrolu doby platnosti ochrany dat pro dočasné adresy URL přesměrování generované vykreslováním Blazor na straně serveru.
  • Podrobné chyby: Popisuje povolení podrobných chyb pro Razor vykreslování na straně serveru součástí.
  • Konfigurace předřažení: Pro Web Apps je ve výchozím nastavení Blazor povolená prerendering. Pokud máte zvláštní okolnosti, které vyžadují, aby aplikace zakázala předsekenderování, postupujte podle tohoto odkazu.
  • Možnosti vazby formuláře: Pokrývá konfiguraci možností vazby formuláře.

Řešení Blazor Server odstraňování pomocí směrování Yarp

Pokud jste dříve postupovali podle pokynů v tématu Povolení podpory ASP.NET Core Blazor Server s Yarpem v přírůstkové migraci pro migraci Blazor Server aplikace s Yarpem na .NET 6 nebo .NET 7, můžete obrátit kroky alternativního řešení, které jste provedli při použití pokynů v článku. Směrování a přímé propojení s Blazor Server Yarpem funguje správně v .NET 8.

Migrace CascadingValue komponent v komponentách rozložení

Kaskádové parametry nepředají data přes hranice režimu vykreslování a rozložení se staticky vykreslují v jinak interaktivních aplikacích. Aplikace, které se proto snaží používat kaskádové parametry v interaktivně vykreslovaných komponentách, nebudou moct kaskádově uspořádat hodnoty z rozložení.

Dva přístupy k migraci jsou:

Další informace najdete v tématu Kaskádové hodnoty/parametry a hranice režimu vykreslení.

BlazorEnableCompression Migrace vlastnosti MSBuild

U Blazor WebAssembly aplikací, které zakazují kompresi a cíl .NET 7 nebo starší, ale jsou sestavené pomocí sady .NET 8 SDK, BlazorEnableCompression se vlastnost MSBuild změnila na CompressionEnabled:

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

Při použití příkazu pro publikování rozhraní příkazového řádku .NET použijte novou vlastnost:

dotnet publish -p:CompressionEnabled=false

Další informace naleznete v následujících zdrojích:

<CascadingAuthenticationState> Migrace komponenty do kaskádových stavových služeb ověřování

V rozhraní .NET 7 nebo starší CascadingAuthenticationState je komponenta zabalená kolem některé části stromu uživatelského rozhraní, například kolem Blazor směrovače, a poskytuje tak kaskádový stav ověřování:

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

V .NET 8 nepoužívejte komponentu CascadingAuthenticationState :

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

Místo toho přidejte do kolekce služby kaskádové ověřovací stavové služby voláním AddCascadingAuthenticationState v Program souboru:

builder.Services.AddCascadingAuthenticationState();

Další informace naleznete v následujících zdrojích:

Nový článek o problémech s ukládáním do mezipaměti HTTP

Přidali jsme nový článek, který popisuje některé běžné problémy s ukládáním do mezipaměti HTTP, ke kterým může dojít při upgradu Blazor aplikací napříč hlavními verzemi a o řešení problémů s ukládáním do mezipaměti HTTP.

Další informace najdete v tématu Zabránění problémům s ukládáním do mezipaměti HTTP při upgradu aplikací ASP.NET CoreBlazor.

Nový článek o knihovnách tříd se statickým vykreslováním na straně serveru (statická SSR)

Přidali jsme nový článek, který popisuje autorství knihovny komponent v Razor knihovnách tříd (RCLS) se statickým vykreslováním na straně serveru (static SSR).

Další informace najdete v tématu ASP.NET Razor knihovny základních tříd (RCLs) se statickým vykreslováním na straně serveru (statické SSR).

Zjišťování komponent z dalších sestavení

Při migraci z Blazor Server aplikace na Blazor webovou aplikaci přejděte k pokynům v ASP.NET Blazor směrování a navigaci v případě, že aplikace používá směrovatelné komponenty z dalších sestavení, jako jsou knihovny tříd komponent.

Přetažení [Parameter] atributu při zadání parametru z řetězce dotazu

Atribut [Parameter] se už nevyžaduje při zadávání parametru z řetězce dotazu:

- [Parameter]
  [SupplyParameterFromQuery]

Blazor Server Autorizace zásad pro použití náhradních skriptů

V .NET 7 Blazor Server se skript (blazor.server.js) obsluhuje middleware statických souborů. Volání Middlewaru statických souborů (UseStaticFiles) do kanálu zpracování požadavků před voláním middlewaru autorizace (UseAuthorization) stačí v aplikacích .NET 7 k tomu, aby skript sloužil Blazor anonymním uživatelům.

V .NET 8 Blazor Server se skript obsluhuje vlastním koncovým bodem pomocí směrování koncového bodu. Tato změna je zavedena opravenou chybou – Předávání možností pro konce Blazor Server useStaticFiles (dotnet/aspnetcore #45897).

Představte si scénář s více tenanty, kde:

  • Výchozí i záložní zásady jsou nastavené identicky.
  • Tenant se vyřeší pomocí prvního segmentu v cestě požadavku (například tld.com/tenant-name/...).
  • Požadavky na koncové body tenanta se ověřují pomocí dalšího schématu ověřování, které do objektu zabezpečení požadavku přidá další identitu.
  • Záložní zásady autorizace mají požadavky, které kontrolují deklarace identity prostřednictvím další identity.

Požadavky na Blazor soubor skriptu (blazor.server.js) se obsluhují na /_framework/blazor.server.jsadrese , která je pevně zakódovaná v rámci. Požadavky na soubor nejsou ověřeny dodatečným schématem ověřování pro tenanty , ale stále jsou vyzýváním záložních zásad, což vede k vrácení neoprávněného výsledku.

Tento problém se vyhodnotuje pro novou funkci rozhraní v komponentách mapováníRazor, která nefunguje s funkcí FallbackPolicy RequireAuthenticatedUser (dotnet/aspnetcore 51836), která je aktuálně naplánovaná pro vydání rozhraní .NET 9 v listopadu 2024. Do té doby můžete tento problém vyřešit pomocí některého z následujících tří přístupů:

  • Nepoužívejte záložní zásady. [Authorize] Použijte atribut v _Imports.razor souboru, abyste ho použili na všechny součásti aplikace. Pro koncové body bez blazoru explicitně použijte [Authorize] nebo RequireAuthorization.

  • Přidejte [AllowAnonymous] do koncového /_framework/blazor.server.jsProgram bodu v souboru:

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

  • Zaregistrujte vlastní, AuthorizationHandler který zkontroluje HttpContext/_framework/blazor.server.js povolení souboru.

Docker

Aktualizace imagí Dockeru

U aplikací používajících Docker aktualizujte příkazy a skripty DockerfileFROM . Použijte základní image, která zahrnuje modul runtime ASP.NET Core 8.0. Představte si následující docker pull rozdíl mezi ASP.NET Core 7.0 a 8.0:

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

Aktualizace portu Dockeru

Výchozí port ASP.NET Core nakonfigurovaný v imagích kontejnerů .NET se aktualizoval z portu 80 na 8080.

Nová ASPNETCORE_HTTP_PORTS proměnná prostředí byla přidána jako jednodušší alternativa k ASPNETCORE_URLS.

Další informace naleznete v tématu:

Kontrola zásadních změn

Zásadní změny z .NET Core .NET 7.0 na 8.0 najdete v tématu Zásadní změny v .NET 8, které zahrnují oddíly ASP.NET Core a Entity Framework Core .