Dela via


Vara värd för och distribuera ASP.NET Core Blazor

Notera

Det här är inte den senaste versionen av den här artikeln. För den aktuella versionen, se version av .NET 9 av den här artikeln.

Varning

Den här versionen av ASP.NET Core stöds inte längre. Mer information finns i .NET och .NET Core Support Policy. För den aktuella versionen, se version av .NET 9 av den här artikeln.

Viktig

Den här informationen gäller en förhandsversionsprodukt som kan ändras avsevärt innan den släpps kommersiellt. Microsoft lämnar inga garantier, uttryckliga eller underförstådda, med avseende på den information som tillhandahålls här.

För den aktuella versionen, se version av .NET 9 av den här artikeln.

Den här artikeln beskriver hur du hostar och driftsätter Blazor-appar.

Publicera appen

Appar publiceras för distribution i Release-konfiguration.

Notera

Publicera en värdbaserad Blazor WebAssemblylösning från Server projektet.

  1. Välj kommandot Publicera {APPLICATION} från menyn Build, där {APPLICATION} platshållar appens namn.
  2. Välj publiceringsmål. Om du vill publicera lokalt väljer du Mapp. Välj Nästa.
  3. När du publicerar lokalt godkänner du standardmappplatsen eller anger en annan plats. Välj Slutför för att spara profilen. Välj Stäng.
  4. Om du vill rensa målets publiceringsmapp innan du publicerar appen väljer du Visa alla inställningar. Välj Inställningar>Filpubliceringsalternativ>Ta bort alla befintliga filer innan du publicerar. Välj Spara.
  5. Välj knappen Publicera.

När appen publiceras utlöses en återställning av projektets beroenden och bygger projektet innan du skapar resurserna för distribution. Som en del av byggprocessen tas oanvända metoder och sammansättningar bort för att minska appens nedladdningsstorlek och inläsningstider.

Töm målpubliceringsmappen

När du använder dotnet publish kommandot i ett kommandogränssnitt för att publicera en app genererar kommandot nödvändiga filer för distribution baserat på projektets aktuella tillstånd och placerar filerna i den angivna utdatamappen. Kommandot rensar inte målmappen automatiskt innan appen publiceras.

Om du vill tömma målmappen automatiskt innan appen publiceras lägger du till följande MSBuild-mål i appens projektfil (.csproj) under rotelementet <Project> :

<Target Name="_RemovePublishDirBeforePublishing" BeforeTargets="BeforePublish">
  <RemoveDir Directories="$(PublishDir)" Condition="'$(PublishDir)' != ''" />
</Target>

Standardpubliceringsplatser

  • Blazor Web App: Appen publiceras i mappen /bin/Release/{TARGET FRAMEWORK}/publish, där platshållaren {TARGET FRAMEWORK} är målramverket. Distribuera innehållet i mappen publish till värddatorn.
  • Fristående Blazor WebAssembly: Appen läggs i bin/Release/{TARGET FRAMEWORK}/publish-mappen eller bin/Release/{TARGET FRAMEWORK}/browser-wasm/publish-mappen. För att distribuera appen som en statisk webbplats kopierar du innehållet i mappen wwwroot till den statiska webbplatsens värd.
  • Blazor Server: Appen publiceras i /bin/Release/{TARGET FRAMEWORK}/publish-mappen, där {TARGET FRAMEWORK}-platshållaren är målramverket. Distribuera innehållet i mappen publish till värddatorn.
  • Blazor WebAssembly
    • Fristående: Appen publiceras i /bin/Release/{TARGET FRAMEWORK}/publish mappen eller bin/Release/{TARGET FRAMEWORK}/browser-wasm/publish . För att distribuera appen som en statisk webbplats kopierar du innehållet i mappen wwwroot till den statiska webbplatsens värd.
    • Värdbaserad: Servern ASP.NET Core-appen och klientappen Blazor WebAssembly/bin/Release/{TARGET FRAMEWORK}/publish publiceras i mappen för serverappen, tillsammans med eventuella statiska webbtillgångar i klientappen. Distribuera innehållet i mappen publish till värddatorn.

IIS

För att vara värd för en Blazor app i IIS, kan du se följande resurser:

Delning av en apppool mellan ASP.NET Core-appar stöds inte, inklusive för Blazor appar. Använd en apppool per app när du är värd för IIS och undvik att använda IIS virtuella kataloger för att vara värd för flera appar.

En eller flera Blazor WebAssembly appar som hanteras av en ASP.NET Core-app, som kallas en värdbaserad Blazor WebAssembly lösning, stöds för en apppool. Vi rekommenderar eller stöder dock inte tilldelning av en enda apppool till flera värdbaserade Blazor WebAssembly lösningar eller i värdscenarier för underappar.

Mer information om lösningarfinns i Tooling for ASP.NET Core Blazor.

Stöd för JavaScript-paket

Körningen Blazor förlitar sig på JavaScript-filer (JS), .NET-körningen som kompilerats till WebAssembly-kod och hanterade sammansättningar packade som WebAssembly-filer. När en Blazor app byggs är Blazor runtime beroende av dessa filer från olika byggplatser. På grund av den här begränsningen Blazorär build-utdata inte kompatibla med JS bundlers, till exempel Gulp, Webpack och Rollup.

