Die Puzzleteile verbinden: WPF, ASP.NET Core und gRPC integrieren

Von Mirko Peters · 2026-08-13

Einführung in die moderne .NET-Entwicklung: Integration, Vorteile und Herausforderungen Sie sehen viele Vorteile, wenn Sie WPF, ASP.NET Core MVC und gRPC in Ihrem Projekt …

Automatisch mit KI aus dem Originalbeitrag übersetzt. Englisches Original lesen

Einführung in die moderne .NET-Entwicklung: Integration

Vorteile und Herausforderungen

Bei der Integration von WPF, ASP.NET Core MVC und gRPC in Ihren Projekten ergeben sich viele Vorteile. Dieser Ansatz bietet Ihnen eine einheitliche Lösung für Desktop, Web und die Kommunikation zwischen Diensten. Der m365.fm Modern .NET Development Podcast, moderiert von Mirko Peters mit Microsoft MVP Gábor Ruzsinszki als Gast, zeigt häufig, wie diese Integration beim Aufbau moderner, skalierbarer Anwendungen hilft.

Die folgende Tabelle zeigt die wichtigsten Vorteile der Kombination dieser Technologien:

Außerdem stehen Sie vor einigen Herausforderungen. Sie müssen die Datensynchronisation zwischen WPF und ASP.NET Core MVC verwalten. Sie müssen eine konsistente Benutzererfahrung auf Desktop und Web sicherstellen. Sicherheit und Authentifizierung werden komplexer, wenn Sie gRPC auf ASP.NET Core für die Kommunikation zwischen Diensten einsetzen. Zudem müssen Sie Versionierung und Updates für jeden Teil Ihrer Lösung handhaben.

Tipp: Mit gemeinsam genutzten Bibliotheken halten Sie Ihre Geschäftslogik über WPF, ASP.NET Core MVC und gRPC auf ASP.NET Core hinweg konsistent. Das reduziert doppelten Code und erleichtert die Wartung Ihrer Lösung.

Praxisszenarien

Aus realen Beispielen lässt sich viel lernen. Viele Organisationen haben Legacy-WPF-Anwendungen zu ASP.NET Core MVC und gRPC auf ASP.NET Core migriert. Diese Migrationen zeigen, wie Sie Ihre Software modernisieren und die Leistung verbessern.

Hier ist eine Tabelle mit einigen Beispielen:

Vielleicht beginnen Sie mit einer WPF-Desktop-App, auf die sich Ihre Nutzer täglich verlassen. Sie möchten mehr Nutzer erreichen und entwickeln daher eine Webversion mit ASP.NET Core MVC. Mit gRPC auf ASP.NET Core verbinden Sie Ihre Desktop- und Web-Apps mit gemeinsamen Backend-Diensten. So können Sie Ihre Geschäftslogik wiederverwenden und Ihre Daten synchron halten.

Sie können gRPC auch nutzen, um Microservices in Ihrer Lösung zu verbinden. gRPC auf ASP.NET Core ermöglicht schnelle und zuverlässige Kommunikation zwischen Diensten. Das ist wichtig, wenn Sie Echtzeit-Updates oder hohe Leistung benötigen.

Wenn Sie diese Integrationsmuster anwenden, schaffen Sie flexible und zukunftssichere Lösungen. Sie können neue Funktionen ergänzen, weitere Plattformen unterstützen und Ihre Anwendungen mitwachsen lassen, wenn Ihre Anforderungen steigen.

Entwicklung und Modernisierung von .NET

Von .NET Framework zu .NET Core

Sie haben erlebt, wie sich .NET über die Jahre stark verändert hat. Der Wechsel von .NET Framework zu .NET Core brachte große Verbesserungen für Entwickler und Unternehmen. Wenn Sie .NET 6 oder .NET 7 verwenden, laufen Ihre Anwendungen schneller und benötigen weniger Speicher als ältere Versionen. Sie stellen einen höheren Durchsatz und kürzere Ausführungszeiten fest, was beim Entwickeln von Webanwendungen mit hohem Datenverkehr hilft. Optimierte Ausführungsengines und neue Laufzeitfunktionen machen Ihren Code effizienter. Jede neue Version bringt mehr Geschwindigkeit und eine bessere Speicherverwaltung. Außerdem können Sie Ihre Apps auf verschiedenen Betriebssystemen bereitstellen, was Ihnen die Arbeit erleichtert.

Hier finden Sie eine Tabelle mit den wichtigsten Unterschieden bei Bereitstellung und Wartung zwischen .NET Framework und .NET Core:

Plattformübergreifend und Cloud-nativ

Sie können .NET-Anwendungen jetzt unter Windows, Linux und macOS erstellen und ausführen. Diese Plattformunabhängigkeit gibt Ihnen mehr Möglichkeiten bei der Bereitstellung. Mit Microservices und Containern zerlegen Sie Ihre Anwendungen in kleinere Teile. Das erleichtert die Skalierung und Aktualisierung Ihrer Lösungen. Die tiefe Integration in Azure ermöglicht Ihnen, Werkzeuge und Dienste zu nutzen, die für .NET-Entwickler entwickelt wurden. Mit Serverless Computing über Azure Functions können Sie außerdem sich auf Ihren Code konzentrieren, statt Server zu verwalten. Diese Funktionen helfen Ihnen, leistungsstarke, skalierbare Apps zu entwickeln, die in der Cloud gut funktionieren. Das starke Entwickler-Ökosystem und moderne Werkzeuge machen Ihre Arbeit schneller und zuverlässiger.

Modernisierung von Legacy-Anwendungen

Möglicherweise haben Sie Legacy-Anwendungen, die Updates benötigen, um nutzbar und sicher zu bleiben. Die Modernisierung von Legacy-Anwendungen beginnt mit einem klaren Plan. Erfassen Sie zunächst alle Abhängigkeiten, etwa Bibliotheken von Drittanbietern und interne DLLs. Suchen Sie anschließend nach veralteten Mustern wie WebForms-Seiten oder Forms Authentication. Prüfen Sie die Codequalität und finden Sie stark gekoppelte Teile oder veraltete APIs. Entscheiden Sie dann, ob Sie Teile Ihrer Anwendung neu schreiben oder alte Bibliotheken ersetzen möchten. Wechseln Sie zu modernen ASP.NET-Technologien wie Razor Pages oder ASP.NET Core MVC. Übernehmen Sie neue Praktiken wie Dependency Injection, automatisierte Tests und CI/CD-Pipelines. Nutzen Sie Werkzeuge wie den .NET Upgrade Assistant, um den Prozess zu unterstützen.

