De puntjes verbinden: WPF, ASP.NET Core en gRPC integreren

By Mirko Peters · 2026-08-13

Inleiding tot moderne .NET-ontwikkeling: voordelen en uitdagingen van integratie Je ziet veel voordelen wanneer je WPF, ASP.NET Core MVC en gRPC in je project integreert…

Automatically translated with AI from the original post. Read the English original

Inleiding tot moderne .NET-ontwikkeling Integratie

Voordelen en uitdagingen

Bij het integreren van WPF, asp.net core mvc en grpc in je projecten zie je veel voordelen. Deze aanpak geeft je één gezamenlijke oplossing voor desktop, web en servicecommunicatie. De m365.fm Modern .NET Development Podcast, gepresenteerd door Mirko Peters met als gast Microsoft MVP Gábor Ruzsinszki, laat vaak zien hoe deze integratie helpt bij het bouwen van moderne, schaalbare applicaties.

Hieronder staat een tabel met de belangrijkste voordelen van het combineren van deze technologieën:

Je krijgt ook met een aantal uitdagingen te maken. Je moet de gegevenssynchronisatie tussen WPF en asp.net core mvc beheren. Je moet een consistente gebruikerservaring op desktop en web waarborgen. Beveiliging en authenticatie worden complexer wanneer je grpc op asp.net core gebruikt voor communicatie tussen services. Daarnaast moet je versiebeheer en updates voor elk onderdeel van je oplossing regelen.

Tip: Je kunt gedeelde bibliotheken gebruiken om je bedrijfslogica consistent te houden in WPF, asp.net core mvc en grpc op asp.net core. Dit voorkomt codeduplicatie en maakt je oplossing makkelijker te onderhouden.

Praktijkscenario's

Uit praktijkvoorbeelden valt veel te leren. Veel organisaties hebben oudere WPF-applicaties gemigreerd naar asp.net core mvc en grpc op asp.net core. Deze migraties laten zien hoe je je software moderniseert en de prestaties verbetert.

Hieronder staat een tabel met enkele voorbeelden:

Je begint misschien met een WPF-desktopapp waar je gebruikers dagelijks op vertrouwen. Je wilt meer gebruikers bereiken, dus bouw je een webversie met asp.net core mvc. Met grpc op asp.net core koppel je je desktop- en webapps aan gedeelde backendservices. Zo hergebruik je je bedrijfslogica en blijven je gegevens synchroon.

Je kunt grpc ook gebruiken om microservices in je oplossing te koppelen. grpc op asp.net core zorgt voor snelle, betrouwbare communicatie tussen services. Dit is belangrijk wanneer je realtime updates of hoge prestaties nodig hebt.

Wanneer je deze integratiepatronen toepast, creëer je flexibele en toekomstbestendige oplossingen. Je kunt nieuwe functies toevoegen, meer platforms ondersteunen en je applicaties schalen naarmate je behoeften groeien.

.NET-evolutie en modernisering

Van .NET Framework naar .NET Core

Je hebt gezien hoe .NET in de loop der jaren veel is veranderd. De overstap van .NET Framework naar .NET Core heeft grote verbeteringen opgeleverd voor ontwikkelaars en bedrijven. Wanneer je .NET 6 of .NET 7 gebruikt, draaien je applicaties sneller en met minder geheugen dan oudere versies. Je merkt een hogere doorvoer en kortere uitvoeringstijden, wat handig is bij webapps met veel verkeer. Geoptimaliseerde uitvoeringsengines en nieuwe runtimefuncties maken je code efficiënter. Elke nieuwe release levert meer snelheid en beter geheugenbeheer op. Je kunt je apps bovendien op verschillende besturingssystemen uitrollen, wat je werk makkelijker maakt.

Hier is een tabel met de belangrijkste verschillen in implementatie en onderhoud tussen .NET Framework en .NET Core:

Cross-platform en cloud-native

Je kunt .NET-applicaties nu bouwen en draaien op Windows, Linux en macOS. Deze cross-platform flexibiliteit geeft je meer keuze bij implementatie. Je kunt microservices en containers gebruiken om je applicaties op te splitsen in kleinere onderdelen. Dat maakt het makkelijker om je oplossingen te schalen en bij te werken. Diepe integratie met Azure laat je tools en services gebruiken die speciaal zijn gemaakt voor .NET-ontwikkelaars. Je kunt ook serverless computing gebruiken met Azure Functions, waardoor je je richt op je code in plaats van op het beheren van servers. Deze functies helpen je om high-performance, schaalbare apps te bouwen die goed werken in de cloud. Het sterke developer-ecosysteem en de moderne tools maken je werk sneller en betrouwbaarder.

Verouderde apps moderniseren

Je hebt misschien oudere applicaties die updates nodig hebben om bruikbaar en veilig te blijven. Verouderde applicaties moderniseren begint met een helder plan. Maak eerst een lijst van al je afhankelijkheden, zoals bibliotheken van derden en interne DLL's. Zoek vervolgens naar oude patronen, zoals WebForms-pagina's of Forms Authentication. Controleer de kwaliteit van je code en zoek naar sterk gekoppelde onderdelen of verouderde API's. Beslis daarna of je delen van je app wilt herschrijven of oude bibliotheken wilt vervangen. Stap over naar moderne ASP.NET-technologieën zoals Razor Pages of ASP.NET Core MVC. Neem nieuwe werkwijzen over, zoals dependency injection, geautomatiseerd testen en CI/CD-pipelines. Gebruik tools zoals de .NET Upgrade Assistant om je te helpen bij het proces.

