Blazor: Webfrontends mit C# statt JavaScript entwickeln

Render-Modi, WebAssembly und Serverbetrieb: was Blazor seit .NET 8 kann, wo es an Grenzen stößt und für welche Teams es sich lohnt
Aktualisiert:
Abstract
- #Blazor
- #Webentwicklung
- #C#
- #WebAssembly
- #Frontend
- #Webanwendungen
- #ASP.NET Core
- #.NET
Wann ein .NET-Team seine Weboberfläche in C# schreiben sollte und wann JavaScript die bessere Wahl bleibt
Angenommen, ein mittelständischer Maschinenbauer beschäftigt ein kleines .NET-Team. Es pflegt seit Jahren das ERP-Backend, die Schnittstellen zu den Maschinen und ein paar Desktop-Werkzeuge, alles in C#. Nun soll das Serviceportal für Kunden eine zeitgemäße Weboberfläche bekommen. Der übliche Weg hieße: TypeScript lernen, sich für React oder Angular entscheiden, npm-Pakete und Build-Werkzeuge einrichten und künftig zwei Technikwelten pflegen.
Blazor verspricht eine Abkürzung. Das Framework von Microsoft erlaubt es, interaktive Weboberflächen in C# zu schreiben, mit denselben Datenmodellen, Validierungsregeln und Bibliotheken wie im Backend. Das Versprechen „ohne JavaScript“ stimmt allerdings nur zum Teil, und die Entscheidung für Blazor hat Folgen für Ladezeiten, Serverlast und Personalplanung. Der folgende Überblick zeigt, wie Blazor heute arbeitet, was sich mit .NET 8 grundlegend geändert hat und für welche Projekte es passt.
Was Blazor ist und woher es kommt
Blazor ist Teil von ASP.NET Core, dem quelloffenen Web-Framework von Microsoft. Der Name verbindet „Browser“ und „Razor“, die Vorlagensyntax, mit der in .NET seit Langem HTML und C# gemischt werden. Wie React oder Vue setzt Blazor auf Komponenten: in sich geschlossene Bausteine der Oberfläche, etwa ein Suchfeld, eine Auftragstabelle oder ein ganzes Formular, die sich verschachteln und wiederverwenden lassen.
Den Anstoß gab Steve Sanderson, der damals bei Microsoft arbeitete und zuvor die JavaScript-Bibliothek Knockout.js entwickelt hatte. Aus seinem Experiment wurde 2018 ein offizielles, zunächst experimentelles Projekt. 2019 erschien Blazor Server als stabile Version, 2020 folgte Blazor WebAssembly. Lange musste sich ein Team zu Projektbeginn für eines der beiden Modelle entscheiden.
Mit .NET 8 im November 2023 hat Microsoft dieses Entweder-oder aufgelöst. Die Projektvorlage heißt seitdem „Blazor Web App“, und jede Seite oder Komponente bekommt einen eigenen Render-Modus. Wer ältere Tutorials liest, sollte deshalb auf das Datum achten: Vieles, was dort über Hosting-Modelle steht, beschreibt den Stand vor .NET 8.
Komponenten aus Razor und C#
Eine Blazor-Komponente ist eine Datei mit der Endung .razor. Oben steht HTML mit eingebetteten C#-Ausdrücken, darunter ein @code-Block mit der Logik. Das klassische Einstiegsbeispiel ist ein Zähler:
@page "/zaehler"
@rendermode InteractiveServer
<h1>Zähler</h1>
<p role="status">Aktueller Wert: @aktuellerWert</p>
<button class="btn btn-primary" @onclick="Erhoehen">Erhöhen</button>
@code {
private int aktuellerWert = 0;
private void Erhoehen()
{
aktuellerWert++;
}
}
Die Direktive @page macht die Komponente unter der Adresse /zaehler erreichbar. @rendermode InteractiveServer legt fest, dass die Komponente interaktiv ist und ihre Logik auf dem Server ausführt. Fehlt diese Zeile, rendert Blazor die Seite nur einmal als statisches HTML, und der Knopf bliebe ohne Wirkung.
Nach einem Klick ruft Blazor die Methode Erhoehen auf, rendert die Komponente neu und vergleicht das Ergebnis mit dem vorherigen Stand. An den Browser geht nur der Unterschied, in diesem Fall die geänderte Zahl. Dieses Prinzip eines Abgleichs im Speicher kennen Entwickler:innen von React.
Daten erhalten Komponenten über Parameter, also öffentliche Eigenschaften mit dem Attribut [Parameter]. Dienste wie ein Datenbankzugriff oder ein API-Client kommen über Dependency Injection hinein, ein Verfahren, bei dem die Anwendung benötigte Objekte zentral bereitstellt, statt dass jede Komponente sie selbst erzeugt. In der Komponente genügt dafür eine Zeile wie @inject IAuftragsService Auftraege. Das erleichtert Tests, weil sich der echte Dienst durch eine Attrappe ersetzen lässt.
Die vier Render-Modi seit .NET 8
Der Render-Modus entscheidet, wo der C#-Code einer Komponente läuft und wie sie mit dem Browser spricht. Er lässt sich für die ganze Anwendung, für einzelne Seiten oder sogar für einzelne Komponenten festlegen.
Statisches Server-Rendering
Der Server erzeugt HTML und schickt es an den Browser, ähnlich wie klassische Webseiten oder Razor Pages. Es gibt keine dauerhafte Verbindung und keine Ereignisbehandlung im Browser. Formulare funktionieren trotzdem, weil sie wie gewohnt per HTTP abgeschickt werden. Für Inhaltsseiten, Produktlisten oder Anmeldemasken ist das oft völlig ausreichend, und die Seiten laden schnell und sind für Suchmaschinen gut lesbar.
Interaktiv auf dem Server
Der Code bleibt auf dem Server. Der Browser baut über SignalR, eine Bibliothek für Echtzeitverbindungen auf Basis von WebSockets, eine dauerhafte Verbindung auf. Jeder Klick wandert zum Server, die Antwort kommt als kleine Änderung am Seitenaufbau zurück. Der Vorteil: Die erste Anzeige ist schnell, und der Code kann direkt auf Datenbanken und interne Dienste zugreifen, ohne eigene API. Der Nachteil: Jede Interaktion braucht einen Netzwerk-Umlauf, der Server hält für jede offene Sitzung Zustand im Speicher, und bei einer abgerissenen Verbindung muss sich die Seite neu verbinden.
Interaktiv per WebAssembly
Hier lädt der Browser eine .NET-Laufzeitumgebung und die Anwendungsbibliotheken herunter und führt den Code lokal aus. WebAssembly ist ein Binärformat, das alle aktuellen Browser neben JavaScript ausführen können. Nach dem Laden reagiert die Oberfläche ohne Umweg über den Server, und die Anwendung kann teilweise offline arbeiten. Dafür dauert der erste Aufruf spürbar länger, und der Code im Browser darf nur über eine API auf Daten zugreifen, denn alles, was dort läuft, kann ein Nutzer einsehen.
Auto-Modus
Der Modus „Auto“ verbindet beides. Beim ersten Besuch arbeitet die Komponente über die Serververbindung, während im Hintergrund die WebAssembly-Dateien geladen werden. Bei späteren Besuchen läuft sie dann im Browser. Das klingt nach dem Besten aus beiden Welten, verlangt aber, dass der Code in beiden Umgebungen funktioniert, meist mit einer Schnittstelle, die serverseitig direkt und im Browser über HTTP umgesetzt ist.
| Render-Modus | Wo läuft C#? | Erste Anzeige | Laufende Verbindung | Typischer Einsatz |
|---|---|---|---|---|
| Statisch (Server) | Server | schnell | keine | Inhaltsseiten, Formulare, Listen |
| Interaktiv Server | Server | schnell | SignalR | interne Fachanwendungen |
| Interaktiv WebAssembly | Browser | langsamer | nur API-Aufrufe | rechenintensive, offlinefähige Apps |
| Auto | erst Server, dann Browser | schnell | wechselnd | öffentliche Portale mit Interaktion |
In der Praxis kombinieren viele Anwendungen die Modi: Die Startseite und die Hilfetexte werden statisch ausgeliefert, nur das Auftragsformular mit Live-Validierung ist interaktiv.
Was WebAssembly leistet und was nicht
Das alte Versprechen „blitzschnell dank WebAssembly“ hält einer nüchternen Betrachtung nur teilweise stand. Standardmäßig übersetzt Blazor WebAssembly den C#-Code nicht in WebAssembly, sondern lädt eine in WebAssembly übersetzte .NET-Laufzeit, die den Zwischencode der Anwendung interpretiert, also Befehl für Befehl ausführt, seit .NET 8 ergänzt um eine teilweise Just-in-time-Übersetzung. Das ist für typische Formulare und Tabellen schnell genug, aber nicht schneller als gut geschriebenes JavaScript.
Für rechenintensive Teile gibt es die AOT-Kompilierung (Ahead of Time): Der Code wird beim Build direkt in WebAssembly übersetzt. Das beschleunigt etwa Berechnungen oder Bildverarbeitung deutlich, macht die herunterzuladenden Dateien aber größer und den Build langsamer. Gegen die Größe hilft das Trimming, bei dem der Build ungenutzten Code aus den Bibliotheken entfernt.
Eine Grenze bleibt: WebAssembly darf das Seitenlayout im Browser, den DOM, nicht direkt verändern. Jede Änderung läuft über eine Brücke in JavaScript. Für Oberflächen mit sehr vielen Elementen, etwa Tabellen mit Tausenden Zeilen, braucht es deshalb Techniken wie Virtualisierung, bei der nur die sichtbaren Zeilen gerendert werden. Blazor bringt dafür die Komponente Virtualize mit. Wie WebAssembly grundsätzlich funktioniert und wo seine Stärken liegen, beschreibt der Beitrag über WebAssembly von C++ bis Rust.
Ganz ohne JavaScript geht es selten
Für viele Fachanwendungen schreibt ein Blazor-Team tatsächlich kaum eine Zeile JavaScript. Ganz verschwindet die Sprache trotzdem nicht. Blazor selbst lädt ein eigenes Skript, das die Verbindung zum Server oder zur WebAssembly-Laufzeit herstellt. Und sobald eine Anwendung Browser-Funktionen braucht, für die .NET keine Schnittstelle hat, oder eine bewährte JavaScript-Bibliothek für Karten oder Diagramme nutzen soll, kommt die JavaScript-Interop ins Spiel.
Über den Dienst IJSRuntime ruft C#-Code JavaScript-Funktionen auf, umgekehrt kann JavaScript mit Methoden zusammenarbeiten, die das Attribut [JSInvokable] tragen. Ein Beispiel ist das Kopieren in die Zwischenablage:
@inject IJSRuntime JS
<button @onclick="Kopieren">Auftragsnummer kopieren</button>
@code {
[Parameter] public string Auftragsnummer { get; set; } = "";
private async Task Kopieren()
{
// Ruft die Browser-API direkt über ihren Namen auf
await JS.InvokeVoidAsync("navigator.clipboard.writeText", Auftragsnummer);
}
}
Die Interop ist bewusst asynchron und sollte sparsam eingesetzt werden, weil jeder Aufruf im Server-Modus über das Netzwerk geht. Details zu Aufrufrichtungen, Fehlerbehandlung und Performance stehen im Beitrag über JavaScript Interop in ASP.NET Core Blazor.
Ein Projekt aufsetzen
Für den Einstieg genügt das .NET SDK. Mit der Kommandozeile entsteht ein neues Projekt, hier mit dem Auto-Modus als Voreinstellung:
dotnet new blazor -o Serviceportal --interactivity Auto
cd Serviceportal
dotnet watch --project Serviceportal
Die Option --interactivity akzeptiert None, Server, WebAssembly und Auto. Bei WebAssembly und Auto legt die Vorlage zwei Projekte an: eines für den Server und eines mit der Endung .Client für alles, was im Browser laufen soll. dotnet watch startet die Anwendung und lädt Änderungen am Code nach Möglichkeit ohne Neustart nach (Hot Reload).
Die Render-Modi werden in der Datei Program.cs registriert. Dort meldet das Team auch eigene Dienste für die Dependency Injection an:
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddRazorComponents()
.AddInteractiveServerComponents()
.AddInteractiveWebAssemblyComponents();
// Eigener Dienst, je Benutzersitzung eine Instanz
builder.Services.AddScoped<IAuftragsService, AuftragsService>();
var app = builder.Build();
app.UseAntiforgery();
app.MapStaticAssets();
app.MapRazorComponents<App>()
.AddInteractiveServerRenderMode()
.AddInteractiveWebAssemblyRenderMode()
.AddAdditionalAssemblies(typeof(Serviceportal.Client._Imports).Assembly);
app.Run();
Als Entwicklungsumgebung eignen sich Visual Studio, Visual Studio Code mit der Erweiterung C# Dev Kit oder JetBrains Rider. Für automatisierte Komponententests hat sich die quelloffene Bibliothek bUnit etabliert.
Ökosystem und Blazor Hybrid
Das Ökosystem ist kleiner als das von React oder Angular, aber für Geschäftsanwendungen gut bestückt. Microsoft liefert Grundbausteine wie Formulare mit Validierung, Authentifizierung und das Tabellen-Raster QuickGrid. Dazu kommen Komponentenbibliotheken, quelloffen etwa MudBlazor, Radzen oder die Fluent UI Blazor Components von Microsoft, kommerziell unter anderem Telerik und Syncfusion. Wer dagegen eine bestimmte, nur für React verfügbare Bibliothek braucht, muss sie über die Interop einbinden oder auf sie verzichten.
Blazor-Komponenten laufen nicht nur im Browser. Mit Blazor Hybrid lassen sie sich in Desktop- und Mobil-Apps einbetten, etwa mit .NET MAUI, WPF oder Windows Forms. Die Komponenten werden dabei in einer eingebetteten Browser-Ansicht dargestellt, nicht mit nativen Bedienelementen des Betriebssystems, haben aber vollen Zugriff auf die Geräte-Schnittstellen über .NET. Für ein Team, das dieselbe Oberfläche im Web und als Tablet-App für den Außendienst braucht, ist das ein handfester Vorteil. Wie sich das mit .NET MAUI umsetzen lässt, beschreibt die Themenseite zu .NET MAUI.
Für wen sich Blazor lohnt
Blazor ist kein Ersatz für JavaScript im ganzen Web, aber eine ernsthafte Option für eine klar umrissene Gruppe von Projekten. Am stärksten ist es bei internen Fachanwendungen und Kundenportalen von Organisationen, die ohnehin auf .NET setzen: Verwaltungsoberflächen, Auftragserfassung, Dashboards, Konfiguratoren. Hier zählt, dass Datenmodelle, Validierung und Geschäftslogik nur einmal existieren und ein Team das gesamte System versteht.
Weniger gut passt Blazor, wenn
- ein Team bereits sicher mit React, Angular oder Vue arbeitet und keinen .NET-Hintergrund hat,
- eine öffentliche Website vor allem schnell laden und gut gefunden werden muss und kaum Interaktion braucht (hier reichen statisch erzeugte Seiten oder schlanke Ansätze wie HTMX),
- sehr viele gleichzeitige Nutzer erwartet werden und nur der Server-Modus in Frage käme, weil dann Arbeitsspeicher und Verbindungen zum Engpass werden können.
Zu bedenken ist auch die Bindung an Microsoft und dessen Taktung: Jedes Jahr im November erscheint eine neue .NET-Version, abwechselnd mit drei Jahren Unterstützung (LTS) und kürzerer Unterstützung (STS). Blazor hat sich in dieser Zeit stark verändert, zuletzt vor allem durch die Render-Modi. Wer ein Projekt startet, sollte ein Update im Jahresrhythmus fest einplanen.
Unsere Einschätzung: Für .NET-Teams, die eine Geschäftsanwendung mit Weboberfläche bauen, ist Blazor heute eine solide und ausgereifte Wahl, vor allem in Kombination aus statischem Rendering und gezielt interaktiven Komponenten. Überschätzt wird es als allgemeiner Ersatz für JavaScript-Frameworks und als Garant für hohe Performance.
Häufige Fragen zu Blazor
Ist Blazor schneller als JavaScript?
Nicht grundsätzlich. Im WebAssembly-Modus wird der Code standardmäßig interpretiert, und jeder Zugriff auf die Seite läuft über JavaScript. Für typische Formulare ist der Unterschied kaum spürbar. Bei rechenintensiven Aufgaben kann AOT-kompilierter Code schneller sein, bei sehr dynamischen Oberflächen sind gut optimierte JavaScript-Frameworks oft im Vorteil. Der größte spürbare Unterschied ist die längere erste Ladezeit im WebAssembly-Modus.
Wie gut können Suchmaschinen Blazor-Seiten lesen?
Seit .NET 8 rendert Blazor Seiten standardmäßig auf dem Server vor. Suchmaschinen erhalten also fertiges HTML, auch wenn die Seite später interaktiv wird. Reine WebAssembly-Anwendungen ohne Vorrendern waren in dieser Hinsicht früher ein Problem.
Lässt sich eine bestehende ASP.NET-Anwendung schrittweise umstellen?
Ja. Blazor-Komponenten lassen sich in bestehende Razor Pages und MVC-Ansichten einbetten. So kann ein Team einzelne Bereiche modernisieren, ohne die gesamte Anwendung neu zu schreiben. Ältere Projekte auf Basis von Blazor Server oder Blazor WebAssembly aus der Zeit vor .NET 8 laufen weiter, lassen sich aber auch auf das Modell der Blazor Web App umstellen.
Welche .NET-Version sollte ein neues Projekt nutzen?
Für neue Projekte empfiehlt sich in der Regel die aktuelle LTS-Version, derzeit .NET 10 aus dem November 2025. Sie wird drei Jahre mit Updates versorgt. Kürzer unterstützte Versionen lohnen sich vor allem, wenn ein Team ohnehin jährlich aktualisiert und neue Funktionen früh nutzen möchte.
Wer Blazor für ein konkretes Vorhaben bewerten oder ein Team in das Framework einarbeiten möchte, findet auf der Themenseite zu ASP.NET Core unsere Angebote für Beratung, Coaching und Seminare.