Die Modernisierung von Legacy-Anwendungen kann Zeit und Ressourcen beanspruchen. Für eine einzelne Geschäftsanwendung mit 50.000 bis 100.000 Codezeilen müssen Sie vermutlich vier bis sechs Monate einplanen. Die Kosten liegen oft zwischen 100.000 und 1 Mio. US-Dollar, mit einem Median von etwa 180.000 US-Dollar. Wenn Sie ein Portfolio mit vielen Legacy-Anwendungen verwalten, kann der Prozess zwei bis drei Jahre dauern, aufgeteilt in kleinere Projekte. Mit der Modernisierung Ihrer Legacy-Systeme verbessern Sie Leistung, Sicherheit und Wartbarkeit.

WPF-Desktopanwendungen modernisieren

WPF in der Unternehmensentwicklung

Mit WPF können Sie Desktopanwendungen schnell entwickeln. Visual Studio stellt Ihnen Werkzeuge zur Verfügung, mit denen Sie Oberflächen und Code einfach gestalten können. Viele Organisationen entscheiden sich für WPF, weil die Bereitstellung vereinfacht wird. Sie können Anwendungen über freigegebene Laufwerke oder mit ClickOnce-Installationsprogrammen verteilen. Das macht WPF zu einer beliebten Wahl für interne Werkzeuge und schnelles Prototyping.

WPF spielt seine Stärken aus, wenn Sie hohe Grafikleistung und Reaktionsfähigkeit benötigen. Mit WPF bewältigen Sie große Datenmengen oder komplexe Visualisierungen. Damit ist es eine starke Alternative zu webbasierten Technologien.

Microsoft entwickelt WPF weiter. Neue Funktionen wie Hardwarebeschleunigung und das Fluent-Design für moderne Benutzeroberflächen kommen hinzu. WPF eignet sich für geschäftskritische Line-of-Business-Anwendungen in vielen Branchen. Weltweit gibt es laut rund 500.000 bis 1.000.000 aktiv entwickelten Anwendungen auf WPF-Basis. Mit WPF entwickeln und installieren Sie Anwendungen schnell und benötigen weniger Vorbereitung als andere Technologie-Stacks.

Migrationsstrategien

Häufig müssen Sie ältere Windows Presentation Foundation-Anwendungen modernisieren. Sie möchten WPF-Desktopanwendungen modernisieren, um neue .NET-Funktionen zu nutzen.

Migration auf .NET Core/5+/6+/8+

Sie beginnen damit, Ihre Projekte zu sichern. Sie installieren den .NET Upgrade Assistant. Sie klicken im Projektmappen-Explorer mit der rechten Maustaste auf Ihr Projekt und wählen Upgrade aus. Sie wählen zwischen einem In-Place- oder einem Side-by-Side-Upgrade. Sie wählen das Zielframework und die zu aktualisierenden Komponenten aus.

Sie richten Ihre Umgebung mit Visual Studio 2019 und .NET Core 3.0 ein. Sie prüfen die API-Kompatibilität mit dem .NET Portability Analyzer. Sie erstellen eine neue .csproj-Datei für Ihr Projekt. Sie legen den Assemblynamen und den Standardnamespace fest. Sie unterdrücken die automatische Generierung von AssemblyInfo.

Zu den Werkzeugen, die Sie für die Migration verwenden, gehören:

• .NET
• Visual Studio 2022 v17.0+
• DevExpress Project Converter
• .NET Portability Analyzer

Uno Platform für plattformübergreifende Anwendungen

Sie modernisieren WPF, indem Sie plattformübergreifende Lösungen prüfen. Mit der Uno Platform führen Sie WPF-ähnliche Apps unter Windows, Linux, macOS, iOS, Android und WebAssembly aus. Sie verwenden Ihre Geschäftslogik und UI-Komponenten weiter. Sie erreichen mehr Benutzer und Geräte mit weniger Aufwand. Die Uno Platform hilft Ihnen, Ihre Desktop-Anwendungen für ein größeres Publikum zu modernisieren.

Integration mit ASP.NET und gRPC

Sie modernisieren WPF-Desktopanwendungen, indem Sie sie mit Web- und Dienst-Technologien verbinden. Sie nutzen ASP.NET Core, um Web-APIs und Benutzeroberflächen zu erstellen. Sie verwenden gRPC für eine schnelle und zuverlässige Kommunikation zwischen Ihrer Desktop-App und den Backend-Diensten. Sie teilen die Geschäftslogik über WPF, ASP.NET und gRPC hinweg. Sie halten Ihre Daten synchron und verbessern die Leistung. Sie modernisieren Ihren Workflow, indem Sie WPF mit modernen Web- und Diensttechnologien integrieren.

ASP.NET Core MVC für Webanwendungen

Überblick über ASP.NET Core

Mit ASP.NET Core MVC erstellen Sie moderne Webanwendungen, die schnell, sicher und leicht zu warten sind. Dieses Framework bietet Ihnen eine einheitliche Methode, sowohl Weboberflächen als auch APIs zu erstellen. Sie können Ihre ASP.NET-Core-Anwendung unter Windows, Linux oder macOS ausführen. Die plattformübergreifende Natur von ASP.NET Core bedeutet, dass Sie Ihre Apps in vielen Umgebungen bereitstellen können, einschließlich der Cloud.

Die folgende Tabelle zeigt die Kernfunktionen, die ASP.NET Core MVC zu einer starken Wahl für die Webentwicklung machen:

Der Einstieg in ASP.NET Core beginnt mit der Installation des .NET SDK und der Einrichtung Ihres ersten Projekts. Der Einrichtungsprozess für ASP.NET Core ist einfach und gut dokumentiert. Sie können Visual Studio oder die Befehlszeile verwenden, um Ihr ASP.NET-Core-MVC-Projekt zu erstellen.

APIs erstellen

Mit ASP.NET Core MVC erstellen Sie APIs, die Ihre Webanwendungen, mobilen Apps und Desktop-Clients miteinander verbinden. Das Framework unterstützt RESTful-Design, was Ihnen hilft, Ihre Endpunkte und Datenmodelle zu strukturieren. Sie können Controller verwenden, um Anfragen zu verarbeiten und Daten im JSON-Format zurückzugeben. So können andere Anwendungen Ihre API problemlos nutzen.

Für skalierbare und wartbare APIs sollten Sie diese bewährten Verfahren befolgen:

• Strukturieren Sie Ihr Projekt nach der Clean Architecture. Organisieren Sie Ihren Code mit Controllern, Services, Repositories und Models bzw. DTOs.
• Verwenden Sie Async und Await für E/A-Vorgänge. Das verbessert die Leistung und ermöglicht es Ihrer App, mehr Benutzer gleichzeitig zu bedienen.
• Ergänzen Sie eine globale Ausnahmebehandlung mit Middleware. Das hilft Ihnen, Fehler an einer zentralen Stelle zu verwalten.
• Aktivieren Sie die API-Versionierung. Dadurch bleiben Ihre APIs mit unterschiedlichen Clients kompatibel.
• Verwenden Sie Logging, um Fehler und wichtige Aktionen nachzuverfolgen.