Het moderniseren van verouderde applicaties kost tijd en middelen. Voor één zakelijke app met 50.000 tot 100.000 regels code kun je vier tot zes maanden kwijt zijn. De kosten liggen vaak tussen $100K en $1M, met een mediaan van ongeveer $180K. Als je een portfolio met veel verouderde applicaties beheert, kan het proces twee tot drie jaar duren, opgedeeld in kleinere projecten. Je krijgt betere prestaties, beveiliging en eenvoudiger onderhoud wanneer je je verouderde systemen moderniseert.

WPF-desktopapplicaties moderniseren

WPF in enterprise-ontwikkeling

Je gebruikt WPF om desktopapplicaties snel te bouwen. Visual Studio biedt je tools om moeiteloos te ontwerpen en te coderen. Veel organisaties kiezen voor WPF omdat de implementatie eenvoudig is. Je kunt apps verspreiden via gedeelde mappen of ClickOnce-installers. Dat maakt WPF een favoriet voor interne tools en snelle prototypes.

WPF blinkt uit wanneer je hoge grafische prestaties en responsiviteit nodig hebt. Je verwerkt grote datasets of complexe visualisaties met WPF. Het is een sterk alternatief voor webgebaseerde technologieën.

Microsoft blijft WPF ontwikkelen. Je ziet nieuwe functies zoals hardwareversnelling en het Fluent-thema voor moderne UI-ontwerp. WPF past bij kritieke line-of-business-applicaties in veel sectoren. WPF vind je in naar schatting 500.000 tot 1.000.000 actief ontwikkelde applicaties wereldwijd. Met WPF maak en implementeer je apps snel, met minder setup dan andere technologiestacks.

Migratiestrategieën

Je moet vaak verouderde Windows Presentation Foundation-applicaties moderniseren. Je wilt WPF-desktopapplicaties moderniseren om te profiteren van nieuwe .NET-functies.

Migratie naar .NET Core/5+/6+/8+

Je begint met het back-uppen van je projecten. Je installeert de .NET Upgrade Assistant. Je klikt met de rechtermuisknop op je project in Solution Explorer en kiest Upgrade. Je kiest tussen een upgrade ter plaatse (in-place) of een upgrade naast het origineel (side-by-side). Je kiest het doel-framework en de componenten die je wilt upgraden.

Je richt je omgeving in met Visual Studio 2019 en .NET Core 3.0. Je controleert de API-compatibiliteit met de .NET Portability Analyzer. Je maakt een nieuw .csproj-bestand voor je project. Je geeft de assemblynaam en de standaard-namespace op. Je onderdrukt het automatisch genereren van AssemblyInfo.

Tools die je voor de migratie kunt gebruiken, zijn onder andere:

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

Uno Platform voor cross-platform

Je moderniseert WPF door cross-platformoplossingen te verkennen. Met Uno Platform laat je WPF-achtige apps draaien op Windows, Linux, macOS, iOS, Android en WebAssembly. Je hergebruikt je bedrijfslogica en UI-componenten. Met minder inspanning bereik je meer gebruikers en apparaten. Uno Platform helpt je om je desktopapps te moderniseren voor een breder publiek.

Integratie met ASP.NET en gRPC

Je moderniseert WPF-desktopapplicaties door ze te koppelen aan web- en servicetechnologieën. Je gebruikt ASP.NET Core om web-API's en gebruikersinterfaces te bouwen. Je gebruikt gRPC voor snelle, betrouwbare communicatie tussen je desktopapp en backendservices. Je deelt bedrijfslogica tussen WPF, ASP.NET en gRPC. Je houdt je gegevens synchroon en verbetert de prestaties. Je moderniseert je werkwijze door WPF te integreren met moderne web- en servicestacks.

ASP.NET Core MVC voor webapps

Overzicht ASP.NET Core

Je gebruikt ASP.NET Core MVC om moderne webapplicaties te bouwen die snel, veilig en eenvoudig te onderhouden zijn. Dit framework biedt je één manier om zowel webgebruikersinterfaces als API's te maken. Je kunt je ASP.NET Core-applicatie draaien op Windows, Linux of macOS. Dankzij het cross-platformkarakter van ASP.NET Core kun je je apps in veel omgevingen uitrollen, inclusief de cloud.

Hieronder staat een tabel met de belangrijkste kenmerken die ASP.NET Core MVC tot een sterke keuze maken voor webontwikkeling:

Je begint met ASP.NET Core door de .NET SDK te installeren en je eerste project op te zetten. Het installatieproces van ASP.NET Core is eenvoudig en goed gedocumenteerd. Je kunt Visual Studio of de opdrachtregel gebruiken om je ASP.NET Core MVC-project te maken.

API's bouwen

Je bouwt API's met ASP.NET Core MVC om je webapps, mobiele apps en desktopclients te verbinden. Het framework ondersteunt RESTful-ontwerp, waarmee je je endpoints en datamodellen overzichtelijk kunt organiseren. Je kunt controllers gebruiken om verzoeken af te handelen en gegevens in JSON-formaat terug te geven. Dit maakt het voor andere applicaties eenvoudig om je API te gebruiken.

Om schaalbare en onderhoudbare API's te maken, volg je deze best practices:

• Structureer je project met Clean Architecture. Organiseer je code met Controllers, Services, Repositories en Models of DTO's.
• Gebruik async en await voor I/O-bewerkingen. Dit verbetert de prestaties en laat je app meer gebruikers tegelijk aan.
• Voeg globale foutafhandeling toe met middleware. Zo beheer je fouten op één plek.
• Schakel API-versiebeheer in. Dit zorgt ervoor dat je API's compatibel blijven met verschillende clients.
• Gebruik logging om fouten en belangrijke acties bij te houden.

Je kunt je ASP.NET Core MVC-API's koppelen aan andere services, zoals gRPC- of WPF-clients. Zo bouw je krachtige oplossingen die op meerdere platforms werken.

Beveiliging en authenticatie

Je beveiligt je ASP.NET Core-toepassing door gebruik te maken van ingebouwde beveiligingsfuncties. Het framework beschermt tegen veelvoorkomende bedreigingen zoals CSRF, XSS en SQL-injectie. Je kunt authenticatie en autorisatie toevoegen om te bepalen wie toegang heeft tot je API's. Veel ontwikkelaars gebruiken JWT-tokens om endpoints te beveiligen en gevoelige gegevens te beschermen.

Zorg er altijd voor dat je ASP.NET Core-toepassing up-to-date blijft. Regelmatige updates helpen je beveiligingsproblemen op te lossen en de prestaties te verbeteren. Je kunt ook middleware gebruiken om authenticatie en autorisatie over je hele app te beheren.

Tip: Beveilig je API's met sterke authenticatie en houd je afhankelijkheden up-to-date. Zo bouw je veilige en betrouwbare webtoepassingen.

Implementatieopties

Er zijn veel manieren om je ASP.NET Core MVC-toepassingen te implementeren. Elke optie biedt andere voordelen. Kies de optie die past bij de eisen van je project en de vaardigheden van je team.

1. Implementatie on-premises

Je kunt je app op je eigen servers implementeren. Deze methode geeft je volledige controle over je omgeving. Op Windows installeer je IIS (Internet Information Services), of op Linux gebruik je Kestrel met een reverse proxy zoals Nginx of Apache. Updates, beveiliging en schaalbaarheid beheer je zelf.

Tip: Gebruik Kestrel voor hoge prestaties. Combineer het met Nginx of Apache om HTTPS en load balancing af te handelen.

2. Clouddeployment

Je kunt je app naar de cloud implementeren. Populaire keuzes zijn Microsoft Azure, Amazon Web Services (AWS) en Google Cloud Platform (GCP). Cloudplatforms bieden eenvoudige schaalbaarheid, hoge beschikbaarheid en beheerde services.

Je kunt Azure App Service gebruiken om je app met slechts een paar klikken te implementeren. Je uploadt je code en Azure regelt de rest. Je kunt ook Azure DevOps gebruiken voor geautomatiseerde implementaties.

3. Containerisatie met Docker

Je kunt je app verpakken in een Docker-container. Deze methode maakt je app draagbaar en eenvoudig overal te implementeren. Je schrijft een eenvoudig Dockerfile om de omgeving van je app te definiëren.

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

Je bouwt en start je container lokaal en pusht die vervolgens naar een containerregister. Je kunt containers implementeren in Kubernetes of in cloudservices zoals Azure Kubernetes Service (AKS).

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

Je kunt je implementatieproces automatiseren met CI/CD-pipelines. Tools zoals GitHub Actions, Azure DevOps en GitLab CI helpen je om je app automatisch te bouwen, testen en implementeren.

Let op: CI/CD vermindert fouten en versnelt je releasecyclus. Je kunt wijzigingen snel terugdraaien als er iets misgaat.

5. Cross-platform hosting

Je kunt ASP.NET Core MVC-apps hosten op Windows, Linux of macOS. Die flexibiliteit laat je de beste omgeving kiezen voor jouw behoeften.

Overzichtstabel: implementatieopties

Bekijk je eisen voordat je een implementatiemethode kiest. Elke optie heeft sterke punten. Je kunt ze combineren voor nog betere resultaten. Je kunt bijvoorbeeld containers in de cloud gebruiken met CI/CD-pipelines voor snelle en betrouwbare implementaties.

gRPC in .NET

Wat is gRPC

Je gebruikt grpc om snelle en betrouwbare communicatie tussen je applicaties te bouwen. grpc staat voor Google Remote Procedure Call. Het is een open-source framework waarmee je methoden op een server vanuit een client kunt aanroepen alsof ze lokaal zijn. Je kunt grpc gebruiken voor scenario's met remote procedure calls met hoge prestaties. Dat betekent dat je gegevens snel verzendt en ontvangt, ook als je apps op verschillende machines draaien.

grpc gebruikt Protocol Buffers, een taal- en platformneutrale manier om gegevens te serialiseren. Je definieert je servicecontracten in een .proto-bestand. Dit bestand beschrijft de berichten en services die je wilt gebruiken. Vanuit dit bestand genereer je code voor je client en server. Je kunt grpc gebruiken in veel soorten toepassingen, waaronder WPF-desktopapps, ASP.NET-webapps en cloudservices.

gRPC versus REST

Je vraagt je misschien af hoe gRPC zich verhoudt tot REST. REST gebruikt HTTP en JSON om gegevens tussen clients en servers te versturen. gRPC gebruikt HTTP/2 en Protocol Buffers. Dat levert betere prestaties op, omdat HTTP/2 multiplexing en streaming ondersteunt. Protocol Buffers maken kleinere berichten dan JSON, waardoor je gegevens sneller onderweg zijn.