Om du vill skapa build-utdata som är kompatibla med JS paketerare under publiceringenWasmBundlerFriendlyBootConfig anger du egenskapen MSBuild till true i appens projektfil:

<WasmBundlerFriendlyBootConfig>true</WasmBundlerFriendlyBootConfig>

Viktig

Den här funktionen genererar endast paketvänliga utdata när du publicerar appen.

Resultatet kan inte köras direkt i webbläsaren, men det kan användas av JS verktyg för att paketera JS filer med de övriga skript som utvecklaren tillhandahåller.

När WasmBundlerFriendlyBootConfig är aktiverat innehåller de producerade JS-filerna import-direktiv för alla resurser i appen, vilket gör beroendena synliga för bundlaren. Många av tillgångarna kan inte läsas in av webbläsaren, men paketerare kan vanligtvis konfigureras för att identifiera tillgångarna efter filtyp för att hantera inläsning. Mer information om hur du konfigurerar paketeraren finns i paketerarens dokumentation.

Notera

Sammanställning av byggutdata bör vara möjligt genom att mappa importer till enskilda filplatser med hjälp av ett anpassat plugin för bundlare. Vi tillhandahåller inte ett sådant plugin-program för tillfället.

Notera

Genom att ersätta plugin-programmet files med url paketeras alla appens JS-filer, inklusive Blazor-WebAssembly-runtime-miljön (base64-kodad i JS), i utdata. Storleken på filen är betydligt större (till exempel 300% större) än när filerna kureras med files plugin-programmet, så vi rekommenderar inte att du använder url plugin-programmet som en allmän praxis när du skapar paketeringsvänliga utdata för JS paketbearbetning.

Följande exempelappar baseras på Rollup. Liknande begrepp gäller när du använder andra JS paketerare.

Exempelappar för demonstration för Blazor WebAssembly i en React-app (BlazorWebAssemblyReact) och .NET på WebAssembly i en React-app (DotNetWebAssemblyReact) för .NET 10 eller senare är tillgängliga på Blazor GitHub-lagringsplatsen för exempel (dotnet/blazor-samples).

Aspekter av Blazor WebAssembly cachelagring gäller för Blazor Web Apps

Blazor vägledning för paketcachelagring och HTTP-cachelagring i Blazor WebAssembly noden fokuserar på fristående Blazor WebAssembly appar, men flera aspekter av cachelagring på klientsidan i dessa artiklar gäller även för Blazor Web App:er som använder interaktiva WebAssembly- eller interaktiva Auto render-lägen. Om en Blazor Web App som renderar innehåll på klienten stöter på ett problem med statisk resurs eller cachelagring av paket, följ rekommendationerna i dessa artiklar för att lösa problemet.

Blazor Server MapFallbackToPage konfiguration

Det här avsnittet gäller endast för Blazor Server appar. MapFallbackToPage stöds inte i Blazor Web Appoch Blazor WebAssembly appar.

I scenarier där en app kräver ett separat område med anpassade resurser och Razor komponenter:

  • Skapa en mapp i appens Pages mapp för att lagra resurserna. Ett administratörsavsnitt i en app skapas till exempel i en ny mapp med namnet Admin (Pages/Admin).

  • Skapa en rotsida (_Host.cshtml) för området. Skapa till exempel en Pages/Admin/_Host.cshtml fil från appens huvudrotsida (Pages/_Host.cshtml). Ge inte ett @page-direktiv på Admin _Host-sidan.

  • Lägg till en layout i områdets mapp (till exempel Pages/Admin/_Layout.razor). I layouten för det separata området anger du taggen <base>href så att den matchar områdets mapp (till exempel <base href="/Admin/" />). I demonstrationssyfte lägger du till ~/ till de statiska resurserna på sidan. Till exempel:

    • ~/css/bootstrap/bootstrap.min.css
    • ~/css/site.css
    • ~/BlazorSample.styles.css (exempelappens namnområde är BlazorSample)
    • ~/_framework/blazor.server.js (Blazor skript)
  • Om området ska ha en egen statisk tillgångsmapp lägger du till mappen och anger dess plats till Static File Middleware i Program.cs (till exempel app.UseStaticFiles("/Admin/wwwroot")).

  • Razor-komponenterna läggs till i områdets mapp. Lägg åtminstone till Index-komponenten i områdesmappen med det rätta @page-direktivet för området. Lägg till exempel till en Pages/Admin/Index.razor fil baserat på appens standardfil Pages/Index.razor. Ange administrationsområdet som routningsmall överst i filen (@page "/admin"). Lägg till ytterligare komponenter efter behov. Till exempel Pages/Admin/Component1.razor med ett @page-direktiv och en vägmall för @page "/admin/component1.

  • I Program.csanropar du MapFallbackToPage för områdets sökväg för begäran omedelbart före rotsidans återställningssökväg till _Host-sidan:

    ...
    app.UseRouting();
    
    app.MapBlazorHub();
    app.MapFallbackToPage("~/Admin/{*clientroutes:nonfile}", "/Admin/_Host");
    app.MapFallbackToPage("/_Host");
    
    app.Run();