Sie können Ihre ASP.NET-Core-MVC-APIs mit anderen Diensten verbinden, etwa gRPC oder WPF-Clients. So entstehen leistungsstarke Lösungen, die plattformübergreifend funktionieren.

Sicherheit und Authentifizierung

Sie schützen Ihre ASP.NET Core-Anwendung, indem Sie die integrierten Sicherheitsfunktionen nutzen. Das Framework schützt vor gängigen Bedrohungen wie CSRF, XSS und SQL-Injection. Sie können Authentifizierung und Autorisierung hinzufügen, um zu steuern, wer auf Ihre APIs zugreifen darf. Viele Entwickler verwenden JWT-Tokens, um Endpunkte abzusichern und sensible Daten zu schützen.

Halten Sie Ihre ASP.NET Core-Anwendung stets auf dem neuesten Stand. Regelmäßige Updates helfen Ihnen, Sicherheitslücken zu schließen und die Leistung zu verbessern. Außerdem können Sie Middleware verwenden, um Authentifizierung und Autorisierung in Ihrer gesamten App zu verwalten.

Tipp: Sichern Sie Ihre APIs mit einer starken Authentifizierung und halten Sie Ihre Abhängigkeiten aktuell. So entwickeln Sie sichere und zuverlässige Webanwendungen.

Bereitstellungsoptionen

Es gibt viele Möglichkeiten, Ihre ASP.NET Core MVC-Anwendungen bereitzustellen. Jede Option bietet andere Vorteile. Wählen Sie die Option, die zu den Anforderungen Ihres Projekts und den Fähigkeiten Ihres Teams passt.

1. Bereitstellung vor Ort (On-Premises)

Sie können Ihre App auf eigenen Servern bereitstellen. Diese Methode gibt Ihnen die volle Kontrolle über Ihre Umgebung. Unter Windows installieren Sie IIS (Internet Information Services). Unter Linux verwenden Sie Kestrel mit einem Reverse Proxy wie Nginx oder Apache. Updates, Sicherheit und Skalierung verwalten Sie selbst.

Tipp: Verwenden Sie Kestrel für hohe Leistung. Kombinieren Sie es mit Nginx oder Apache, um HTTPS und Lastverteilung zu übernehmen.

2. Cloud-Bereitstellung

Sie können Ihre App in die Cloud bereitstellen. Beliebte Optionen sind Microsoft Azure, Amazon Web Services (AWS) und Google Cloud Platform (GCP). Cloud-Plattformen bieten einfache Skalierung, hohe Verfügbarkeit und verwaltete Dienste.

Mit Azure App Service stellen Sie Ihre App mit wenigen Klicks bereit. Sie laden Ihren Code hoch, und Azure übernimmt den Rest. Für automatisierte Bereitstellungen können Sie außerdem Azure DevOps verwenden.

3. Containerisierung mit Docker

Sie können Ihre App in einem Docker-Container verpacken. Diese Methode macht Ihre App portabel und lässt sie sich überall einfach bereitstellen. Mit einer einfachen Dockerfile definieren Sie die Umgebung Ihrer App.

FROM mcr.microsoft.com/dotnet/aspnet:8.0
COPY . /app
WORKDIR /app
ENTRYPOINT ["dotnet", "YourApp.dll"]

Sie erstellen und starten den Container lokal und übertragen ihn anschließend in eine Container-Registry. Container lassen sich auf Kubernetes oder in Cloud-Diensten wie Azure Kubernetes Service (AKS) bereitstellen.

4. Continuous Integration und Continuous Deployment (CI/CD)

Sie können den Bereitstellungsprozess mit CI/CD-Pipelines automatisieren. Werkzeuge wie GitHub Actions, Azure DevOps und GitLab CI helfen Ihnen, Ihre App automatisch zu erstellen, zu testen und bereitzustellen.

Hinweis: CI/CD reduziert Fehler und beschleunigt Ihren Release-Zyklus. Sollte etwas schiefgehen, können Sie Änderungen schnell zurücksetzen.

5. Plattformübergreifendes Hosting

Sie können ASP.NET Core MVC-Anwendungen unter Windows, Linux oder macOS hosten. Diese Flexibilität erlaubt es Ihnen, die beste Umgebung für Ihre Anforderungen zu wählen.

Übersicht: Bereitstellungsoptionen

Prüfen Sie Ihre Anforderungen, bevor Sie eine Bereitstellungsmethode wählen. Jede Option hat Stärken. Sie können sie auch kombinieren, um noch bessere Ergebnisse zu erzielen. Beispielsweise können Sie Container in der Cloud mit CI/CD-Pipelines verwenden, um schnelle und zuverlässige Bereitstellungen zu erreichen.

gRPC in .NET

Was ist gRPC

Mit gRPC entwickeln Sie schnelle und zuverlässige Kommunikation zwischen Ihren Anwendungen. gRPC steht für Google Remote Procedure Call. Es handelt sich um ein Open-Source-Framework, mit dem Sie Methoden auf einem Server von einem Client aus aufrufen können, als wären sie lokal. Sie können gRPC für Remote-Procedure-Call-Szenarien mit hoher Leistung einsetzen. Das bedeutet, Daten werden schnell gesendet und empfangen, auch wenn Ihre Apps auf unterschiedlichen Rechnern laufen.

gRPC verwendet Protocol Buffers, eine sprach- und plattformneutrale Methode zur Serialisierung von Daten. Sie definieren Ihre Dienstverträge in einer .proto-Datei. Diese Datei beschreibt die Nachrichten und Dienste, die Sie verwenden möchten. Aus dieser Datei generieren Sie den Code für Client und Server. Sie können gRPC in vielen Anwendungstypen einsetzen, darunter WPF-Desktop-Apps, ASP.NET-Webanwendungen und Cloud-Dienste.

gRPC vs. REST

Sie fragen sich vielleicht, wie sich gRPC von REST unterscheidet. REST nutzt HTTP und JSON, um Daten zwischen Clients und Servern zu übertragen. gRPC setzt auf HTTP/2 und Protocol Buffers. Dadurch erzielen Sie eine bessere Leistung, denn HTTP/2 unterstützt Multiplexing und Streaming. Protocol Buffers erzeugen kleinere Nachrichten als JSON, sodass sich Ihre Daten schneller übertragen lassen.

Die folgende Tabelle hilft Ihnen beim Vergleich von gRPC und REST:

Sie wählen gRPC, wenn Sie hoch skalierbare Systeme oder Echtzeitkommunikation benötigen. REST verwenden Sie, wenn Sie einfache APIs wünschen, die mit Browsern funktionieren. Viele Entwickler nutzen beide Technologien in derselben Lösung.