Hier is een tabel die je helpt gRPC en REST te vergelijken:

Je kiest voor gRPC wanneer je zeer schaalbare systemen of realtimecommunicatie nodig hebt. Je gebruikt REST wanneer je eenvoudige API's wilt die met browsers werken. Veel ontwikkelaars gebruiken beide in dezelfde oplossing.

gRPC-services instellen

Je zet gRPC-services in .NET op met een paar stappen. Eerst maak je een nieuw project aan in Visual Studio of met de .NET CLI. Je selecteert de sjabloon "gRPC Service". Deze sjabloon levert een voorbeeld-.proto-bestand en de code om je service te starten.

Je definieert je service en berichten in het .proto-bestand. Bijvoorbeeld:

syntax = "proto3";

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

message HelloRequest {
  string name = 1;
}

message HelloReply {
  string message = 1;
}

Je bouwt je project. De tools genereren C#-klassen voor je gRPC-client en -server. Je implementeert je servicelogica in C#. Je kunt gRPC-services hosten in ASP.NET Core of zelfs in een WPF-app voor geavanceerde scenario's.

Om je gRPC-services te testen, gebruik je tools zoals grpc-dotnet, Grpc.Net.Client en Grpc.AspNetCore.Server. Deze bibliotheken helpen je gRPC-services in .NET te bouwen, te hosten en te gebruiken. Je kunt FINT ook gebruiken om je gRPC-endpoints te testen.

Je koppelt je WPF-client of ASP.NET-app aan je gRPC-services door de gegenereerde clientcode toe te voegen. Hierdoor kunnen je apps snel en veilig met elkaar communiceren. Je kunt migreren van oudere technologieën zoals WCF naar gRPC voor een moderne, schaalbare oplossing.

Tip: Gebruik gRPC wanneer je snelle, betrouwbare en zeer schaalbare communicatie tussen je .NET-applicaties nodig hebt.

gRPC gebruiken in WPF en ASP.NET

Je kunt je WPF- en ASP.NET Core-applicaties koppelen aan gRPC-services. Zo deel je gegevens en bedrijfslogica tussen desktop- en webapps. Je krijgt snelle, betrouwbare communicatie die goed werkt voor moderne oplossingen.

WPF-clientintegratie

Je kunt gRPC toevoegen aan je WPF-desktopapp. Begin met het installeren van het NuGet-pakket Grpc.Net.Client. Dit pakket bevat de tools om gRPC-services vanuit je WPF-project aan te roepen.

Volg deze stappen om een gRPC-client in WPF in te stellen:

1. Voeg het .proto-bestand toe
   Plaats het .proto-bestand van je gRPC-service in je WPF-project. Stel de buildactie in op "Protobuf" in het projectbestand.

2. Installeer NuGet-pakketten
   Open de NuGet Package Manager. Installeer Grpc.Net.Client en Google.Protobuf.

3. Configureer de gRPC-client
   Maak een channel en een client in je code. Bijvoorbeeld:

   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. Verwerk threading
   Gebruik async en await om je UI responsief te houden. Blokkeer de hoofdthread niet.

Tip: Je kunt datamodellen delen tussen je WPF- en ASP.NET Core-projecten door gedeelde bibliotheken te gebruiken. Zo blijft je code overzichtelijk en consistent.

ASP.NET-clientintegratie

Je kunt gRPC-clients ook gebruiken in je ASP.NET Core-applicaties. Dit is handig wanneer je webapp andere services moet aanroepen, zoals microservices of backend-API's.

Zo stel je een gRPC-client in ASP.NET Core in:

1. Voeg het .proto-bestand toe
   Neem het .proto-bestand op in je ASP.NET Core-project. Stel de buildactie in op "Protobuf".

2. Installeer NuGet-pakketten
   Voeg Grpc.Net.ClientFactory en Google.Protobuf toe via NuGet.

3. Registreer de gRPC-client
   Registreer de client met dependency injection in je Startup.cs of Program.cs:

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

4. Injecteer en gebruik de client
   Injecteer de client in je controller of service:

   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();
       }
   }

Let op: Je kunt gRPC-clients gebruiken in achtergrondservices, controllers of elk ander onderdeel van je ASP.NET Core-app.

Je kunt je WPF- en ASP.NET Core-apps nu koppelen aan dezelfde gRPC-backend. Dit geeft je een uniforme en zeer performante oplossing voor je bedrijfsbehoeften.

Praktische integratiewalkthrough

Solutionarchitectuur

Je kunt een moderne oplossing bouwen door wpf, asp.net core mvc en grpc met elkaar te verbinden. Deze architectuur helpt je een naadloze ervaring te leveren op desktop en web. Je begint met een wpf-desktopapplicatie. Voor je webinterface voeg je asp.net core mvc toe. Met grpc koppel je beide clients aan je backendservices.

Hier is een eenvoudig diagram dat je helpt de structuur te begrijpen:

Je kunt deze opzet in veel scenario's gebruiken. Zo kun je bijvoorbeeld een verouderde wpf-app moderniseren door asp.net core mvc en grpc toe te voegen. Je kunt ook nieuwe oplossingen bouwen die zowel desktop- als webclients nodig hebben. Deze architectuur werkt goed voor microservices, omdat grpc snelle communicatie ondersteunt.

