ASP.NET Core Blazor värdmodeller
Notera
Det här är inte den senaste versionen av den här artikeln. För den aktuella utgåvan, se .NET 9-versionen 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 att se den aktuella versionen, se den .NET 9-versionen 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 .NET 9-versionen av denna artikel.
Den här artikeln beskriver Blazor värdmodeller, främst inriktade på Blazor Server och Blazor WebAssembly appar i versioner av .NET tidigare än .NET 8. Vägledningen i den här artikeln är relevant under alla .NET-versioner för Blazor Hybrid appar som körs på interna mobil- och skrivbordsplattformar. Blazor Web Appi .NET 8 eller senare är bättre konceptualiserade genom hur Razor komponenter renderas, vilket beskrivs som deras renderingsläge. Återgivningslägen berörs kort i översiktsartikeln Fundamentals och beskrivs i detalj i ASP.NET Core Blazor återgivningslägen av noden Components.
Den här artikeln beskriver Blazor värdmodeller och hur du väljer vilken som ska användas.
Blazor är ett webbramverk för att skapa webbgränssnittskomponenter (Razor komponenter) som kan hanteras på olika sätt. Razor-komponenterna kan köra på server-sidan i ASP.NET Core (Blazor Server) versus på klient-sidan i webbläsaren på en WebAssembly-baserad .NET-körmiljö (Blazor WebAssembly, Blazor WASM). Du kan också använda Razor-komponenter i mobila och skrivbordsappar som körs lokalt och renderas till en inbäddad Web View-kontroll (Blazor Hybrid). Oavsett värdmodell är sättet du skapar Razor komponenter samma. Samma Razor komponenter kan användas med någon av värdmodellerna oförändrade.
Blazor är ett webbramverk för att skapa webbgränssnittskomponenter (Razor komponenter) som kan hanteras på olika sätt. Razor-komponenter kan köra på server-sidan i ASP.NET Core (Blazor Server) jämfört med på klient-sidan i webbläsaren på en WebAssembly-baserad .NET-körningsmiljö (Blazor WebAssembly, Blazor WASM). Oavsett värdmodell är sättet du skapar Razor komponenter samma. Samma Razor komponenter kan användas med någon av värdmodellerna oförändrade.
Blazor Server
Med Blazor Server värdmodell körs komponenter på servern inifrån en ASP.NET Core-app. Användargränssnittsuppdateringar, händelsehantering och JavaScript-anrop hanteras via en SignalR-anslutning med hjälp av WebSockets-protokollet. Tillståndet på servern som är kopplat till varje ansluten klient kallas för en krets. Kretsar är inte knutna till en specifik nätverksanslutning och kan tolerera tillfälliga nätverksavbrott och försök från klienten att återansluta till servern när anslutningen går förlorad.
Om du öppnar samma app i flera webbläsarskärmar (flikar eller iframes) i en traditionell server renderad app översätts det vanligtvis inte till ytterligare resurskrav på servern. För Blazor Server värdmodell kräver varje webbläsarskärm en separat krets och separata instanser av serverhanterat komponenttillstånd.
Blazor överväger att stänga en webbläsarflik eller navigera till en extern URL som en snygg avslutning. I händelse av en korrekt avslutning släpps kretsen och associerade resurser omedelbart. En klient kan också kopplas från på ett felaktigt sätt, till exempel på grund av ett nätverksavbrott.
Blazor Server lagrar frånkopplade kretsar för ett konfigurerbart intervall så att klienten kan återansluta.
På klienten upprättar Blazor-skriptet den SignalR anslutningen till servern. Skriptet levereras som en statisk webbresurs med automatisk komprimering och fingeravtryck.
På klienten upprättar Blazor-skriptet den SignalR anslutningen till servern. Skriptet hanteras från en inbäddad resurs i det delade ramverket ASP.NET Core.
Värdmodellen Blazor Server erbjuder flera fördelar:
- Nedladdningsstorleken är betydligt mindre än när Blazor WebAssembly värdmodell används och appen läses in mycket snabbare.
- Appen drar full nytta av serverfunktioner, inklusive användning av .NET Core-API:er.
- .NET Core på servern används för att köra appen, så befintliga .NET-verktyg, till exempel felsökning, fungerar som förväntat.
- Tunna klienter stöds. Till exempel fungerar Blazor Server med webbläsare som inte stöder WebAssembly och på resursbegränsade enheter.
- Appens .NET- och C#-kodbas, inklusive appens komponentkod, tillhandahålls inte till klienterna.
Värdmodellen Blazor Server har följande begränsningar:
- Det finns vanligtvis högre svarstider. Varje användarinteraktion innebär ett nätverkshopp.
- Det finns inget offlinestöd. Om klientanslutningen misslyckas misslyckas interaktiviteten.
- För att skala appar med många användare krävs serverresurser för att hantera flera klientanslutningar och klienttillstånd.
- En ASP.NET Core-server krävs för att hantera appen. Serverlösa distributionsscenarier är inte möjliga, till exempel att hantera appen från ett nätverk för innehållsleverans (CDN).
Vi rekommenderar att du använder Azure SignalR Service för appar som använder Blazor Server värdmodell. Tjänsten gör det möjligt att skala upp en Blazor Server app till ett stort antal samtidiga SignalR anslutningar.
Blazor WebAssembly
Värdmodellen Blazor WebAssembly kör komponenter på klientsidan i webbläsaren på en WebAssembly-baserad .NET-runtime. Razor-komponenter, deras beroenden och .NET-runtime laddas ned till webbläsaren. Komponenter körs direkt i webbläsarens användargränssnittstråd. Uppdateringar av användargränssnittet och händelsehantering sker inom samma process. Tillgångar distribueras som statiska filer till en webbserver eller tjänst som kan hantera statiskt innehåll till klienter.
Blazor webbappar kan använda Blazor WebAssembly värdmodell för att aktivera interaktivitet på klientsidan. När en app skapas som uteslutande körs på Blazor WebAssembly värdmodell utan återgivning på serversidan och interaktivitet kallas appen för en friståendeBlazor WebAssembly app.
När Blazor WebAssembly-appen skapas för utplacering utan en ASP.NET Core-backend för att tillhandahålla sina filer, kallas appen för en fristående Blazor WebAssembly-app.
När en fristående Blazor WebAssembly app använder en serverdelsapp ASP.NET Core för att hantera sina filer kallas appen för en värdbaseradBlazor WebAssembly app. Med hjälp av värdbaserade Blazor WebAssemblyfår du en fullständig webbutvecklingsupplevelse med .NET, inklusive möjligheten att dela kod mellan klient- och serverappar, stöd för prerendering och integrering med MVC och Razor Pages. En värdbaserad klientapp kan interagera med sin serverapp via nätverket med hjälp av en mängd olika meddelanderamverk och protokoll, till exempel webb-API, gRPC-weboch SignalR (Use ASP.NET Core SignalR with Blazor).
En Blazor WebAssembly app som skapats som en Progressive Web App (PWA) använder moderna webbläsar-API:er för att möjliggöra många av funktionerna i en native klientapp, till exempel fungera offline, köra i ett eget appfönster, starta från värdsystemets operativsystem, ta emot push-meddelanden och automatiskt uppdatera i bakgrunden.
Skriptet Blazor hanterar:
- Laddar ner .NET runtime, Razor-komponenter och beroenden.
- Körningsinitiering.
Storleken på den publicerade appen, dess nyttolaststorlek, är en viktig prestandafaktor för en apps användbarhet. En stor app tar relativt lång tid att ladda ned till en webbläsare, vilket minskar användarupplevelsen. Blazor WebAssembly optimerar nyttolaststorleken för att minska nedladdningstiderna:
- Oanvänd kod tas bort från appen när den publiceras av mellanspråketrimmern (IL-trimmern) .
- HTTP-svar komprimeras.
- .NET-körningen och sammansättningarna cachelagras i webbläsaren.
Värdmodellen Blazor WebAssembly erbjuder flera fördelar:
- För fristående Blazor WebAssembly appar finns det inget .NET-beroende på serversidan när appen har laddats ned från servern, så appen fungerar fortfarande om servern går offline.
- Klientresurser och -funktioner utnyttjas fullt ut.
- Arbetet avlastas från servern till klienten.
- För fristående Blazor WebAssembly appar krävs ingen ASP.NET Core-webbserver för att vara värd för appen. Serverlösa distributionsscenarier är möjliga, till exempel att hantera appen från ett nätverk för innehållsleverans (CDN).
Värdmodellen Blazor WebAssembly har följande begränsningar:
- Razor komponenter är begränsade till funktionerna i webbläsaren.
- Kompatibel klientmaskinvara och programvara (till exempel WebAssembly-support) krävs.
- Nedladdningsstorleken är större och komponenterna tar längre tid att läsa in.
- Kod som skickas till klienten kan inte skyddas från kontroll och manipulering av användare.
.NET Intermediate Language (IL)-tolken innehåller delvis jit(just-in-time) runtime-stöd för att få bättre körningsprestanda. JIT-tolken optimerar körningen av tolkbytekoder genom att ersätta dem med små blobar med WebAssembly-kod. JIT-tolken aktiveras automatiskt för Blazor WebAssembly appar förutom vid felsökning.
Blazor stöder AOT-kompilering (i förväg) där du kan kompilera .NET-koden direkt till WebAssembly. AOT-kompilering resulterar i prestandaförbättringar vid körning på bekostnad av en ökad appstorlek. Mer information finns i ASP.NET Core Blazor WebAssembly byggverktyg och ahead-of-time (AOT) kompilering.
Samma .NET WebAssembly-byggverktyg som används för AOT-kompilering länkar även om .NET WebAssembly-runtime för att trimma oanvänd körningskod. Blazor trimmar även oanvänd kod från .NET Framework-bibliotek. .NET-kompilatorn vidareförkomprimerar en fristående app Blazor WebAssembly för en mindre applikationsbelastning.
WebAssembly-renderade Razor-komponenter kan använda inbyggda beroenden som skapats för att köras på WebAssembly.
Blazor WebAssembly innehåller stöd för att trimma oanvänd kod från .NET Core-ramverksbibliotek. Mer information finns i ASP.NET Core Blazor globalisering och lokalisering.
Blazor Hybrid
Blazor kan också användas för att skapa interna klientappar med hjälp av en hybridmetod. Hybridappar är inbyggda appar som använder webbtekniker för sina funktioner. I en Blazor Hybrid-app körs Razor-komponenter direkt i den ursprungliga appen (inte på WebAssembly) tillsammans med all annan .NET-kod och renderar webbgränssnitt baserat på HTML och CSS till en inbäddad Web View-kontrollkomponent via en lokal interopkanal.
Blazor Hybrid appar kan skapas med olika .NET-inbyggda appramverk, inklusive .NET MAUI, WPF och Windows Forms.
Blazor tillhandahåller BlazorWebView kontroller för att lägga till Razor komponenter i appar som skapats med dessa ramverk. Att använda Blazor med .NET MAUI är ett bekvämt sätt att skapa plattformsoberoende Blazor Hybrid appar för mobil och stationär dator, medan Blazor integrering med WPF och Windows Forms kan vara ett bra sätt att modernisera befintliga appar.
Eftersom Blazor Hybrid appar är inbyggda appar kan de ha stöd för funktioner som inte bara är tillgängliga med webbplattformen. Blazor Hybrid appar har fullständig åtkomst till inbyggda plattformsfunktioner via vanliga .NET-API:er. Blazor Hybrid appar kan också dela och återanvända komponenter med befintliga Blazor Server eller Blazor WebAssembly appar. Blazor Hybrid appar kombinerar fördelarna med webben, interna appar och .NET-plattformen.
Värdmodellen Blazor Hybrid erbjuder flera fördelar:
- Återanvänd befintliga komponenter som kan delas mellan mobila enheter, datorer och webbplatser.
- Utnyttja webbutvecklingskunskaper, erfarenhet och resurser.
- Appar har fullständig åtkomst till enhetens interna funktioner.
Värdmodellen Blazor Hybrid har följande begränsningar:
- Separata interna klientappar måste skapas, distribueras och underhållas för varje målplattform.
- Inhemska klientappar tar vanligtvis längre tid att hitta, ladda ned och installera jämfört med att använda en webbapp i en webbläsare.
Mer information finns i ASP.NET Core Blazor Hybrid.
Mer information om Microsofts interna klientramverk finns i följande resurser:
Vilken Blazor värdmodell ska jag välja?
En komponents värdmodell anges av dess återgivningsläge, antingen vid kompilering eller körningstid, vilket beskrivs med exempel i ASP.NET Core Blazor återgivningslägen. Följande tabell visar de viktigaste övervägandena för att ange återgivningsläget för att fastställa en komponents värdmodell. För fristående Blazor WebAssembly appar återges alla appens komponenter på klienten med Blazor WebAssembly värdmodell.
Välj Blazor värdmodell baserat på appens funktionskrav. Följande tabell visar de viktigaste övervägandena för att välja värdmodell.
Blazor Hybrid appar inkluderar .NET MAUI, WPF och Windows Forms framework-appar.
| Funktion | Blazor Server | Blazor WebAssembly (WASM) | Blazor Hybrid |
|---|---|---|---|
| Fullständig .NET API-kompatibilitet | ✔️ stöds | Stöds inte | ✔️ stöds |
| Direktåtkomst till server- och nätverksresurser | ✔️ stöds | Stöds inte† | Stöds inte† |
| Liten nyttolaststorlek med snabb starttid | ✔️ stöds | Stöds inte | Stöds inte |
| Nästan inbyggd körhastighet | ✔️ stöds | ✔️ stöds‡ | ✔️ stöds |
| Appkoden är säker och privat på servern | ✔️ stöds | Stöds inte† | Stöds inte† |
| Kör appar offline när de har laddats ned | Stöds inte | ✔️ stöds | ✔️ stöds |
| Hosting av statisk webbplats | Stöds inte | ✔️ stöds | Stöds inte |
| avlastar bearbetning till klienter | Stöds inte | ✔️ stöds | ✔️ stöds |
| Fullständig åtkomst till interna klientfunktioner | Stöds inte | Stöds inte | ✔️ stöds |
| webbaserad distribution | ✔️ stöds | ✔️ stöds | Stöds inte |
†Blazor WebAssembly och Blazor Hybrid appar kan använda serverbaserade API:er för att komma åt server-/nätverksresurser och få åtkomst till privat och säker appkod.
‡Blazor WebAssembly når bara nästan inhemsk prestanda med AOT-kompilering.
| Funktion | Blazor Server | Blazor WebAssembly (WASM) |
|---|---|---|
| Fullständig .NET API-kompatibilitet | ✔️ stöds | Stöds inte |
| Direktåtkomst till server- och nätverksresurser | ✔️ stöds | Stöds inte† |
| Liten nyttolaststorlek med snabb starttid | ✔️ stöds | Stöds inte |
| Appkoden är säker och privat på servern | ✔️ stöds | Stöds inte† |
| Kör appar offline när de har laddats ned | Stöds inte | ✔️ stöds |
| Hosting av statiska webbplatser | Stöds inte | ✔️ stöds |
| avlastar bearbetning till klienter | Stöds inte | ✔️ stöds |
†Blazor WebAssembly appar kan använda serverbaserade API:er för att komma åt server-/nätverksresurser och få åtkomst till privat och säker appkod.
När du har valt appens värdmodell kan du generera en Blazor Server eller Blazor WebAssembly app från en Blazor projektmall. Mer information finns i Tooling for ASP.NET Core Blazor.
Information om hur du skapar en Blazor Hybrid-app finns i artiklarna under ASP.NET Core Blazor Hybrid-självstudier.
Slutför .NET API-kompatibilitet
Komponenter som återges för Blazor Server värdmodell och Blazor Hybrid-appar har fullständig .NET API-kompatibilitet, medan komponenter som återges för Blazor WebAssembly är begränsade till en delmängd av .NET API:er. När en apps specifikation kräver en eller flera .NET-API:er som inte är tillgängliga för WebAssembly-renderade komponenter väljer du att rendera komponenter för Blazor Server eller använda Blazor Hybrid.
Blazor Server och Blazor Hybrid appar har fullständig .NET API-kompatibilitet, medan Blazor WebAssembly appar är begränsade till en delmängd av .NET-API:er. När en apps specifikation kräver en eller flera .NET-API:er som inte är tillgängliga för Blazor WebAssembly appar väljer du sedan Blazor Server eller Blazor Hybrid.
Blazor Server appar har fullständig .NET API-kompatibilitet, medan Blazor WebAssembly appar är begränsade till en delmängd av .NET API:er. När en apps specifikation kräver en eller flera .NET-API:er som inte är tillgängliga för Blazor WebAssembly appar väljer du sedan Blazor Server.
Direktåtkomst till server- och nätverksresurser
Komponenter som återges för Blazor Server värdmodell har direkt åtkomst till server- och nätverksresurser där appen körs. Eftersom komponenter som hanteras med hjälp av Blazor WebAssembly eller Blazor Hybrid körs på en klient, har de inte direkt åtkomst till server- och nätverksresurser. Komponenter kan komma åt server- och nätverksresurser indirekt via skyddade serverbaserade API:er. Serverbaserade API:er kan vara tillgängliga via bibliotek, paket och tjänster från tredje part. Ta hänsyn till följande överväganden:
- Bibliotek, paket och tjänster från tredje part kan vara kostsamma att implementera och underhålla, svagt stödja eller införa säkerhetsrisker.
- Om en eller flera serverbaserade API:er utvecklas internt av din organisation krävs ytterligare resurser för att skapa och underhålla dem.
Använd Blazor Server värdmodell för att undvika behovet av att exponera API:er från servermiljön.
Blazor Server appar har direkt åtkomst till server- och nätverksresurser där appen körs. Eftersom Blazor WebAssembly och Blazor Hybrid appar körs på en klient har de inte direkt åtkomst till server- och nätverksresurser. Blazor WebAssembly och Blazor Hybrid appar kan komma åt server- och nätverksresurser indirekt via skyddade serverbaserade API:er. Serverbaserade API:er kan vara tillgängliga via bibliotek, paket och tjänster från tredje part. Ta hänsyn till följande överväganden:
- Bibliotek, paket och tjänster från tredje part kan vara kostsamma att implementera och underhålla, svagt stödja eller införa säkerhetsrisker.
- Om en eller flera serverbaserade API:er utvecklas internt av din organisation krävs ytterligare resurser för att skapa och underhålla dem.
Om du vill undvika serverbaserade API:er för Blazor WebAssembly eller Blazor Hybrid appar kan du använda Blazor Server, som kan komma åt server- och nätverksresurser direkt.
Blazor Server appar har direkt åtkomst till server- och nätverksresurser där appen körs. Eftersom Blazor WebAssembly appar körs på en klient har de inte direkt åtkomst till server- och nätverksresurser. Blazor WebAssembly appar kan komma åt server- och nätverksresurser indirekt via skyddade serverbaserade API:er. Serverbaserade API:er kan vara tillgängliga via bibliotek, paket och tjänster från tredje part. Ta hänsyn till följande överväganden:
- Bibliotek, paket och tjänster från tredje part kan vara kostsamma att implementera och underhålla, svagt stödja eller införa säkerhetsrisker.
- Om en eller flera serverbaserade API:er utvecklas internt av din organisation krävs ytterligare resurser för att skapa och underhålla dem.
Om du vill undvika serverbaserade API:er för Blazor WebAssembly appar använder du Blazor Server, som kan komma åt server- och nätverksresurser direkt.
Liten nyttolast med snabb laddning från start
Rendering av komponenter från servern minskar appens nyttolaststorlek och förbättrar de första inläsningstiderna. När du vill ha en snabb inledande inläsningstid kan du använda Blazor Server värdmodell eller överväga statisk återgivning på serversidan.
Blazor Server appar har relativt små nyttolaststorlekar med snabbare inledande inläsningstider. För att få en snabb inläsningstid, använd Blazor Server.
Nära nativ körningshastighet
Blazor Hybrid appar körs med .NET runtime nativt på målplattformen, vilket ger bästa möjliga hastighet.
Komponenter som renderas för Blazor WebAssembly-värdmodellen, inklusive progressiva webbappar (PWA) och fristående appar Blazor WebAssembly, körs med hjälp av .NET-körmiljön för WebAssembly, vilket är långsammare än att köra direkt på plattformen. Överväg att använda i förväg (AOT) som kompilerats för att förbättra körningsprestanda när du använder Blazor WebAssembly.
Blazor Hybrid-appar körs naturligt med .NET runtime:en på målplattformen, vilket ger bästa möjliga hastighet.
Blazor WebAssembly, inklusive Progressive Web Apps (PWA) körs appar med hjälp av .NET-körningen för WebAssembly, vilket är långsammare än att köra direkt på plattformen, även för appar som i förväg (AOT) som kompilerats för WebAssembly i webbläsaren.
Blazor Server appar körs vanligtvis snabbt på servern.
Blazor WebAssembly-appar körs med .NET-runtime för WebAssembly, och detta är långsammare än att köra direkt på plattformen.
Säker och privat appkod på servern
Att underhålla appkod på ett säkert och privat sätt på servern är en inbyggd funktion i komponenter som återges för Blazor Server värdmodell. Komponenter som återges med hjälp av Blazor WebAssembly eller Blazor Hybrid värdmodeller kan använda serverbaserade API:er för att få åtkomst till funktioner som måste hållas privata och säkra. Överväganden för att utveckla och underhålla serverbaserade API:er som beskrivs i avsnittet Direkt åtkomst till server- och nätverksresurser gäller. Om utveckling och underhåll av serverbaserade API:er inte är önskvärda för att upprätthålla säker och privat appkod, rendera komponenter för Blazor Server värdmodell.
Att underhålla appkod på ett säkert och privat sätt på servern är en inbyggd funktion i Blazor Server. Blazor WebAssembly och Blazor Hybrid appar kan använda serverbaserade API:er för att få åtkomst till funktioner som måste hållas privata och säkra. Överväganden för att utveckla och underhålla serverbaserade API:er som beskrivs i avsnittet Direkt åtkomst till server- och nätverksresurser gäller. Om utveckling och underhåll av serverbaserade API:er inte är önskvärda för att upprätthålla säker och privat appkod bör du använda Blazor Server värdmodell.
Att underhålla appkod på ett säkert och privat sätt på servern är en inbyggd funktion i Blazor Server. Blazor WebAssembly appar kan använda serverbaserade API:er för att få åtkomst till funktioner som måste hållas privata och säkra. Överväganden för att utveckla och underhålla serverbaserade API:er som beskrivs i avsnittet Direkt åtkomst till server- och nätverksresurser gäller. Om utveckling och underhåll av serverbaserade API:er inte är önskvärda för att upprätthålla säker och privat appkod bör du använda Blazor Server värdmodell.
Kör appar offline när de har laddats ned
Fristående Blazor WebAssembly appar som skapats som PWA (Progressive Web Apps) och Blazor Hybrid appar kan köras offline, vilket är särskilt användbart när klienter inte kan ansluta till Internet. Komponenter som återges för Blazor Server värdmodell kan inte köras när anslutningen till servern går förlorad. Om en app måste köras offline är fristående Blazor WebAssembly och Blazor Hybrid de bästa alternativen.
Blazor WebAssembly appar som skapats som PWA(Progressive Web Apps) och Blazor Hybrid appar kan köras offline, vilket är särskilt användbart när klienter inte kan ansluta till Internet. Blazor Server appar kan inte köras när anslutningen till servern går förlorad. Om en app måste köras offline är Blazor WebAssembly och Blazor Hybrid de bästa alternativen.
Blazor WebAssembly appar kan köras offline, vilket är särskilt användbart när klienter inte kan ansluta till Internet. Blazor Server appar kan inte köras när anslutningen till servern går förlorad. Om en app måste köras offline är Blazor WebAssembly det bästa valet.
Webbhotell för statisk webbplats
Att vara värd för statiska webbplatser är möjligt med fristående Blazor WebAssembly-appar eftersom de laddas ner till klienter som en uppsättning statiska filer. Fristående Blazor WebAssembly appar kräver inte att en server kör kod på serversidan för att ladda ned och köra och kan levereras via ett Content Delivery Network (CDN) (till exempel Azure CDN-).
Även om Blazor Hybrid appar kompileras till en eller flera fristående distributionstillgångar, tillhandahålls tillgångarna vanligtvis till klienter via en appbutik från tredje part. Om statisk värd är ett appkrav väljer du fristående Blazor WebAssembly.
Avlastar bearbetning till klienter
Komponenter som återges med hjälp av Blazor WebAssembly eller Blazor Hybrid värdmodeller körs på klienter och avlastar därmed bearbetning till klienter. Komponenter som återges för Blazor Server värdmodell körs på en server, så efterfrågan på serverresurser ökar vanligtvis med antalet användare och mängden bearbetning som krävs per användare. När det är möjligt att avlasta de flesta eller alla av en apps bearbetning till klienter och appen bearbetar en betydande mängd data är Blazor WebAssembly eller Blazor Hybrid det bästa valet.
Blazor WebAssembly och Blazor Hybrid appar körs på klienter och avlastar därför bearbetning till klienter. Blazor Server appar körs på en server, så efterfrågan på serverresurser ökar vanligtvis med antalet användare och mängden bearbetning som krävs per användare. När det är möjligt att avlasta de flesta eller alla av en apps bearbetning till klienter och appen bearbetar en betydande mängd data är Blazor WebAssembly eller Blazor Hybrid det bästa valet.
Blazor WebAssembly-appar körs på klienter och avlastar därför bearbetning till klienter. Blazor Server appar körs på en server, så efterfrågan på serverresurser ökar vanligtvis med antalet användare och mängden bearbetning som krävs per användare. När det är möjligt att avlasta de flesta eller alla av en apps bearbetning till klienter och appen bearbetar en betydande mängd data, är Blazor WebAssembly det bästa valet.
Fullständig åtkomst till interna klientfunktioner
Blazor Hybrid appar har fullständig åtkomst till interna klient-API-funktioner via .NET-interna appramverk. I Blazor Hybrid appar körs Razor komponenter direkt i den interna appen, inte på WebAssembly. När fullständiga klientfunktioner är ett krav är Blazor Hybrid det bästa valet.
Webbaserad distribution
Blazor webbappar uppdateras vid nästa appuppdatering från webbläsaren.
Blazor Hybrid appar är interna klientappar som vanligtvis kräver en installationsprogram- och plattformsspecifik distributionsmekanism.
Ange en komponents värdmodell
Om du vill ange en komponents värdmodell till Blazor Server eller Blazor WebAssembly vid kompileringstid eller dynamiskt vid körning anger du dess återgivningsläge. Återgivningslägen förklaras fullständigt och visas i artikeln ASP.NET Core Blazor renderingslägen. Vi rekommenderar inte att du hoppar från den här artikeln direkt till Renderlägen-artikeln utan att först ha läst innehållet i artiklarna däremellan. Renderningslägen är till exempel lättare att förstå genom att titta på Razor komponentexempel, men grundläggande Razor komponentstruktur och funktion behandlas inte förrän man når artikeln om ASP.NET Core Blazor grunderna. Det är också bra att lära dig mer om Blazorprojektmallar och verktyg innan du arbetar med komponentexemplen i artikeln Rendera lägen.
ASP.NET Core