gRPC-Dienste einrichten

Die Einrichtung von gRPC-Diensten in .NET erfordert nur wenige Schritte. Zuerst erstellen Sie ein neues Projekt in Visual Studio oder mit der .NET CLI. Dabei wählen Sie die Vorlage „gRPC Service“ aus. Diese Vorlage stellt Ihnen eine Beispieldatei .proto und den Code zum Starten Ihres Dienstes bereit.

Sie definieren Ihren Dienst und Ihre Nachrichten in der Datei .proto. Zum Beispiel:

syntax = "proto3";

service Greeter {
  rpc SayHello (HelloRequest) returns (HelloReply);
}

message HelloRequest {
  string name = 1;
}

message HelloReply {
  string message = 1;
}

Sie erstellen Ihr Projekt. Die Tools generieren C#-Klassen für Ihren gRPC-Client und -Server. Die Dienstlogik implementieren Sie in C#. Für anspruchsvolle Szenarien können Sie gRPC-Dienste in ASP.NET Core hosten oder sogar in einer WPF-App.

Zum Testen Ihrer gRPC-Dienste verwenden Sie Werkzeuge wie grpc-dotnet, Grpc.Net.Client und Grpc.AspNetCore.Server. Diese Bibliotheken helfen Ihnen beim Erstellen, Hosten und Nutzen von gRPC-Diensten in .NET. Zum Testen Ihrer gRPC-Endpunkte können Sie außerdem FINT einsetzen.

Sie verbinden Ihren WPF-Client oder Ihre ASP.NET-App mit Ihren gRPC-Diensten, indem Sie den generierten Clientcode hinzufügen. So kommunizieren Ihre Anwendungen schnell und sicher miteinander. Wenn Sie ältere Technologien wie WCF nutzen, können Sie zu gRPC migrieren und erhalten eine moderne, skalierbare Lösung.

Tipp: Verwenden Sie gRPC, wenn Sie schnelle, zuverlässige und hoch skalierbare Kommunikation zwischen Ihren .NET-Anwendungen benötigen.

gRPC in WPF und ASP.NET nutzen

Sie können Ihre WPF- und ASP.NET-Core-Anwendungen mit gRPC-Diensten verbinden. So teilen Sie Daten und Geschäftslogik zwischen Desktop- und Web-Apps. Sie erhalten schnelle, zuverlässige Kommunikation, die sich gut für moderne Lösungen eignet.

Integration des WPF-Clients

Sie können gRPC zu Ihrer WPF-Desktop-App hinzufügen. Installieren Sie zuerst das NuGet-Paket Grpc.Net.Client. Dieses Paket stellt die Werkzeuge bereit, mit denen Sie gRPC-Dienste aus Ihrem WPF-Projekt aufrufen.

So richten Sie einen gRPC-Client in WPF ein:

1. Fügen Sie die .proto-Datei hinzu
   Legen Sie die .proto-Datei aus Ihrem gRPC-Dienst in Ihr WPF-Projekt. Setzen Sie die Buildaktion in der Projektdatei auf „Protobuf“.

2. Installieren Sie die NuGet-Pakete
   Öffnen Sie den NuGet-Paket-Manager. Installieren Sie Grpc.Net.Client und Google.Protobuf.

3. Konfigurieren Sie den gRPC-Client
   Erstellen Sie in Ihrem Code einen Kanal und einen Client. Zum Beispiel:

   using Grpc.Net.Client;
   using Greet;
   
   var channel = GrpcChannel.ForAddress("https://localhost:5001");
   var client = new Greeter.GreeterClient(channel);
   var reply = await client.SayHelloAsync(new HelloRequest { Name = "WPF User" });
   MessageBox.Show(reply.Message);

4. Behandeln Sie Threading
   Verwenden Sie async und await, damit Ihre Benutzeroberfläche reaktionsfähig bleibt. Blockieren Sie den Hauptthread nicht.

Tipp: Sie können Datenmodelle zwischen Ihren WPF- und ASP.NET-Core-Projekten über gemeinsame Bibliotheken teilen. So bleibt Ihr Code sauber und konsistent.

Integration des ASP.NET-Clients

Sie können gRPC-Clients auch in Ihren ASP.NET-Core-Anwendungen verwenden. Das ist nützlich, wenn Ihre Web-App andere Dienste aufrufen muss, etwa Microservices oder Backend-APIs.

So richten Sie einen gRPC-Client in ASP.NET Core ein:

1. Fügen Sie die .proto-Datei hinzu
   Nehmen Sie die .proto-Datei in Ihr ASP.NET-Core-Projekt auf. Setzen Sie die Buildaktion auf „Protobuf“.

2. Installieren Sie die NuGet-Pakete
   Fügen Sie Grpc.Net.ClientFactory und Google.Protobuf über NuGet hinzu.

3. Registrieren Sie den gRPC-Client
   Registrieren Sie den Client in Ihrer Startup.cs oder Program.cs per Dependency Injection:

   builder.Services.AddGrpcClient<Greeter.GreeterClient>(o =>
   {
       o.Address = new Uri("https://localhost:5001");
   });

4. Injizieren und verwenden Sie den Client
   Injizieren Sie den Client in Ihren Controller oder Ihren Dienst:

   public class HomeController : Controller
   {
       private readonly Greeter.GreeterClient _greeterClient;
   
       public HomeController(Greeter.GreeterClient greeterClient)
       {
           _greeterClient = greeterClient;
       }
   
       public async Task<IActionResult> Index()
       {
           var reply = await _greeterClient.SayHelloAsync(new HelloRequest { Name = "Web User" });
           ViewBag.Message = reply.Message;
           return View();
       }
   }

Hinweis: Sie können gRPC-Clients in Hintergrunddiensten, Controllern oder an beliebiger Stelle in Ihrer ASP.NET-Core-Anwendung verwenden.

Sie können Ihre WPF- und ASP.NET-Core-Apps nun mit demselben gRPC-Backend verbinden. So erhalten Sie eine einheitliche und hochperformante Lösung für Ihre geschäftlichen Anforderungen.

Praktische Schritt-für-Schritt-Anleitung zur Integration

Lösungsarchitektur

Sie können eine moderne Lösung aufbauen, indem Sie WPF, ASP.NET Core MVC und gRPC miteinander verbinden. Diese Architektur sorgt für ein durchgängiges Erlebnis auf Desktop und Web. Sie beginnen mit einer WPF-Desktopanwendung. Für Ihre Weboberfläche ergänzen Sie ASP.NET Core MVC. Mit gRPC binden Sie beide Clients an Ihre Backend-Dienste an.

Das folgende Diagramm hilft Ihnen, den Aufbau zu verstehen:

Sie können diesen Aufbau für viele Szenarien nutzen. Beispielsweise können Sie eine bestehende WPF-App modernisieren, indem Sie ASP.NET Core MVC und gRPC ergänzen. Ebenso lassen sich neue Lösungen entwickeln, die sowohl Desktop- als auch Web-Clients benötigen. Diese Architektur eignet sich gut für Microservices, da gRPC eine hochperformante Kommunikation unterstützt.

Tipp: Mit Shared Libraries können Sie die Geschäftslogik zwischen WPF, ASP.NET Core MVC und ASP.NET Core teilen. So bleibt Ihr Code übersichtlich und Redundanzen werden vermieden.

gRPC-Dienst in ASP.NET Core erstellen

Sie können in ASP.NET Core einen einfachen gRPC-Dienst erstellen. Dieser Dienst ermöglicht Ihren WPF- und ASP.NET Core MVC-Clients die Kommunikation mit dem Backend. Sie beginnen, indem Sie Visual Studio öffnen und ein neues Projekt anlegen. Wählen Sie die Vorlage „gRPC-Dienst“. Diese Vorlage stellt alles bereit, was Sie für den Einstieg benötigen.

Gehen Sie wie folgt vor:

1. Öffnen Sie Visual Studio und wählen Sie „Neues Projekt erstellen“.
2. Wählen Sie „gRPC-Dienst“ und klicken Sie auf „Weiter“.
3. Geben Sie Ihrem Projekt einen Namen und wählen Sie ASP.NET Core 8.0 oder höher.
4. Klicken Sie auf „Erstellen“.

In Ihrem Projekt finden Sie einen Beispieldienst „Greeter“. Der Dienst verwendet eine .proto-Datei, um den Vertrag zu definieren. Sie können diese Datei bearbeiten, um eigene Methoden und Nachrichten hinzuzufügen.

Hier ist ein Beispiel für eine .proto-Datei:

syntax = "proto3";

service Greeter {
  rpc SayHello (HelloRequest) returns (HelloReply);
}

message HelloRequest {
  string name = 1;
}

message HelloReply {
  string message = 1;
}

Den Dienst implementieren Sie in C#. Die Vorlage stellt die Datei GreeterService.cs bereit. Dort können Sie Ihre Logik ergänzen.

public class GreeterService : Greeter.GreeterBase
{
    public override Task<HelloReply> SayHello(HelloRequest request, ServerCallContext context)
    {
        return Task.FromResult(new HelloReply
        {
            Message = $"Hello, {request.Name}"
        });
    }
}

Starten Sie Ihr ASP.NET Core-Projekt. Der gRPC-Dienst wartet nun auf Anfragen Ihrer Clients. Sie können Ihre WPF- und ASP.NET Core MVC-Anwendungen jetzt mit diesem Dienst verbinden.

Hinweis: gRPC verwendet HTTP/2. Stellen Sie daher sicher, dass Ihr Server dieses Protokoll unterstützt. Bei Verwendung der Vorlage übernimmt Visual Studio diese Einrichtung für Sie.

gRPC in WPF nutzen

Sie können Ihre WPF-Anwendung mit Ihrem gRPC-Dienst verbinden. So nutzt Ihre Desktop-App dasselbe Backend wie Ihre Web-App. Beginnen Sie, indem Sie die .proto-Datei zu Ihrem WPF-Projekt hinzufügen. Setzen Sie die Buildaktion auf „Protobuf“.

Gehen Sie wie folgt vor, um den Client einzurichten:

1. Installieren Sie die NuGet-Pakete Grpc.Net.Client und Google.Protobuf.
2. Fügen Sie die .proto-Datei Ihrem Projekt hinzu.
3. Erstellen Sie in Ihrem Code einen gRPC-Kanal.

Hier ist ein Beispielcodeausschnitt:

using Grpc.Net.Client;
using Greet;

var channel = GrpcChannel.ForAddress("https://localhost:5001");
var client = new Greeter.GreeterClient(channel);
var reply = await client.SayHelloAsync(new HelloRequest { Name = "WPF User" });
MessageBox.Show(reply.Message);

Mit async und await bleibt Ihre WPF-App reaktionsschnell. Sie können gRPC-Methoden aus Ihren ViewModels oder Diensten aufrufen. Dieser Ansatz ermöglicht es, Daten und Logik zwischen Ihren WPF- und ASP.NET Core MVC-Clients zu teilen.

Tipp: Legen Sie Ihre Datenmodelle in einer Shared Library ab, um beide Projekte synchron zu halten.

Jetzt haben Sie eine Lösung, in der WPF und ASP.NET Core MVC beide über gRPC mit dem Backend kommunizieren. Dieser Aufbau bietet Ihnen Geschwindigkeit, Zuverlässigkeit und eine moderne Architektur.

Datenverträge und Protobuf

In gRPC definieren Sie Datenverträge mit Protocol Buffers, kurz Protobuf. Mit Protobuf beschreiben Sie den Aufbau Ihrer Nachrichten in einer .proto-Datei. Diese Datei fungiert als Vertrag zwischen Client und Server. Daraus generieren Sie C#-Klassen, die beide Seiten verstehen.

Wenn Sie eine .proto-Datei zu Ihrem .NET-Projekt hinzufügen, müssen Sie sie korrekt konfigurieren. Die folgende Tabelle zeigt die wichtigsten Einstellungen, die Sie verwenden:

Halten Sie Ihre .proto-Dateien einfach und übersichtlich. Verwenden Sie eindeutige Namen für Nachrichten und Felder. Vermeiden Sie reservierte Wörter und Sonderzeichen. Wenn Sie Ihre Verträge später aktualisieren möchten, sollten Sie Versionsnummern in Nachrichtennamen oder Paketnamen verwenden.

Hier sind einige Best Practices für die Arbeit mit Protobuf in .NET:

• Legen Sie Ihre .proto-Dateien in einem gemeinsamen Ordner oder einer gemeinsamen Bibliothek ab. So stellen Sie sicher, dass Ihre Verträge über WPF, ASP.NET Core und andere Projekte hinweg synchron bleiben.
• Verwenden Sie die Option Both für GrpcServices, wenn Sie aus derselben .proto-Datei sowohl Client- als auch Servercode generieren möchten.
• Halten Sie Ihre Datentypen einfach. Verwenden Sie für die meisten Felder grundlegende Typen wie string, int32 oder bool.
• Versehen Sie Ihre .proto-Dateien mit Kommentaren. Kommentare helfen anderen Entwicklern, Ihre Verträge zu verstehen.

Tipp: Wenn Sie eine .proto-Datei aktualisieren, generieren Sie den C#-Code in allen Projekten neu, die diese Datei verwenden. So bleiben Client und Server synchron.

Fehlerbehandlung und Protokollierung