Tip: Met gedeelde bibliotheken kun je bedrijfslogica delen tussen wpf, asp.net core mvc en asp.net core. Dat houdt je code overzichtelijk en voorkomt duplicatie.

Een gRPC-service maken in ASP.NET Core

Je kunt in asp.net core eenvoudig een grpc-service maken. Deze service laat je wpf- en asp.net core mvc-clients met je backend communiceren. Je begint met het openen van Visual Studio en het maken van een nieuw project. Kies de sjabloon "gRPC Service". Deze sjabloon biedt alles wat je nodig hebt om te starten.

Volg deze stappen:

1. Open Visual Studio en selecteer "Create a new project".
2. Kies "gRPC Service" en klik op Volgende.
3. Geef je project een naam en selecteer asp.net core 8.0 of hoger.
4. Klik op Maken.

In je project zie je een voorbeeldservice "Greeter". De service gebruikt een .proto-bestand om het contract vast te leggen. Je kunt dit bestand bewerken om je eigen methoden en berichten toe te voegen.

Hier is een voorbeeld van een .proto-bestand:

syntax = "proto3";

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

message HelloRequest {
  string name = 1;
}

message HelloReply {
  string message = 1;
}

Je implementeert de service in C#. De sjabloon levert een GreeterService.cs-bestand. Daar voeg je je logica toe.

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

Je start je asp.net core-project. De grpc-service luistert naar aanvragen van je clients. Nu kun je je wpf- en asp.net core mvc-apps met deze service verbinden.

Let op: grpc gebruikt HTTP/2, dus zorg dat je server dit ondersteunt. Visual Studio regelt dit voor je wanneer je de sjabloon gebruikt.

grpc gebruiken in WPF

Je kunt je wpf-applicatie koppelen aan je grpc-service. Zo gebruikt je desktopapp dezelfde backend als je webapp. Je begint met het toevoegen van het .proto-bestand aan je wpf-project. Stel de buildactie in op "Protobuf".

Volg deze stappen om de client in te stellen:

1. Installeer de NuGet-pakketten Grpc.Net.Client en Google.Protobuf.
2. Voeg het .proto-bestand toe aan je project.
3. Maak in je code een grpc-kanaal aan.

Hier is een voorbeeld van een codefragment:

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

Je gebruikt async en await om je wpf-app responsief te houden. Je kunt grpc-methoden aanroepen vanuit je viewmodels of services. Met deze aanpak deel je gegevens en logica tussen je wpf- en asp.net core mvc-clients.

Tip: Je kunt je datamodellen hergebruiken door ze in een gedeelde bibliotheek te plaatsen. Zo blijven je wpf- en asp.net core mvc-projecten makkelijker synchroon.

Je hebt nu een oplossing waarin wpf en asp.net core mvc beide grpc gebruiken om met je backend te communiceren. Deze opzet biedt snelheid, betrouwbaarheid en een moderne architectuur.

Datacontracten en Protobuf

Je definieert datacontracten in gRPC met Protocol Buffers, ook wel Protobuf genoemd. Met Protobuf beschrijf je de structuur van je berichten in een .proto-bestand. Dit bestand fungeert als contract tussen je client en server. Je gebruikt het om C#-klassen te genereren die beide kanten begrijpen.

Wanneer je een .proto-bestand aan je .NET-project toevoegt, moet je het correct configureren. In onderstaande tabel staan de belangrijkste instellingen die je gebruikt:

Houd je .proto-bestanden eenvoudig en duidelijk. Gebruik duidelijke namen voor je berichten en velden. Vermijd gereserveerde woorden en speciale tekens. Gebruik altijd versienummers in je berichtnamen of pakketnamen als je van plan bent je contracten in de toekomst bij te werken.

Dit zijn enkele best practices voor het werken met Protobuf in .NET:

• Plaats je .proto-bestanden in een gedeelde map of bibliotheek. Zo houd je je contracten synchroon tussen WPF, ASP.NET Core en andere projecten.
• Gebruik de optie Both voor GrpcServices als je zowel client- als servercode wilt genereren op basis van hetzelfde .proto-bestand.
• Houd je gegevenstypen eenvoudig. Gebruik voor de meeste velden basistypen zoals string, int32 of bool.
• Voeg opmerkingen toe aan je .proto-bestanden. Opmerkingen helpen andere ontwikkelaars om je contracten te begrijpen.

Tip: Wanneer je een .proto-bestand bijwerkt, zorg er dan voor dat je de C#-code opnieuw genereert in alle projecten die het gebruiken. Zo blijven je client en server synchroon.

Foutafhandeling en logging

Je hebt sterke foutafhandeling en logging nodig om je .NET-applicaties betrouwbaar te houden. Wanneer je WPF, ASP.NET Core en gRPC samen gebruikt, moet je een aantal belangrijke strategieën volgen:

• Stel globale exception handlers in zowel ASP.NET Core als WPF in. Zo vang je fouten op die anders misschien onopgemerkt blijven.
• Gebruik gecentraliseerde logging. Dit maakt het eenvoudiger om problemen te volgen en je code te onderhouden.
• Gebruik in ASP.NET Core de interface IExceptionHandler om uitzonderingen in je hele app af te handelen.
• Maak in WPF een globale exception handler aan om onafgehandelde fouten op te vangen en te loggen.
• Log altijd belangrijke gebeurtenissen, fouten en waarschuwingen. Gebruik tools zoals Serilog, NLog of de ingebouwde logging-providers.
• Zorg ervoor dat je logs voldoende details bevatten, zodat je problemen snel kunt vinden en oplossen.

Let op: Goede foutafhandeling en logging helpen je problemen vroeg te signaleren. Ze maken je applicaties ook makkelijker te ondersteunen en na verloop van tijd te verbeteren.

Authenticatie en beveiliging

gRPC-services beveiligen

Je moet je gRPC-services beveiligen om je gegevens en gebruikers te beschermen. Begin met HTTPS voor alle gRPC-communicatie. Met deze stap versleutel je de gegevens tussen je client en server. Gebruik daarnaast authenticatie en autorisatie om de toegang te beheren. Wanneer je authenticatie en autorisatie instelt, bepaal je wie je gRPC-methoden mag aanroepen en welke acties ze mogen uitvoeren. Je kunt certificaten of tokens gebruiken om de identiteit van elke client te verifiëren. Veel ontwikkelaars gebruiken hiervoor JWT-tokens. Valideer deze tokens altijd op de server voordat je een aanvraag verwerkt.

Tip: Gebruik op rollen gebaseerde autorisatie om de toegang tot gevoelige gRPC-methoden te beperken. Wijs rollen toe aan gebruikers en controleer hun machtigingen voordat je ze acties laat uitvoeren.

Authenticatie in WPF en ASP.NET

Je moet authenticatie en autorisatie implementeren in zowel je WPF- als je ASP.NET-applicaties. In ASP.NET kun je ingebouwde middleware gebruiken voor authenticatie en autorisatie. Deze middleware controleert gebruikersreferenties en past autorisatieregels toe op elke aanvraag. Je kunt authenticatie/autorisatie toevoegen door de services te configureren in je Startup- of Program-bestand. Voor WPF maak je vaak verbinding met een backendservice voor authenticatie en autorisatie. De WPF-client stuurt de gebruikersreferenties naar de server, die een token teruggeeft als de referenties geldig zijn. De client gebruikt dit token vervolgens voor volgende aanvragen. Bewaar tokens altijd veilig aan de clientkant.

Onderstaande tabel toont veelgebruikte methoden voor authenticatie en autorisatie:

Let op: Gebruik altijd veilige opslag voor tokens in WPF-apps. Sla gevoelige gegevens nooit op in platte tekst.

Tokenbeheer

Je moet tokens zorgvuldig beheren om je applicaties veilig te houden. Wanneer je authenticatie en autorisatie gebruikt, geeft je server na een geslaagde aanmelding een token uit. De client slaat dit token op en stuurt het bij elk verzoek mee. Je moet vervaltijden voor tokens instellen om het risico te beperken. Wanneer een token verloopt, moet de client een nieuw token aanvragen. In ASP.NET kun je de levensduur van tokens en de logica voor vernieuwen configureren. Voor gRPC controleer je het token altijd voordat je een verzoek verwerkt. Ontbreekt het token of is het ongeldig, dan weiger je de toegang op basis van je autorisatieregels.

Je moet tokens ook intrekken wanneer een gebruiker zich afmeldt of wanneer je verdachte activiteit detecteert. Deze stap voorkomt ongeautoriseerde toegang. Controleer regelmatig je authenticatie- en autorisatie-instellingen om er zeker van te zijn dat ze aan je beveiligingseisen voldoen.

Tip: Automatiseer het vernieuwen van tokens in je clients, zodat sessies actief blijven zonder dat gebruikers worden onderbroken.

Implementatie en onderhoud

Implementatie in meerdere lagen

Je kunt je .NET-oplossing organiseren met een implementatie in meerdere lagen. Deze aanpak splitst je applicatie op in lagen. Elke laag heeft een specifieke taak. Je kunt bijvoorbeeld een presentatielaag gebruiken voor WPF of ASP.NET Core MVC, een servicelaag voor gRPC-communicatie en een datalaag voor je database. Deze structuur helpt je om je code te beheren en je oplossing te schalen.

Een typische opzet met meerdere lagen ziet er als volgt uit:

Je implementeert elke laag op een andere server of in een andere container. Deze scheiding verbetert de beveiliging en de prestaties. Je kunt de ene laag bijwerken zonder de andere te beïnvloeden.

Tip: Gebruik gRPC in je servicelaag om je presentatie- en datalaag snel en betrouwbaar met elkaar te verbinden.

CI/CD-pipelines

Je kunt je build- en deploymentproces automatiseren met CI/CD-pipelines. CI staat voor Continuous Integration. CD staat voor Continuous Deployment. Met deze pipelines lever je updates sneller en met minder fouten op.

Dit zijn de belangrijkste stappen in een CI/CD-pipeline:

1. Je pusht je code naar een broncodebeheersysteem zoals GitHub of Azure DevOps.
2. De pipeline bouwt je applicatie en voert tests uit.
3. Als de tests slagen, implementeert de pipeline je app in een test- of productieomgeving.

Je kunt tools gebruiken zoals GitHub Actions, Azure Pipelines of GitLab CI. Deze tools ondersteunen .NET-, ASP.NET Core- en gRPC-projecten. Je kunt automatische implementaties instellen voor je WPF-, web- en gRPC-services.

Opmerking: CI/CD-pipelines helpen je om problemen vroeg te ontdekken. Je kunt wijzigingen terugdraaien als er iets misgaat.