Sie benötigen eine robuste Fehlerbehandlung und Protokollierung, damit Ihre .NET-Anwendungen zuverlässig laufen. Wenn Sie WPF, ASP.NET Core und gRPC gemeinsam einsetzen, sollten Sie einige zentrale Strategien befolgen:

• Richten Sie globale Ausnahmebehandlungen sowohl in ASP.NET Core als auch in WPF ein. So erkennen Sie Fehler, die sonst unbemerkt bleiben würden.
• Nutzen Sie eine zentrale Protokollierung. Das erleichtert die Nachverfolgung von Problemen und die Wartung Ihres Codes.
• Verwenden Sie in ASP.NET Core die Schnittstelle IExceptionHandler, um Ausnahmen in der gesamten Anwendung zu behandeln.
• Erstellen Sie in WPF eine globale Ausnahmebehandlung, die nicht behandelte Fehler abfängt und protokolliert.
• Protokollieren Sie wichtige Ereignisse, Fehler und Warnungen immer. Nutzen Sie dafür Werkzeuge wie Serilog, NLog oder die integrierten Logging-Anbieter.
• Achten Sie darauf, dass Ihre Protokolle genügend Details enthalten, um Probleme schnell zu finden und zu beheben.

Hinweis: Eine gute Fehlerbehandlung und Protokollierung hilft Ihnen, Probleme frühzeitig zu erkennen. Außerdem machen sie Ihre Anwendungen leichter zu betreuen und im Laufe der Zeit zu verbessern.

Authentifizierung und Sicherheit

Absicherung von gRPC-Diensten

Sie sollten Ihre gRPC-Dienste absichern, um Ihre Daten und Benutzer zu schützen. Beginnen Sie damit, für die gesamte gRPC-Kommunikation HTTPS zu verwenden. Dieser Schritt verschlüsselt die Daten zwischen Client und Server. Außerdem sollten Sie Authentifizierung und Autorisierung einsetzen, um den Zugriff zu steuern. Wenn Sie beides einrichten, legen Sie fest, wer Ihre gRPC-Methoden aufrufen darf und welche Aktionen dabei erlaubt sind. Zur Überprüfung der Identität jedes Clients können Sie Zertifikate oder Token verwenden. Viele Entwickler nutzen dafür JWT-Token. Validieren Sie diese Token immer auf dem Server, bevor Sie eine Anfrage verarbeiten.

Tipp: Verwenden Sie die rollenbasierte Autorisierung, um den Zugriff auf sensible gRPC-Methoden einzuschränken. Weisen Sie Benutzern Rollen zu und prüfen Sie deren Berechtigungen, bevor Sie Aktionen zulassen.

Authentifizierung in WPF und ASP.NET

Sie müssen Authentifizierung und Autorisierung sowohl in Ihren WPF- als auch in Ihren ASP.NET-Anwendungen implementieren. In ASP.NET können Sie integrierte Middleware für Authentifizierung und Autorisierung verwenden. Diese Middleware prüft die Anmeldeinformationen des Benutzers und setzt die Autorisierungsregeln für jede Anfrage durch. Sie können die Authentifizierungs- und Autorisierungsfunktion hinzufügen, indem Sie die Dienste in Ihrer Startup- oder Program-Datei konfigurieren. Bei WPF verbinden Sie sich für Authentifizierung und Autorisierung häufig mit einem Backend-Dienst. Der WPF-Client sendet die Anmeldeinformationen des Benutzers an den Server, der bei gültigen Daten ein Token zurückgibt. Der Client verwendet dieses Token anschließend für weitere Anfragen. Speichern Sie Token auf der Clientseite immer sicher.

Die folgende Tabelle zeigt gängige Methoden zur Authentifizierung und Autorisierung:

Hinweis: Verwenden Sie in WPF-Apps immer einen sicheren Speicher für Token. Speichern Sie niemals sensible Daten im Klartext.

Token-Verwaltung

Sie müssen Tokens sorgfältig verwalten, damit Ihre Anwendungen sicher bleiben. Wenn Sie Authentifizierung und Autorisierung verwenden, stellt Ihr Server nach einer erfolgreichen Anmeldung ein Token aus. Der Client speichert dieses Token und sendet es mit jeder Anfrage. Sie sollten Ablaufzeiten für Tokens festlegen, um das Risiko zu verringern. Läuft ein Token ab, muss der Client ein neues anfordern. In ASP.NET können Sie Lebensdauer und Aktualisierungslogik von Tokens konfigurieren. Bei gRPC sollten Sie das Token immer prüfen, bevor Sie eine Anfrage verarbeiten. Fehlt das Token oder ist es ungültig, verweigern Sie den Zugriff anhand Ihrer Autorisierungsregeln.

Sie sollten Tokens außerdem widerrufen, wenn sich ein Benutzer abmeldet oder Sie verdächtige Aktivitäten erkennen. Dieser Schritt verhindert unbefugten Zugriff. Überprüfen Sie Ihre Authentifizierungs- und Autorisierungskonfiguration regelmäßig, damit sie Ihren Sicherheitsanforderungen entspricht.

Tipp: Automatisieren Sie die Erneuerung von Tokens in Ihren Clients, damit Sitzungen ohne Unterbrechung für den Benutzer aktiv bleiben.

Bereitstellung und Wartung

Mehrschichtige Bereitstellung

Sie können Ihre .NET-Lösung mit einer mehrschichtigen Bereitstellung organisieren. Dieser Ansatz trennt Ihre Anwendung in Schichten. Jede Schicht hat eine klar definierte Aufgabe. Beispielsweise können Sie eine Präsentationsschicht für WPF oder ASP.NET Core MVC, eine Dienstschicht für die gRPC-Kommunikation und eine Datenschicht für Ihre Datenbank haben. Diese Struktur hilft Ihnen, Ihren Code zu verwalten und Ihre Lösung zu skalieren.

Ein typischer mehrschichtiger Aufbau sieht so aus:

Sie stellen jede Schicht auf unterschiedlichen Servern oder in separaten Containern bereit. Diese Trennung verbessert Sicherheit und Leistung. Sie können eine Schicht aktualisieren, ohne die anderen zu beeinflussen.

Tipp: Verwenden Sie gRPC in Ihrer Dienstschicht, um Präsentations- und Datenschicht schnell und zuverlässig zu verbinden.

CI/CD-Pipelines

Sie können Ihren Build- und Bereitstellungsprozess automatisieren mit CI/CD-Pipelines. CI steht für Continuous Integration, CD für Continuous Deployment. Diese Pipelines helfen Ihnen, Updates schneller und mit weniger Fehlern auszuliefern.

Die wichtigsten Schritte einer CI/CD-Pipeline sind:

1. Sie übertragen Ihren Code in ein Quellcodeverwaltungssystem wie GitHub oder Azure DevOps.
2. Die Pipeline erstellt Ihre Anwendung und führt Tests aus.
3. Wenn die Tests erfolgreich sind, stellt die Pipeline Ihre App in einer Test- oder Produktionsumgebung bereit.

Sie können Tools wie GitHub Actions, Azure Pipelines oder GitLab CI verwenden. Diese Tools unterstützen .NET-, ASP.NET Core- und gRPC-Projekte. Sie können automatische Bereitstellungen für Ihre WPF-, Web- und gRPC-Dienste einrichten.

Hinweis: CI/CD-Pipelines helfen Ihnen, Probleme früh zu erkennen. Sie können Änderungen zurücksetzen, wenn etwas schiefgeht.

Überwachung und Updates

Sie müssen Ihre Anwendungen überwachen, um ihren Zustand zu erhalten. Überwachungstools erfassen Fehler, Leistung und Nutzung. Sie können Application Insights, Prometheus oder Grafana verwenden. Diese Tools arbeiten mit .NET-, ASP.NET Core- und gRPC-Diensten.

Sie sollten Warnmeldungen für wichtige Ereignisse einrichten. Beispielsweise können Sie eine Benachrichtigung erhalten, wenn Ihr gRPC-Dienst ausfällt oder Ihre Web-App langsamer wird. Regelmäßige Updates halten Ihr System sicher und schnell. Sie sollten Ihre Server patchen, Ihre Bibliotheken aktualisieren und Ihre Protokolle häufig überprüfen.

Eine einfache Checkliste für die Wartung:

• Überwachen Sie alle Dienste, einschließlich der gRPC-Endpunkte.
• Richten Sie Warnmeldungen für Fehler und Verlangsamungen ein.
• Aktualisieren Sie Ihre .NET-Laufzeit und Ihre Bibliotheken.
• Prüfen Sie Protokolle und beheben Sie Probleme zügig.

Tipp: Planen Sie regelmäßige Wartungsfenster ein. So können Sie Updates einspielen, ohne Benutzer zu stören.

Best Practices und nächste Schritte

Entwurfsmuster

Sie verbessern Ihre .NET-Projekte, indem Sie bewährte Entwurfsmuster einsetzen. Diese Muster helfen Ihnen, Code zu schreiben, der leicht verständlich, testbar und wartbar ist. In der modernen .NET-Entwicklung verwenden Sie häufig Muster wie Dependency Injection, Repository und MVVM (Model-View-ViewModel).

• Dependency Injection ermöglicht es Ihnen, Abhängigkeiten zwischen Klassen zu verwalten. Sie registrieren Dienste in Ihrem Startcode und injizieren sie dort, wo sie benötigt werden. Dieses Muster macht Ihren Code flexibel und testbar.
• Repository Pattern trennt Ihre Datenzugriffslogik von der Geschäftslogik. Sie erstellen Repository-Klassen, die Datenbankoperationen übernehmen. Dadurch bleibt Ihr Code organisiert.
• MVVM eignet sich gut für WPF-Anwendungen. Sie trennen Benutzeroberfläche, Geschäftslogik und Datenmodelle. Dieses Muster hilft Ihnen, reaktionsschnelle und wartbare Desktop-Apps zu erstellen.

Tipp: Der Podcast Modern .NET Development auf m365.fm zeigt häufig, wie diese Muster Ihnen helfen, Ihre Lösungen zu skalieren und sich auf künftige Änderungen vorzubereiten.

Teststrategien

Für zuverlässige Software brauchen Sie durchdachte Teststrategien. Tests helfen Ihnen, Fehler frühzeitig zu erkennen, und stellen sicher, dass Ihr Code wie erwartet funktioniert. In .NET setzen Sie verschiedene Testarten ein:

Schreiben Sie Unit-Tests für Ihre Geschäftslogik. Mit Integrationstests prüfen Sie, wie Ihre Dienste und Datenbanken zusammenarbeiten. Für WPF- und Web-Apps ergänzen Sie UI-Tests, damit die Benutzererfahrung reibungslos bleibt.

• Verwenden Sie testgetriebene Entwicklung (TDD), um Tests vor dem Code zu schreiben.
• Automatisieren Sie Ihre Tests in CI/CD-Pipelines, damit Sie schnell Rückmeldung erhalten.
• Simulieren Sie Abhängigkeiten (Mocking), um Ihre Tests zu isolieren.

Hinweis: Automatisierte Tests sparen Zeit und reduzieren Fehler bei Aktualisierungen.

Dokumentation und Zusammenarbeit

Sie halten Ihre Projekte gesund, indem Sie klar dokumentieren und gut im Team zusammenarbeiten. Gute Dokumentation hilft neuen Entwicklern, Ihren Code zu verstehen. Außerdem erleichtert sie die Wartung und Erweiterung Ihrer Anwendungen.

• Schreiben Sie README-Dateien, die den Zweck Ihres Projekts und die Einrichtungsschritte erklären.
• Verwenden Sie XML-Kommentare in Ihrem Code, um Klassen und Methoden zu beschreiben.
• Erstellen Sie API-Dokumentation mit Werkzeugen wie Swagger für ASP.NET Core.

Sie arbeiten besser zusammen, wenn Sie Versionsverwaltungssysteme wie Git einsetzen. Sie verfolgen Änderungen, prüfen Code und lösen Konflikte gemeinsam im Team. Kommunikationsfähigkeiten sind ebenso wichtig wie technisches Können. Der Podcast Modern .NET Development spricht oft darüber, wie eine starke Kommunikation und klare Dokumentation Teams zum Erfolg verhelfen, besonders da KI-Werkzeuge in der Entwicklung immer üblicher werden.

Tipp: Planen Sie regelmäßige Code-Reviews ein und teilen Sie Wissen mit Ihrem Team. So entsteht besserer Code und ein stärkeres Team.

Lernressourcen

Sie können Ihre .NET-Kenntnisse mit einer Vielzahl von Lernressourcen ausbauen. Das .NET-Ökosystem entwickelt sich schnell weiter, daher sollten Sie über die neuesten Werkzeuge, Frameworks und Best Practices auf dem Laufenden bleiben. Hier sind einige der besten Ressourcen, mit denen Sie Ihr Wissen aktuell und praxisnah halten.

📚 Empfohlene Podcasts und Sendungen

• Modern .NET Development Podcast (m365.fm)
  Hören Sie zu, wie Mirko Peters und der Microsoft MVP Gábor Ruzsinszki praxisnahe .NET-Themen besprechen. Sie erhalten fundierte Ratschläge zu WPF, ASP.NET Core, gRPC und mehr. Der Podcast behandelt KI in der Entwicklung, Kommunikationsfähigkeiten und zukünftige .NET-Funktionen.

  Tipp: Abonnieren Sie den Modern .NET Development Podcast auf Ihrer bevorzugten Plattform, um regelmäßig informiert zu bleiben.