Monitoring en updates

Je moet je applicaties monitoren om ze gezond te houden. Monitoringtools houden fouten, prestaties en gebruik bij. Je kunt Application Insights, Prometheus of Grafana gebruiken. Deze tools werken met .NET-, ASP.NET Core- en gRPC-services.

Je moet alerts instellen voor belangrijke gebeurtenissen. Je kunt bijvoorbeeld een melding krijgen als je gRPC-service uitvalt of je webapp traag wordt. Regelmatige updates houden je systeem veilig en snel. Je moet je servers patchen, je bibliotheken bijwerken en je logs vaak controleren.

Een eenvoudige checklist voor onderhoud:

• Monitor alle services, inclusief gRPC-endpoints.
• Stel alerts in voor fouten en vertragingen.
• Werk je .NET-runtime en bibliotheken bij.
• Controleer logs en los problemen snel op.

Tip: Plan regelmatig onderhoudsvensters in. Zo kun je updates toepassen zonder gebruikers te storen.

Best practices en volgende stappen

Ontwerppatronen

Je verbetert je .NET-projecten door bewezen ontwerppatronen te gebruiken. Deze patronen helpen je code te schrijven die makkelijk te begrijpen, testen en onderhouden is. In moderne .NET-ontwikkeling gebruik je vaak patronen zoals Dependency Injection, Repository en MVVM (Model-View-ViewModel).

• Dependency Injection laat je afhankelijkheden tussen klassen beheren. Je registreert services in je startupcode en injecteert ze waar nodig. Dit patroon maakt je code flexibel en testbaar.
• Repository Pattern scheidt je datatoegangslogica van de bedrijfslogica. Je maakt repositoryklassen aan om databasebewerkingen af te handelen. Zo blijft je code georganiseerd.
• MVVM werkt goed voor WPF-applicaties. Je scheidt je UI, bedrijfslogica en datamodellen. Dit patroon helpt je responsieve en onderhoudbare desktopapps te bouwen.

Tip: The Modern .NET Development Podcast op m365.fm laat vaak zien hoe deze patronen je helpen om je oplossingen te schalen en je voor te bereiden op toekomstige wijzigingen.

Teststrategieën

Je hebt sterke teststrategieën nodig om betrouwbare software op te leveren. Testen helpt je om bugs vroeg te vinden en zorgt ervoor dat je code werkt zoals verwacht. In .NET gebruik je verschillende soorten tests:

Je schrijft unit-tests voor je bedrijfslogica. Met integratietests controleer je hoe je services en databases met elkaar samenwerken. Voor WPF- en webapps voeg je UI-tests toe om ervoor te zorgen dat je gebruikerservaring soepel blijft verlopen.

• Gebruik testgedreven ontwikkeling (TDD) om tests te schrijven voordat je code schrijft.
• Automatiseer je tests in CI/CD-pipelines voor snelle feedback.
• Mock afhankelijkheden om je tests te isoleren.

Let op: geautomatiseerd testen bespaart je tijd en vermindert fouten tijdens updates.

Documentatie en samenwerking

Je houdt je projecten gezond door duidelijke documentatie te schrijven en goed samen te werken met je team. Goede documentatie helpt nieuwe ontwikkelaars om je code te begrijpen. Het maakt het ook makkelijker om je applicaties te onderhouden en uit te breiden.

• Schrijf README-bestanden die het doel van je project en de installatiestappen uitleggen.
• Gebruik XML-commentaar in je code om klassen en methoden te beschrijven.
• Maak API-documentatie met tools zoals Swagger voor ASP.NET Core.

Je werkt beter samen als je versiebeheersystemen zoals Git gebruikt. Je houdt wijzigingen bij, reviewt code en lost conflicten samen op als team. Communicatieve vaardigheden zijn even belangrijk als technische vaardigheden. The Modern .NET Development Podcast bespreekt vaak hoe sterke communicatie en duidelijke documentatie teams helpen slagen, vooral nu AI-tools steeds vaker in ontwikkeling worden gebruikt.

Tip: Plan regelmatig code reviews in en deel kennis met je team. Deze aanpak leidt tot betere code en een sterker team.

Leermiddelen

Je kunt je .NET-vaardigheden verder ontwikkelen met een breed scala aan leermiddelen. Het .NET-ecosysteem verandert snel, dus je moet op de hoogte blijven van de nieuwste tools, frameworks en best practices. Hieronder staan enkele topbronnen die je helpen om je kennis actueel en praktisch te houden.

📚 Aanbevolen podcasts en shows

• Modern .NET Development Podcast (m365.fm)
  Luister mee terwijl Mirko Peters en Microsoft MVP Gábor Ruzsinszki praten over .NET-onderwerpen uit de praktijk. Je krijgt expertadvies over WPF, ASP.NET Core, gRPC en meer. De podcast behandelt AI in ontwikkeling, communicatieve vaardigheden en toekomstige .NET-functies.

  Tip: Abonneer je op de Modern .NET Development Podcast via je favoriete platform voor regelmatige updates.

• .NET Rocks!
  In deze show staan interviews met toonaangevende figuren uit de branche. Je leert over nieuwe trends, tools en technieken in .NET.

📖 Officiële documentatie en gidsen

• Microsoft Learn voor .NET
  Je vindt stap-voor-stap-tutorials, codevoorbeelden en interactieve lessen. Microsoft Learn helpt je om alles te beheersen, van WPF tot ASP.NET Core en gRPC.

• ASP.NET Core-documentatie
  Je krijgt uitgebreide handleidingen voor het bouwen van webapps, API's en veilige oplossingen.

• gRPC voor .NET-documentatie
  Deze bron legt uit hoe je gRPC-services in .NET instelt, gebruikt en test.

🛠️ Community en interactieve platforms

• Stack Overflow
  Je kunt vragen stellen en antwoorden vinden van ervaren .NET-ontwikkelaars. Zoek naar oplossingen of deel je eigen kennis.

• GitHub
  Ontdek open-source .NET-projecten. Je kunt code lezen, bijdragen aan repositories en leren van praktijkvoorbeelden.

• Microsoft Q&A
  Via dit forum kom je in contact met Microsoft-engineers en de .NET-community.

📅 Conferenties en online evenementen

• .NET Conf
  Je kunt livesessies en workshops bekijken. Leer over de nieuwste .NET-releases en -functies.

• Lokale meetups
  Sluit je aan bij .NET-gebruikersgroepen in je regio. Ontmoet andere ontwikkelaars, deel ervaringen en werk samen aan projecten.

📝 Tabel: Snel overzicht van leermiddelen

Let op: Reserveer elke week tijd om nieuwe bronnen te verkennen. Continu leren helpt je om voorop te blijven in modern .NET-ontwikkelen.

Je kunt deze bronnen combineren om een sterke basis op te bouwen. Probeer nieuwe tools, volg expertadvies en word lid van de .NET-community. Zo verbeter je je vaardigheden en houd je je projecten modern en efficiënt.

Je hebt geleerd hoe je WPF, ASP.NET en gRPC met elkaar verbindt voor modern .NET-ontwikkelen. Je hebt praktische stappen gezien voor migratie, integratie en beveiliging. Met gRPC bouw je snelle communicatie tussen desktop- en webapps. Je verbetert je projecten door de best practices te volgen uit de aflevering Modern .NET: WPF, ASP.NET Core, and gRPC with Gábor Ruzsinszki [MVP]. Probeer gRPC in je volgende oplossing. Op m365.fm vind je meer expertadvies.

Sluit je aan bij de .NET-community en experimenteer met voorbeeldprojecten om je vaardigheden te vergroten.

Veelgestelde vragen

Wat is het belangrijkste voordeel van WPF voor desktopapplicaties?

Met WPF bouw je rijke en responsieve gebruikersinterfaces. Het framework ondersteunt geavanceerde graphics en databinding. Zo ontwerp je snel en efficiënt desktopapps van enterprise-niveau.

Hoe verbetert ASP.NET Core webontwikkeling?

Met ASP.NET Core krijg je cross-platformondersteuning en hoge prestaties. Het framework laat je veilige webapps en API's bouwen. Je rolt je oplossingen uit op Windows, Linux of macOS.

Waarom zou je gRPC gebruiken voor servicecommunicatie?

Met gRPC bereik je snelle en betrouwbare communicatie tussen services. Het framework gebruikt HTTP/2 en Protocol Buffers. Zo verlaag je de latentie en verbeter je de schaalbaarheid van je applicaties.

Kun je WPF en ASP.NET Core met gRPC verbinden?

Met gRPC integreer je WPF en ASP.NET Core. Het framework zorgt ervoor dat je desktop- en webapps gegevens en bedrijfslogica kunnen delen. Zo maak je geünificeerde oplossingen voor moderne bedrijfsbehoeften.

Welke tools helpen je bij het migreren van verouderde .NET-applicaties?

Voor migratie gebruik je de .NET Upgrade Assistant en Visual Studio. Deze tools analyseren je code en begeleiden je door het upgradeproces. Zo moderniseer je je apps met minder inspanning.

Hoe beveilig je je ASP.NET Core- en gRPC-services?

Je beschermt je services door HTTPS in te schakelen en authenticatietokens te gebruiken. Met op rollen gebaseerde autorisatie bepaal je wie toegang krijgt. Zo houd je je gegevens veilig en je gebruikers beschermd.

Waar vind je expertadvies over modern .NET-ontwikkelen?

Luister naar de Modern .NET Development Podcast op m365.fm. De podcast bevat praktijkvoorbeelden en praktische tips. Je leert van experts uit de sector en blijft op de hoogte van nieuwe technologieën.

🎧 Luister naar deze aflevering

Wil je een praktische uitleg over Modern .NET? In deze aflevering wordt het onderwerp helder uitgelegd en wordt duidelijk waarom het ertoe doet voor Microsoft 365, Azure, Power Platform, beveiliging, AI en modern werken.

Luister naar deze aflevering als je:

• De kernconcepten achter Modern .NET wilt begrijpen
• wilt zien hoe het past in het bredere Microsoft-technologie-ecosysteem
• wilt leren waar het praktische waarde kan opleveren voor je organisatie

Misschien vind je ook deze gerelateerde M365 FM-afleveringen leuk:

• LINQ to SQL vs EF Core voor .NET-gegevenstoegang
• .NET-uitbreidbaarheid en Clean Architecture met Miguel Castro [MVP]
• Modern Microsoft 365 Automation Beyond PowerShell Scripts
• Build AI Applications with .NET 10
• Improve Entity Framework Core Query Performance

Ontdek meer praktische Microsoft-gesprekken op M365 FM.