• .NET Rocks!
  In dieser Sendung kommen Branchenexperten zu Wort. Sie erfahren Neues zu Trends, Werkzeugen und Techniken in .NET.

📖 Offizielle Dokumentation und Anleitungen

• Microsoft Learn für .NET
  Hier finden Sie Schritt-für-Schritt-Anleitungen, Codebeispiele und interaktive Lektionen. Microsoft Learn hilft Ihnen, alles von WPF bis ASP.NET Core und gRPC zu beherrschen.

• ASP.NET Core-Dokumentation
  Sie erhalten detaillierte Anleitungen zur Entwicklung von Web-Apps, APIs und sicheren Lösungen.

• gRPC für .NET-Dokumentation
  Diese Ressource erklärt, wie Sie gRPC-Dienste in .NET einrichten, verwenden und testen.

🛠️ Community und interaktive Plattformen

• Stack Overflow
  Sie können Fragen stellen und Antworten von erfahrenen .NET-Entwicklern erhalten. Suchen Sie nach Lösungen oder teilen Sie Ihr eigenes Wissen.

• GitHub
  Entdecken Sie Open-Source-.NET-Projekte. Sie können Code lesen, zu Repositories beitragen und aus Praxisbeispielen lernen.

• Microsoft Q&A
  Dieses Forum ermöglicht Ihnen den Austausch mit Microsoft-Ingenieuren und der .NET-Community.

📅 Konferenzen und Online-Veranstaltungen

• .NET Conf
  Sie können Live-Sessions und Workshops verfolgen. Erfahren Sie mehr über die neuesten .NET-Versionen und Funktionen.

• Lokale Meetups
  Treten Sie lokalen .NET-Benutzergruppen in Ihrer Region bei. Lernen Sie andere Entwickler kennen, tauschen Sie Erfahrungen aus und arbeiten Sie gemeinsam an Projekten.

📝 Tabelle: Schnellübersicht zu Lernressourcen

Hinweis: Planen Sie jede Woche Zeit ein, um neue Ressourcen zu erkunden. Kontinuierliches Lernen hilft Ihnen, in der modernen .NET-Entwicklung vorne zu bleiben.

Sie können diese Ressourcen kombinieren, um eine solide Grundlage aufzubauen. Probieren Sie neue Werkzeuge aus, folgen Sie Expertenrat und werden Sie Teil der .NET-Community. So verbessern Sie Ihre Fähigkeiten und halten Ihre Projekte modern und effizient.

Sie haben gelernt, wie Sie WPF, ASP.NET und gRPC für die moderne .NET-Entwicklung miteinander verbinden. Sie haben praktische Schritte für Migration, Integration und Sicherheit kennengelernt. Mit gRPC schaffen Sie schnelle Kommunikation zwischen Desktop- und Web-Anwendungen. Sie verbessern Ihre Projekte, indem Sie Best Practices aus der Folge Modern .NET: WPF, ASP.NET Core, and gRPC with Gábor Ruzsinszki [MVP] anwenden. Probieren Sie gRPC in Ihrer nächsten Lösung aus. Weitere Expertentipps finden Sie auf m365.fm.

Werden Sie Teil der .NET-Community und experimentieren Sie mit Beispielprojekten, um Ihre Fähigkeiten auszubauen.

Häufige Fragen

Was ist der Hauptvorteil von WPF für Desktop-Anwendungen?

Mit WPF erstellen Sie leistungsstarke und reaktionsschnelle Benutzeroberflächen. Das Framework unterstützt erweiterte Grafiken und Datenbindung. So entwickeln Sie Desktop-Anwendungen für Unternehmen schnell und effizient.

Wie verbessert ASP.NET Core die Webentwicklung?

ASP.NET Core bietet plattformübergreifende Unterstützung und hohe Leistung. Mit dem Framework erstellen Sie sichere Web-Apps und APIs. Sie stellen Ihre Lösungen unter Windows, Linux oder macOS bereit.

Warum sollten Sie gRPC für die Dienstkommunikation verwenden?

Mit gRPC erreichen Sie eine schnelle und zuverlässige Kommunikation zwischen Diensten. Das Framework nutzt HTTP/2 und Protocol Buffers. So reduzieren Sie die Latenz und verbessern die Skalierbarkeit Ihrer Anwendungen.

Können Sie WPF und ASP.NET Core mit gRPC verbinden?

Sie integrieren WPF und ASP.NET Core mithilfe von gRPC. Das Framework ermöglicht es Ihren Desktop- und Web-Apps, Daten und Geschäftslogik gemeinsam zu nutzen. So entstehen einheitliche Lösungen für moderne Geschäftsanforderungen.

Welche Werkzeuge helfen bei der Migration älterer .NET-Anwendungen?

Für die Migration verwenden Sie den .NET Upgrade Assistant und Visual Studio. Diese Werkzeuge analysieren Ihren Code und führen Sie durch den Upgrade-Prozess. So modernisieren Sie Ihre Apps mit geringerem Aufwand.

Wie sichern Sie Ihre ASP.NET Core- und gRPC-Dienste ab?

Sie schützen Ihre Dienste, indem Sie HTTPS aktivieren und Authentifizierungstoken verwenden. Rollenbasierte Autorisierung steuert den Zugriff. So bleiben Ihre Daten geschützt und Ihre Benutzer sicher.

Wo finden Sie Expertenrat zur modernen .NET-Entwicklung?

Hören Sie sich den Modern .NET Development Podcast auf m365.fm an. Der Podcast bietet Praxisbeispiele und praktische Tipps. Sie lernen von Branchenexperten und bleiben über neue Technologien auf dem Laufenden.

🎧 Diese Folge anhören

Möchten Sie eine praxisnahe Erklärung zu Modern .NET? Diese Folge erläutert das Thema in verständlicher Sprache und zeigt, warum es für Microsoft 365, Azure, Power Platform, Sicherheit, KI und modernes Arbeiten wichtig ist.

Hören Sie sich diese Folge an, wenn Sie:

• die zentralen Konzepte hinter Modern .NET verstehen möchten
• sehen möchten, wie es in das breitere Microsoft-Technologie-Ökosystem passt
• erfahren möchten, wo es für Ihre Organisation praktischen Mehrwert schaffen kann

Diese verwandten M365.FM-Folgen könnten Sie ebenfalls interessieren:

• LINQ to SQL vs. EF Core für den .NET-Datenzugriff
• .NET-Erweiterbarkeit und Clean Architecture mit Miguel Castro [MVP]
• Modern Microsoft 365 Automation Beyond PowerShell Scripts
• Build AI Applications with .NET 10
• Improve Entity Framework Core Query Performance

Mehr praxisnahe Gespräche rund um Microsoft finden Sie auf M365 FM.