Łączenie kropek: integracja WPF, ASP.NET Core i gRPC

By Mirko Peters · 2026-08-13

Wprowadzenie do nowoczesnej integracji w .NET: korzyści i wyzwania Widzisz wiele korzyści, gdy integrujesz WPF, ASP.NET Core MVC i gRPC w swoich projektach. Takie podejście daje ci jednolite rozwiązanie dla komunikacji z aplikacjami desktopowymi, webowymi i usługami. Poniższe…

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

Wprowadzenie do nowoczesnej integracji w .NET

Korzyści i wyzwania

Widzisz wiele korzyści, gdy integrujesz WPF, ASP.NET Core MVC i gRPC w swoich projektach. Takie podejście daje ci jednolite rozwiązanie dla komunikacji desktop, web i usług. Podcast m365.fm Modern .NET Development Podcast, prowadzony przez Mirko Petersa, z gościem, Microsoft MVP Gáborem Ruzsinszkim, często podkreśla, jak ta integracja pomaga budować nowoczesne, skalowalne aplikacje.

Poniżej znajduje się tabela z głównymi korzyściami łączenia tych technologii:

Napotkasz także pewne wyzwania. Musisz zarządzać synchronizacją danych między WPF a ASP.NET Core MVC. Musisz zapewnić spójne doświadczenie użytkownika w aplikacji desktopowej i webowej. Bezpieczeństwo i uwierzytelnianie stają się bardziej złożone, gdy używasz gRPC w ASP.NET Core do komunikacji między usługami. Musisz też obsługiwać wersjonowanie i aktualizacje każdej części rozwiązania.

Wskazówka: Możesz użyć bibliotek współdzielonych, aby logika biznesowa była spójna w WPF, ASP.NET Core MVC i gRPC w ASP.NET Core. Ograniczy to duplikowanie kodu i ułatwi utrzymanie rozwiązania.

Scenariusze z życia wzięte

Wiele można nauczyć się na przykładach z praktyki. Wiele organizacji migrowało starsze aplikacje WPF do ASP.NET Core MVC i gRPC w ASP.NET Core. Te migracje pokazują, jak zmodernizować oprogramowanie i poprawić wydajność.

Poniżej znajduje się tabela z przykładami:

Możesz zacząć od aplikacji desktopowej WPF, z której użytkownicy korzystają każdego dnia. Chcesz dotrzeć do większej liczby użytkowników, więc budujesz wersję webową z użyciem ASP.NET Core MVC. Do połączenia aplikacji desktopowej i webowej ze wspólnymi usługami zaplecza używasz gRPC w ASP.NET Core. Dzięki temu możesz ponownie wykorzystać logikę biznesową i utrzymać spójność danych.

Do łączenia mikrousług w rozwiązaniu możesz też użyć gRPC. gRPC w ASP.NET Core zapewnia szybką i niezawodną komunikację między usługami. Jest to istotne, gdy potrzebujesz aktualizacji w czasie rzeczywistym lub wysokiej wydajności.

Stosując te wzorce integracji, tworzysz elastyczne i przyszłościowe rozwiązania. Możesz dodawać nowe funkcje, obsługiwać więcej platform i skalować aplikacje wraz z rosnącymi potrzebami.

Ewolucja .NET i modernizacja

Przejście z .NET Framework na .NET Core

Widzisz, jak bardzo .NET zmienił się na przestrzeni lat. Przejście z .NET Framework na .NET Core przyniosło duże usprawnienia dla programistów i firm. Gdy używasz .NET 6 lub .NET 7, twoje aplikacje działają szybciej i zużywają mniej pamięci niż w starszych wersjach. Zauważysz lepszą przepustowość i krótsze czasy wykonania, co pomaga przy budowie aplikacji webowych o dużym ruchu. Zoptymalizowane silniki wykonawcze i nowe funkcje runtime sprawiają, że twój kod jest bardziej wydajny. Każde nowe wydanie przynosi większą szybkość i lepsze zarządzanie pamięcią. Możesz też wdrażać swoje aplikacje w różnych systemach operacyjnych, co ułatwia pracę.

Oto tabela pokazująca najważniejsze różnice we wdrażaniu i utrzymaniu między .NET Framework a .NET Core:

Wieloplatformowość i natywność dla chmury

Aplikacje .NET można teraz tworzyć i uruchamiać w systemach Windows, Linux i macOS. Ta wieloplatformowa elastyczność daje więcej możliwości wyboru sposobu wdrożenia. Aplikacje można podzielić na mniejsze części, korzystając z mikrousług i kontenerów. Ułatwia to skalowanie i aktualizowanie rozwiązań. Głęboka integracja z platformą Azure pozwala korzystać z narzędzi i usług przeznaczonych dla programistów .NET. Można też używać obliczeń bezserwerowych z Azure Functions, dzięki czemu skupiasz się na kodzie, a nie na zarządzaniu serwerami. Te funkcje pomagają tworzyć wydajne, skalowalne aplikacje, które dobrze działają w chmurze. Silny ekosystem deweloperski i nowoczesne narzędzia sprawiają, że praca jest szybsza i bardziej niezawodna.

Modernizacja starszych aplikacji

Być może masz starsze aplikacje, które wymagają aktualizacji, aby pozostały użyteczne i bezpieczne. Modernizacja starszych aplikacji zaczyna się od jasnego planu. Najpierw wypisz wszystkie zależności, takie jak biblioteki firm trzecich i wewnętrzne pliki DLL. Następnie poszukaj przestarzałych wzorców, na przykład stron WebForms czy Forms Authentication. Sprawdź jakość kodu i znajdź silnie powiązane fragmenty oraz przestarzałe interfejsy API. Potem zdecyduj, czy chcesz przepisać części aplikacji, czy wymienić stare biblioteki. Przejdź na nowoczesne technologie ASP.NET, takie jak Razor Pages lub ASP.NET Core MVC. Wdróż nowe praktyki, na przykład wstrzykiwanie zależności, automatyczne testowanie i potoki CI/CD. Do pomocy w tym procesie użyj narzędzi takich jak .NET Upgrade Assistant.

Modernizacja starszych aplikacji może wymagać czasu i zasobów. W przypadku pojedynczej aplikacji biznesowej liczącej od 50 000 do 100 000 linii kodu może to zająć od czterech do sześciu miesięcy. Koszty najczęściej mieszczą się w przedziale od 100 tys. do 1 mln USD, a mediana wynosi około 180 tys. USD. Jeśli zarządzasz portfelem wielu starszych aplikacji, proces może potrwać od dwóch do trzech lat, podzielony na mniejsze projekty. Modernizując starsze systemy, zyskujesz lepszą wydajność, bezpieczeństwo i łatwiejsze utrzymanie.

Modernizacja aplikacji desktopowych WPF

WPF w tworzeniu aplikacji korporacyjnych

Za pomocą WPF możesz szybko tworzyć aplikacje desktopowe. Visual Studio udostępnia narzędzia, które pozwalają projektować i pisać kod bez trudu. Wiele organizacji wybiera WPF, ponieważ upraszcza wdrażanie. Aplikacje można rozprowadzać przez udziały sieciowe lub instalatory ClickOnce. Sprawia to, że WPF jest chętnie wybierany do narzędzi wewnętrznych i szybkiego prototypowania.

WPF sprawdza się najlepiej, gdy potrzebujesz wysokiej wydajności graficznej i responsywności. Dzięki WPF możesz obsługiwać duże zbiory danych lub złożone wizualizacje. Jest to mocna alternatywa dla technologii opartych na przeglądarce.

Microsoft nadal rozwija WPF. Pojawiają się nowe funkcje, takie jak akceleracja sprzętowa i motyw Fluent do nowoczesnego projektowania interfejsu. WPF dobrze sprawdza się w krytycznych aplikacjach biznesowych w wielu branżach. Według szacunków na świecie działa około 500 000 do 1 000 000 aktywnie rozwijanych aplikacji opartych na WPF. Dzięki WPF szybko tworzysz i wdrażasz aplikacje, a konfiguracja wymaga mniej pracy niż w innych stosach technologicznych.

Strategie migracji

Często zachodzi potrzeba modernizacji starszych aplikacji Windows Presentation Foundation. Chcesz zmodernizować aplikacje desktopowe WPF, aby skorzystać z nowych funkcji .NET.

Migracja do .NET Core/5+/6+/8+

Zaczynasz od wykonania kopii zapasowej projektów. Instalujesz narzędzie .NET Upgrade Assistant. Klikasz prawym przyciskiem myszy projekt w Eksploratorze rozwiązań i wybierasz opcję Uaktualnij. Wybierasz między uaktualnieniem w miejscu a uaktualnieniem równoległym (side-by-side). Wybierasz platformę docelową i składniki do uaktualnienia.

Konfigurujesz środowisko z programem Visual Studio 2019 i .NET Core 3.0. Sprawdzasz zgodność interfejsów API za pomocą narzędzia .NET Portability Analyzer. Tworzysz nowy plik .csproj dla swojego projektu. Określasz nazwę zestawu i domyślną przestrzeń nazw. Wyłączasz automatyczne generowanie pliku AssemblyInfo.

Narzędzia użyteczne podczas migracji to m.in.:

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

Uno Platform for Cross-Platform

Modernizujesz aplikacje WPF, sięgając po rozwiązania wieloplatformowe. Uno Platform pozwala uruchamiać aplikacje podobne do WPF w systemach Windows, Linux, macOS, iOS, Android oraz WebAssembly. Ponownie wykorzystujesz logikę biznesową i komponenty interfejsu użytkownika. Docierasz do większej liczby użytkowników i urządzeń przy mniejszym nakładzie pracy. Uno Platform pomaga unowocześnić aplikacje desktopowe i dotrzeć do szerszego grona odbiorców.

Integracja z ASP.NET i gRPC

Modernizujesz aplikacje desktopowe WPF, łącząc je z technologiami webowymi i usługowymi. Do budowy interfejsów API i interfejsów użytkownika w sieci używasz ASP.NET Core. Do szybkiej i niezawodnej komunikacji między aplikacją desktopową a usługami zaplecza używasz gRPC. Współdzielisz logikę biznesową między WPF, ASP.NET i gRPC. Utrzymujesz dane w synchronizacji i poprawiasz wydajność. Unowocześniasz proces pracy, integrując WPF z nowoczesnymi stosami webowymi i usługowymi.

ASP.NET Core MVC dla aplikacji internetowych

Omówienie ASP.NET Core

Za pomocą ASP.NET Core MVC tworzysz nowoczesne aplikacje internetowe, które są szybkie, bezpieczne i łatwe w utrzymaniu. Ta platforma zapewnia jednolity sposób tworzenia zarówno interfejsów użytkownika w sieci, jak i interfejsów API. Aplikację ASP.NET Core uruchomisz w systemach Windows, Linux lub macOS. Wieloplatformowy charakter ASP.NET Core oznacza, że możesz wdrażać aplikacje w wielu środowiskach, w tym w chmurze.

Poniżej znajduje się tabela przedstawiająca kluczowe funkcje, które sprawiają, że ASP.NET Core MVC jest mocnym wyborem do tworzenia aplikacji internetowych:

Pierwsze kroki z ASP.NET Core zaczynasz od instalacji .NET SDK i utworzenia pierwszego projektu. Proces konfiguracji ASP.NET Core jest prosty i dobrze udokumentowany. Projekt ASP.NET Core MVC utworzysz w programie Visual Studio lub w wierszu poleceń.

Budowanie interfejsów API

Interfejsy API budujesz za pomocą ASP.NET Core MVC, aby łączyć aplikacje internetowe, mobilne i klienty desktopowe. Platforma obsługuje projektowanie RESTful, które pomaga uporządkować punkty końcowe i modele danych. Do obsługi żądań i zwracania danych w formacie JSON możesz użyć kontrolerów. Dzięki temu inne aplikacje łatwo korzystają z Twojego interfejsu API.

Aby tworzyć skalowalne i łatwe w utrzymaniu interfejsy API, warto stosować te sprawdzone praktyki:

• Strukturyzuj projekt zgodnie z Clean Architecture. Uporządkuj kod w kontrolery, usługi, repozytoria oraz modele lub DTO.
• Używaj async i await do operacji wejścia-wyjścia. Poprawia to wydajność i pozwala aplikacji obsłużyć więcej użytkowników jednocześnie.
• Dodaj globalną obsługę wyjątków za pomocą middleware. Ułatwia to zarządzanie błędami w jednym miejscu.
• Włącz wersjonowanie interfejsu API. Dzięki temu Twoje interfejsy API pozostają zgodne z różnymi klientami.
• Używaj logowania do śledzenia błędów i ważnych działań.

Interfejsy API ASP.NET Core MVC możesz połączyć z innymi usługami, takimi jak klienty gRPC lub WPF. Pozwala to tworzyć zaawansowane rozwiązania działające na wielu platformach.

Zabezpieczenia i uwierzytelnianie

Chronisz swoją aplikację asp.net core, korzystając z wbudowanych funkcji zabezpieczeń. Platforma chroni przed typowymi zagrożeniami, takimi jak CSRF, XSS i wstrzykiwanie SQL. Możesz dodać uwierzytelnianie i autoryzację, aby kontrolować, kto ma dostęp do Twoich interfejsów API. Wielu programistów używa tokenów JWT do zabezpieczania punktów końcowych i ochrony wrażliwych danych.

Zawsze powinieneś utrzymywać aplikację asp.net core w aktualnej wersji. Regularne aktualizacje pomagają usuwać problemy z zabezpieczeniami i poprawiać wydajność. Możesz także użyć middleware do zarządzania uwierzytelnianiem i autoryzacją w całej aplikacji.

Wskazówka: zabezpieczaj interfejsy API silnym uwierzytelnianiem i dbaj o aktualność zależności. Pomaga to tworzyć bezpieczne i niezawodne aplikacje internetowe.

Opcje wdrażania

Istnieje wiele sposobów wdrażania aplikacji ASP.NET Core MVC. Każda opcja daje inne korzyści. Wybierz tę, która pasuje do wymagań projektu i umiejętności zespołu.

1. Wdrożenie lokalne (on-premises)

Aplikację możesz wdrożyć na własnych serwerach. Ta metoda daje pełną kontrolę nad środowiskiem. Na systemie Windows instalujesz IIS (Internet Information Services), a na Linuksie używasz Kestrel z odwrotnym serwerem proxy, takim jak Nginx lub Apache. Aktualizacjami, zabezpieczeniami i skalowaniem zarządzasz samodzielnie.

Wskazówka: Użyj Kestrel, aby uzyskać wysoką wydajność. Połącz go z Nginx lub Apache, aby obsługiwać HTTPS i równoważenie obciążenia.

2. Wdrożenie w chmurze

Aplikację możesz wdrożyć w chmurze. Do popularnych wyborów należą Microsoft Azure, Amazon Web Services (AWS) i Google Cloud Platform (GCP). Platformy chmurowe oferują łatwe skalowanie, wysoką dostępność i usługi zarządzane.

Aplikację wdrożysz w usłudze Azure App Service w kilku kliknięciach. Przesyłasz kod, a Azure zajmuje się resztą. Do zautomatyzowanych wdrożeń możesz też użyć Azure DevOps.

3. Konteneryzacja z Dockerem

Aplikację możesz spakować do kontenera Docker. Dzięki temu staje się ona przenośna i łatwa do wdrożenia w dowolnym miejscu. Środowisko aplikacji definiujesz w prostym pliku Dockerfile.

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

Kontener budujesz i uruchamiasz lokalnie, a następnie wysyłasz do rejestru kontenerów. Kontenery możesz wdrażać w Kubernetes lub w usługach chmurowych, takich jak Azure Kubernetes Service (AKS).

4. Ciągła integracja i ciągłe wdrażanie (CI/CD)

Proces wdrażania możesz zautomatyzować za pomocą potoków CI/CD. Narzędzia takie jak GitHub Actions, Azure DevOps i GitLab CI pomagają automatycznie budować, testować i wdrażać aplikację.

Uwaga: CI/CD ogranicza liczbę błędów i przyspiesza cykl wydań. Jeśli coś pójdzie nie tak, możesz szybko wycofać zmiany.

5. Hosting wieloplatformowy

Aplikacje ASP.NET Core MVC możesz hostować w systemach Windows, Linux lub macOS. Ta elastyczność pozwala wybrać środowisko najlepiej dopasowane do Twoich potrzeb.

Tabela podsumowująca: opcje wdrażania

Przed wyborem metody wdrożenia warto przeanalizować wymagania. Każda opcja ma swoje mocne strony. Możesz je także łączyć, aby uzyskać jeszcze lepsze efekty. Na przykład kontenery w chmurze z potokami CI/CD zapewnią szybkie i niezawodne wdrożenia.

gRPC w .NET

Czym jest gRPC

Do budowy szybkiej i niezawodnej komunikacji między aplikacjami używasz grpc. grpc oznacza Google Remote Procedure Call. To framework open source, który pozwala wywoływać metody na serwerze z poziomu klienta tak, jakby były lokalne. Możesz go użyć w scenariuszach zdalnego wywoływania procedur o wysokiej wydajności. Oznacza to, że dane wysyłasz i odbierasz szybko, nawet gdy aplikacje działają na różnych maszynach.

grpc korzysta z Protocol Buffers, neutralnego względem języka i platformy sposobu serializacji danych. Kontrakty usług definiujesz w pliku .proto. Plik ten opisuje komunikaty i usługi, których chcesz używać. Kod dla klienta i serwera generujesz właśnie z tego pliku. grpc możesz stosować w wielu typach aplikacji, m.in. w aplikacjach desktopowych WPF, aplikacjach internetowych ASP.NET i usługach chmurowych.

gRPC a REST

Być może zastanawiasz się, jak gRPC wypada na tle REST. REST wykorzystuje HTTP i JSON do przesyłania danych między klientami a serwerami. gRPC korzysta z HTTP/2 i Protocol Buffers. Zapewnia to lepszą wydajność, ponieważ HTTP/2 obsługuje multipleksowanie i strumieniowanie. Protocol Buffers tworzą mniejsze komunikaty niż JSON, dzięki czemu dane przesyłane są szybciej.

Poniżej tabela, która pomoże porównać gRPC i REST:

Wybierasz gRPC, gdy potrzebujesz wysoce skalowalnych systemów lub komunikacji w czasie rzeczywistym. Używasz REST, gdy chcesz prostych interfejsów API, które działają w przeglądarkach. Wielu deweloperów korzysta z obu tych rozwiązań w tym samym projekcie.

Konfigurowanie usług gRPC

Konfiguracja usług gRPC w .NET wymaga kilku kroków. Najpierw tworzysz nowy projekt w Visual Studio lub za pomocą .NET CLI. Wybierasz szablon „gRPC Service”. Szablon ten zawiera przykładowy plik .proto oraz kod potrzebny do uruchomienia usługi.

W pliku .proto definiujesz usługę i komunikaty. Na przykład:

syntax = "proto3";

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

message HelloRequest {
  string name = 1;
}

message HelloReply {
  string message = 1;
}

Kompilujesz projekt. Narzędzia generują klasy C# dla klienta i serwera gRPC. Logikę usługi implementujesz w C#. Usługi gRPC możesz hostować w ASP.NET Core, a w zaawansowanych scenariuszach nawet w aplikacji WPF.

Do testowania usług gRPC możesz użyć bibliotek takich jak grpc-dotnet, Grpc.Net.Client i Grpc.AspNetCore.Server. Ułatwiają one budowanie, hostowanie i korzystanie z usług gRPC w .NET. Do testowania punktów końcowych gRPC możesz też użyć narzędzia FINT.

Łączysz klienta WPF lub aplikację ASP.NET z usługami gRPC, dodając wygenerowany kod klienta. Dzięki temu aplikacje szybko i bezpiecznie komunikują się ze sobą. Możesz też migrować ze starszych technologii, takich jak WCF, do gRPC, uzyskując nowoczesne, skalowalne rozwiązanie.

Wskazówka: Używaj gRPC, gdy potrzebujesz szybkiej, niezawodnej i wysoce skalowalnej komunikacji między aplikacjami .NET.

Korzystanie z gRPC w WPF i ASP.NET

Możesz połączyć aplikacje WPF i ASP.NET Core z usługami gRPC. Pozwala to współdzielić dane i logikę biznesową między aplikacjami desktopowymi a webowymi. Otrzymujesz szybką, niezawodną komunikację, która dobrze sprawdza się w nowoczesnych rozwiązaniach.

Integracja klienta WPF

Klienta gRPC możesz dodać do aplikacji desktopowej WPF. Zacznij od zainstalowania pakietu NuGet Grpc.Net.Client. Pakiet ten zapewnia narzędzia do wywoływania usług gRPC z projektu WPF.

Wykonaj poniższe kroki, aby skonfigurować klienta gRPC w WPF:

1. Dodaj plik .proto
   Umieść plik .proto z usługi gRPC w projekcie WPF. Ustaw jego akcję kompilacji na „Protobuf” w pliku projektu.

2. Zainstaluj pakiety NuGet
   Otwórz Menedżera pakietów NuGet. Zainstaluj Grpc.Net.Client i Google.Protobuf.

3. Skonfiguruj klienta gRPC
   W kodzie utwórz kanał i klienta. Na przykład:

   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. Obsłuż wątki
   Użyj async i await, aby interfejs użytkownika pozostał responsywny. Nie blokuj wątku głównego.

Wskazówka: Modele danych możesz współdzielić między projektami WPF i ASP.NET Core, korzystając z bibliotek współdzielonych. Dzięki temu kod pozostaje czysty i spójny.

Integracja klienta ASP.NET

Klientów gRPC możesz też używać w aplikacjach ASP.NET Core. Jest to przydatne, gdy aplikacja webowa musi wywoływać inne usługi, na przykład mikrousługi lub backendowe interfejsy API.

Tak skonfigurujesz klienta gRPC w ASP.NET Core:

1. Dodaj plik .proto
   Dołącz plik .proto do projektu ASP.NET Core. Ustaw jego akcję kompilacji na „Protobuf”.

2. Zainstaluj pakiety NuGet
   Dodaj pakiety Grpc.Net.ClientFactory i Google.Protobuf za pomocą NuGet.

3. Zarejestruj klienta gRPC
   W pliku Startup.cs lub Program.cs zarejestruj klienta w kontenerze wstrzykiwania zależności:

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

4. Wstrzyknij i użyj klienta
   Wstrzyknij klienta do kontrolera lub usługi:

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

Uwaga: Klientów gRPC możesz używać w usługach działających w tle, kontrolerach lub w dowolnej części aplikacji ASP.NET Core.

Możesz teraz połączyć aplikacje WPF i ASP.NET Core z tym samym backendem gRPC. Daje to ujednolicone, wysokowydajne rozwiązanie dla potrzeb biznesowych.

Praktyczny przewodnik po integracji

Architektura rozwiązania

Nowoczesne rozwiązanie zbudujesz, łącząc ze sobą wpf, asp.net core mvc i grpc. Ta architektura pozwala zapewnić płynne doświadczenie zarówno na komputerze, jak i w przeglądarce. Zaczynasz od aplikacji desktopowej wpf. Dodajesz asp.net core mvc jako interfejs webowy. Za pomocą grpc łączysz oba klienty z usługami zaplecza.

Oto prosty diagram, który pomoże Ci zrozumieć strukturę:

Tej konfiguracji możesz użyć w wielu scenariuszach. Na przykład możesz zmodernizować istniejącą aplikację wpf, dodając asp.net core mvc i grpc. Możesz też budować nowe rozwiązania, które potrzebują zarówno klientów desktopowych, jak i webowych. Ta architektura dobrze sprawdza się w mikrousługach, ponieważ grpc obsługuje szybką komunikację.

Wskazówka: Logikę biznesową możesz współdzielić między wpf, asp.net core mvc i asp.net core, korzystając z bibliotek współdzielonych. Dzięki temu kod jest czystszy i nie powtarza się.

Tworzenie usługi gRPC w ASP.NET Core

Możesz utworzyć prostą usługę grpc w asp.net core. Ta usługa umożliwi klientom wpf i asp.net core mvc komunikację z zapleczem. Zaczynasz od otwarcia programu Visual Studio i utworzenia nowego projektu. Wybierz szablon „gRPC Service”. Ten szablon daje wszystko, czego potrzebujesz, aby zacząć.

Wykonaj następujące kroki:

1. Otwórz program Visual Studio i wybierz „Create a new project”.
2. Wybierz „gRPC Service” i kliknij Dalej.
3. Nadaj nazwę projektowi i wybierz asp.net core 8.0 lub nowszy.
4. Kliknij Utwórz.

W projekcie zobaczysz przykładową usługę „Greeter”. Usługa korzysta z pliku .proto, aby zdefiniować kontrakt. Możesz edytować ten plik, aby dodać własne metody i komunikaty.

Oto przykład pliku .proto:

syntax = "proto3";

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

message HelloRequest {
  string name = 1;
}

message HelloReply {
  string message = 1;
}

Usługę implementujesz w języku C#. Szablon udostępnia plik GreeterService.cs. Możesz dodać tam swoją logikę.

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

Uruchamiasz projekt asp.net core. Usługa grpc nasłuchuje żądań od klientów. Możesz teraz połączyć aplikacje wpf i asp.net core mvc z tą usługą.

Uwaga: grpc korzysta z protokołu HTTP/2, więc upewnij się, że serwer go obsługuje. Visual Studio robi to za Ciebie, gdy używasz szablonu.

Korzystanie z gRPC w WPF

Możesz połączyć aplikację wpf z usługą grpc. Dzięki temu aplikacja desktopowa może korzystać z tego samego zaplecza co aplikacja webowa. Zaczynasz od dodania pliku .proto do projektu wpf. Ustaw jego akcję kompilacji na „Protobuf”.

Wykonaj poniższe kroki, aby skonfigurować klienta:

1. Zainstaluj pakiety NuGet Grpc.Net.Client i Google.Protobuf.
2. Dodaj plik .proto do projektu.
3. Utwórz kanał grpc w swoim kodzie.

Oto przykładowy fragment kodu:

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

Użyj async i await, aby aplikacja wpf pozostawała responsywna. Metody grpc możesz wywoływać z modeli widoku lub usług. Takie podejście pozwala współdzielić dane i logikę między klientami wpf i asp.net core mvc.

Wskazówka: Modele danych możesz ponownie wykorzystać, umieszczając je w bibliotece współdzielonej. Ułatwia to utrzymanie zgodności projektów wpf i asp.net core mvc.

Masz teraz rozwiązanie, w którym wpf i asp.net core mvc korzystają z grpc do komunikacji z zapleczem. Ta konfiguracja zapewnia szybkość, niezawodność i nowoczesną architekturę.

Kontrakty danych i Protobuf

Kontrakty danych w gRPC definiujesz za pomocą Protocol Buffers, znanych też jako Protobuf. Protobuf pozwala opisać strukturę komunikatów w pliku .proto. Ten plik działa jako kontrakt między klientem a serwerem. Używasz go do wygenerowania klas C#, które rozumieją obie strony.

Gdy dodajesz plik .proto do projektu .NET, musisz go poprawnie skonfigurować. Poniższa tabela przedstawia najważniejsze ustawienia, których używasz:

Pliki .proto warto utrzymywać proste i przejrzyste. Stosuj czytelne nazwy komunikatów i pól. Unikaj słów zastrzeżonych i znaków specjalnych. Jeśli planujesz w przyszłości aktualizować kontrakty, zawsze umieszczaj numery wersji w nazwach komunikatów lub pakietów.

Oto kilka najlepszych praktyk pracy z Protobuf w .NET:

• Umieszczaj pliki .proto we wspólnym folderze lub bibliotece. Dzięki temu kontrakty pozostają zsynchronizowane między projektami WPF, ASP.NET Core i innymi.
• Jeśli chcesz wygenerować kod klienta i serwera z tego samego pliku .proto, użyj opcji Both dla GrpcServices.
• Utrzymuj proste typy danych. W większości pól używaj podstawowych typów, takich jak string, int32 lub bool.
• Dodawaj komentarze do plików .proto. Komentarze pomagają innym programistom zrozumieć kontrakty.

Wskazówka: Po zmianie pliku .proto wygeneruj ponownie kod C# we wszystkich projektach, które go używają. Dzięki temu klient i serwer pozostają zsynchronizowane.

Obsługa błędów i logowanie

Aby aplikacje .NET działały niezawodnie, potrzebujesz solidnej obsługi błędów i logowania. Gdy używasz łącznie WPF, ASP.NET Core i gRPC, warto zastosować kilka kluczowych strategii:

• Skonfiguruj globalne moduły obsługi wyjątków w ASP.NET Core i WPF. Pomoże to wychwytywać błędy, które inaczej mogłyby pozostać niezauważone.
• Stosuj scentralizowane logowanie. Ułatwia to śledzenie problemów i utrzymanie kodu.
• W ASP.NET Core użyj interfejsu IExceptionHandler, aby obsługiwać wyjątki w całej aplikacji.
• W WPF utwórz globalny moduł obsługi wyjątków, który przechwytuje nieobsłużone błędy i zapisuje je w logu.
• Zawsze rejestruj ważne zdarzenia, błędy i ostrzeżenia. Użyj narzędzi takich jak Serilog, NLog lub wbudowanych dostawców logowania.
• Dbaj o to, aby logi zawierały wystarczająco dużo szczegółów, by szybko znajdować i usuwać problemy.

Uwaga: Dobra obsługa błędów i logowanie pozwalają wcześnie wykrywać problemy. Dzięki nim aplikacje łatwiej się wspiera i rozwija z czasem.

Uwierzytelnianie i zabezpieczenia

Zabezpieczanie usług gRPC

Aby chronić dane i użytkowników, musisz zabezpieczyć usługi grpc. Zacznij od użycia HTTPS dla całej komunikacji grpc. Ten krok szyfruje dane przesyłane między klientem a serwerem. Do kontrolowania dostępu użyj również uwierzytelniania i autoryzacji. Konfigurując uwierzytelnianie i autoryzację, decydujesz, kto może wywoływać metody grpc i jakie działania może wykonywać. Do weryfikacji tożsamości każdego klienta możesz użyć certyfikatów lub tokenów. Wielu programistów w tym celu korzysta z tokenów JWT. Zawsze weryfikuj te tokeny po stronie serwera, zanim przetworzysz jakiekolwiek żądanie.

Wskazówka: Użyj autoryzacji opartej na rolach, aby ograniczyć dostęp do wrażliwych metod grpc. Przypisz role użytkownikom i sprawdzaj ich uprawnienia, zanim pozwolisz im wykonać działania.

Uwierzytelnianie w WPF i ASP.NET

Uwierzytelnianie i autoryzację musisz wdrożyć zarówno w aplikacjach WPF, jak i w aplikacjach ASP.NET. W ASP.NET możesz użyć wbudowanego middleware do obsługi uwierzytelniania i autoryzacji. Ten middleware sprawdza poświadczenia użytkownika i egzekwuje reguły autoryzacji dla każdego żądania. Funkcję uwierzytelniania i autoryzacji dodasz, konfigurując usługi w pliku Startup lub Program. W przypadku WPF często łączysz się z zapleczem usługi, które obsługuje uwierzytelnianie i autoryzację. Klient WPF wysyła poświadczenia użytkownika do serwera, który w razie ich poprawności zwraca token. Klient następnie używa tego tokenu w kolejnych żądaniach. Tokeny zawsze przechowuj po stronie klienta w bezpieczny sposób.

Poniższa tabela przedstawia typowe metody uwierzytelniania i autoryzacji:

Uwaga: W aplikacjach WPF zawsze używaj bezpiecznego przechowywania tokenów. Nigdy nie przechowuj wrażliwych danych w postaci jawnego tekstu.

Zarządzanie tokenami

Zarządzanie tokenami musi być starannie zaplanowane, aby zabezpieczyć Twoje aplikacje. Gdy korzystasz z uwierzytelniania i autoryzacji, serwer wystawia token po udanym logowaniu. Klient przechowuje ten token i wysyła go z każdym żądaniem. Aby ograniczyć ryzyko, ustaw czas wygaśnięcia tokenów. Gdy token wygaśnie, klient musi zażądać nowego. W ASP.NET możesz skonfigurować czas życia tokenów oraz logikę ich odświeżania. W przypadku gRPC zawsze sprawdzaj token przed przetworzeniem żądania. Jeśli token jest brakujący lub nieprawidłowy, odmów dostępu zgodnie z regułami autoryzacji.

Tokeny należy także unieważniać, gdy użytkownik się wyloguje lub gdy wykryjesz podejrzaną aktywność. Ten krok zapobiega nieautoryzowanemu dostępowi. Regularnie przeglądaj konfigurację uwierzytelniania i autoryzacji, aby upewnić się, że spełnia Twoje potrzeby w zakresie bezpieczeństwa.

Wskazówka: Zautomatyzuj odnawianie tokenów w klientach, aby sesje pozostawały aktywne bez przerywania pracy użytkownika.

Wdrażanie i utrzymanie

Wdrażanie wielowarstwowe

Rozwiązanie .NET możesz zorganizować, stosując wdrożenie wielowarstwowe. Takie podejście dzieli aplikację na warstwy. Każda warstwa ma określone zadanie. Na przykład możesz mieć warstwę prezentacji dla WPF lub ASP.NET Core MVC, warstwę usług dla komunikacji gRPC oraz warstwę danych dla bazy danych. Taka struktura ułatwia zarządzanie kodem i skalowanie rozwiązania.

Typowa konfiguracja wielowarstwowa wygląda następująco:

Każdą warstwę wdrażasz na innych serwerach lub w innych kontenerach. Taki podział poprawia bezpieczeństwo i wydajność. Możesz aktualizować jedną warstwę bez wpływu na pozostałe.

Wskazówka: Użyj gRPC w warstwie usług, aby szybko i niezawodnie połączyć warstwę prezentacji z warstwą danych.

Potoki CI/CD

Proces budowania i wdrażania możesz zautomatyzować, korzystając z potoków CI/CD. CI oznacza ciągłą integrację (Continuous Integration), a CD – ciągłe wdrażanie (Continuous Deployment). Te potoki pomagają szybciej dostarczać aktualizacje i ograniczać liczbę błędów.

Główne etapy potoku CI/CD są następujące:

1. Wysyłasz kod do systemu kontroli źródła, takiego jak GitHub lub Azure DevOps.
2. Potok buduje aplikację i uruchamia testy.
3. Jeśli testy zakończą się powodzeniem, potok wdraża aplikację w środowisku testowym lub produkcyjnym.

Możesz korzystać z narzędzi takich jak GitHub Actions, Azure Pipelines lub GitLab CI. Obsługują one projekty .NET, ASP.NET Core i gRPC. Możesz skonfigurować automatyczne wdrażanie usług WPF, aplikacji webowych i usług gRPC.

Uwaga: Potoki CI/CD pomagają wcześnie wykrywać problemy. Jeśli coś pójdzie nie tak, możesz cofnąć zmiany.

Monitorowanie i aktualizacje

Aplikacje należy monitorować, aby działały prawidłowo. Narzędzia do monitorowania śledzą błędy, wydajność i wykorzystanie. Możesz użyć Application Insights, Prometheus lub Grafana. Narzędzia te współpracują z usługami .NET, ASP.NET Core i gRPC.

Warto skonfigurować alerty dla ważnych zdarzeń. Na przykład możesz otrzymać wiadomość, gdy usługa gRPC przestanie działać lub aplikacja webowa zacznie zwalniać. Regularne aktualizacje utrzymują system w bezpiecznym i szybkim stanie. Należy regularnie łatać serwery, aktualizować biblioteki i przeglądać dzienniki zdarzeń.

Prosta lista kontrolna konserwacji:

• Monitoruj wszystkie usługi, w tym punkty końcowe gRPC.
• Skonfiguruj alerty dotyczące błędów i spowolnień.
• Aktualizuj środowisko uruchomieniowe .NET oraz biblioteki.
• Przeglądaj dzienniki i szybko usuwaj problemy.

Wskazówka: Planuj regularne okna serwisowe. Dzięki temu zastosujesz aktualizacje bez zakłócania pracy użytkowników.

Najlepsze praktyki i kolejne kroki

Wzorce projektowe

Projekty .NET ulepszysz, stosując sprawdzone wzorce projektowe. Pomagają one pisać kod łatwy do zrozumienia, testowania i utrzymania. We współczesnym programowaniu w .NET często używa się wzorców takich jak Dependency Injection, Repository oraz MVVM (Model-View-ViewModel).

• Dependency Injection pozwala zarządzać zależnościami między klasami. Rejestrujesz usługi w kodzie startowym i wstrzykujesz je tam, gdzie są potrzebne. Ten wzorzec sprawia, że kod jest elastyczny i łatwy do testowania.
• Repository Pattern oddziela logikę dostępu do danych od logiki biznesowej. Tworzysz klasy repozytoriów, które obsługują operacje na bazie danych. Dzięki temu kod pozostaje uporządkowany.
• MVVM dobrze sprawdza się w aplikacjach WPF. Oddzielasz interfejs użytkownika, logikę biznesową i modele danych. Ten wzorzec pomaga tworzyć responsywne i łatwe w utrzymaniu aplikacje desktopowe.

Wskazówka: Podcast The Modern .NET Development Podcast na m365.fm często pokazuje, jak te wzorce pomagają skalować rozwiązania i przygotowywać się na przyszłe zmiany.

Strategie testowania

Aby dostarczać niezawodne oprogramowanie, potrzebujesz solidnych strategii testowania. Testy pozwalają wcześnie wykrywać błędy i potwierdzać, że kod działa zgodnie z oczekiwaniami. W środowisku .NET używasz różnych typów testów:

Testy jednostkowe piszesz dla logiki biznesowej. Testy integracyjne wykorzystujesz do sprawdzania, jak współpracują usługi i bazy danych. W przypadku aplikacji WPF i webowych dodajesz testy interfejsu użytkownika, aby doświadczenie użytkownika pozostawało płynne.

• Stosuj programowanie sterowane testami (TDD), czyli pisz testy przed kodem.
• Automatyzuj testy w potokach CI/CD, aby szybko otrzymywać informacje zwrotne.
• Izoluj testy, stosując atrapy (mocki) zależności.

Uwaga: Zautomatyzowane testowanie oszczędza czas i ogranicza liczbę błędów podczas aktualizacji.

Dokumentacja i współpraca

Projekty utrzymujesz w dobrej kondycji, pisząc przejrzystą dokumentację i dobrze współpracując z zespołem. Dobra dokumentacja pomaga nowym programistom zrozumieć kod. Ułatwia też jego utrzymanie i rozbudowę aplikacji.

• Pisz pliki README, które wyjaśniają cel projektu i kroki konfiguracji.
• Używaj komentarzy XML w kodzie, aby opisywać klasy i metody.
• Twórz dokumentację API za pomocą narzędzi takich jak Swagger dla ASP.NET Core.

Lepiej współpracujesz, korzystając z systemów kontroli wersji, takich jak Git. Śledzisz zmiany, przeglądasz kod i rozwiązujesz konflikty jako zespół. Umiejętności komunikacyjne są równie ważne jak techniczne. Podcast The Modern .NET Development Podcast często omawia, jak dobra komunikacja i przejrzysta dokumentacja pomagają zespołom odnosić sukcesy, zwłaszcza gdy narzędzia AI stają się w programowaniu coraz powszechniejsze.

Wskazówka: Planuj regularne przeglądy kodu i dziel się wiedzą z zespołem. Takie podejście prowadzi do lepszego kodu i silniejszego zespołu.

Materiały do nauki

Umiejętności w .NET możesz rozwijać, korzystając z różnorodnych materiałów edukacyjnych. Ekosystem .NET zmienia się szybko, dlatego musisz na bieżąco śledzić nowe narzędzia, frameworki i dobre praktyki. Oto kilka najlepszych źródeł, które pomagają utrzymać wiedzę na bieżąco i w praktycznej formie.

📚 Polecane podcasty i programy

• Modern .NET Development Podcast (m365.fm)
  Słuchaj Mirko Petersa i Microsoft MVP Gábora Ruzsinszkiego, którzy omawiają praktyczne zagadnienia związane z .NET. Otrzymujesz eksperckie porady dotyczące WPF, ASP.NET Core, gRPC i nie tylko. Podcast obejmuje AI w programowaniu, umiejętności komunikacyjne oraz przyszłe funkcje .NET.

  Wskazówka: Zasubskrybuj The Modern .NET Development Podcast na ulubionej platformie, aby otrzymywać regularne aktualizacje.

• .NET Rocks!
  Ten program zawiera wywiady z liderami branży. Dowiesz się o nowych trendach, narzędziach i technikach w .NET.

📖 Oficjalna dokumentacja i przewodniki

• Microsoft Learn for .NET
  Znajdziesz instrukcje krok po kroku, przykłady kodu i interaktywne lekcje. Microsoft Learn pomoże Ci opanować wszystko, od WPF po ASP.NET Core i gRPC.

• Dokumentacja ASP.NET Core
  Otrzymujesz szczegółowe przewodniki dotyczące tworzenia aplikacji webowych, interfejsów API i bezpiecznych rozwiązań.

• Dokumentacja gRPC for .NET
  Ten materiał wyjaśnia, jak konfigurować, używać i testować usługi gRPC w .NET.

🛠️ Społeczność i platformy interaktywne

• Stack Overflow
  Możesz zadawać pytania i otrzymywać odpowiedzi od doświadczonych programistów .NET. Szukaj gotowych rozwiązań lub dziel się własną wiedzą.

• GitHub
  Poznawaj projekty open source w .NET. Możesz czytać kod, wnosić wkład w repozytoria i uczyć się na przykładach z życia wziętych.

• Microsoft Q&A
  To forum pozwala nawiązać kontakt z inżynierami Microsoft i społecznością .NET.

📅 Konferencje i wydarzenia online

• .NET Conf
  Możesz oglądać sesje na żywo i warsztaty. Poznasz najnowsze wydania i funkcje .NET.

• Lokalne spotkania
  Dołącz do grup użytkowników .NET w swojej okolicy. Poznaj innych programistów, dziel się doświadczeniami i wspólnie pracuj nad projektami.

📝 Tabela: Szybki przegląd materiałów edukacyjnych

Uwaga: Warto co tydzień poświęcić czas na poznawanie nowych zasobów. Ciągła nauka pomaga być na bieżąco w nowoczesnym programowaniu w .NET.

Możesz połączyć te zasoby, aby zbudować solidne fundamenty. Testuj nowe narzędzia, korzystaj z rad ekspertów i dołącz do społeczności .NET. Dzięki temu rozwiniesz swoje umiejętności, a Twoje projekty pozostaną nowoczesne i wydajne.

Poznałeś, jak połączyć WPF, ASP.NET i gRPC w nowoczesnym programowaniu w .NET. Zobaczyłeś praktyczne kroki dotyczące migracji, integracji i bezpieczeństwa. Za pomocą gRPC możesz budować szybką komunikację między aplikacjami desktopowymi i webowymi. Ulepszysz swoje projekty, stosując najlepsze praktyki z odcinka Modern .NET: WPF, ASP.NET Core, and gRPC with Gábor Ruzsinszki [MVP]. Warto wypróbować gRPC w swoim następnym rozwiązaniu. Więcej porad eksperckich znajdziesz na m365.fm.

Dołącz do społeczności .NET i eksperymentuj z przykładowymi projektami, aby rozwijać swoje umiejętności.

Często zadawane pytania

Jaka jest główna zaleta korzystania z WPF w aplikacjach desktopowych?

Dzięki WPF możesz tworzyć bogate i responsywne interfejsy użytkownika. Platforma obsługuje zaawansowaną grafikę i powiązania danych. Szybko i efektywnie projektujesz aplikacje desktopowe klasy enterprise.

W jaki sposób ASP.NET Core usprawnia tworzenie aplikacji webowych?

ASP.NET Core zapewnia obsługę wielu platform i wysoką wydajność. Platforma pozwala tworzyć bezpieczne aplikacje webowe i interfejsy API. Wdrażasz swoje rozwiązania w systemach Windows, Linux lub macOS.

Dlaczego warto używać gRPC do komunikacji między usługami?

Dzięki gRPC osiągasz szybką i niezawodną komunikację między usługami. Platforma wykorzystuje HTTP/2 i Protocol Buffers. Zmniejszasz opóźnienia i poprawiasz skalowalność swoich aplikacji.

Czy można połączyć WPF i ASP.NET Core za pomocą gRPC?

Integrujesz WPF i ASP.NET Core, korzystając z gRPC. Platforma umożliwia współdzielenie danych i logiki biznesowej między aplikacjami desktopowymi i webowymi. Tworzysz spójne rozwiązania odpowiadające nowoczesnym potrzebom biznesu.

Jakich narzędzi użyć do migracji starszych aplikacji .NET?

Do migracji używasz .NET Upgrade Assistant oraz Visual Studio. Narzędzia te analizują kod i prowadzą Cię przez proces aktualizacji. Modernizujesz aplikacje z mniejszym nakładem pracy.

Jak zabezpieczyć usługi ASP.NET Core i gRPC?

Chronisz usługi, włączając HTTPS i stosując tokeny uwierzytelniania. Wdrażasz autoryzację opartą na rolach, aby kontrolować dostęp. Dbasz o bezpieczeństwo danych i użytkowników.

Gdzie szukać eksperckich porad dotyczących nowoczesnego programowania w .NET?

Posłuchaj podcastu Modern .NET Development Podcast na m365.fm. Podcast zawiera przykłady z życia wzięte i praktyczne wskazówki. Uczysz się od ekspertów branżowych i jesteś na bieżąco z nowymi technologiami.

🎧 Posłuchaj tego odcinka

Chcesz praktycznego wyjaśnienia, czym jest Modern .NET? Ten odcinek przedstawia temat jasnym językiem i pokazuje, dlaczego ma znaczenie dla Microsoft 365, Azure, Power Platform, bezpieczeństwa, AI i nowoczesnej pracy.

Posłuchaj tego odcinka, jeśli chcesz:

• Zrozumieć kluczowe koncepcje stojące za Modern .NET
• Zobaczyć, jak ten temat wpisuje się w szerszy ekosystem technologii Microsoft
• Dowiedzieć się, gdzie może przynieść praktyczną wartość Twojej organizacji

Możesz też polubić te powiązane odcinki M365 FM:

• LINQ to SQL kontra EF Core w dostępie do danych w .NET
• Rozszerzalność w .NET i czysta architektura z Miguelem Castro [MVP]
• Modern Microsoft 365 Automation Beyond PowerShell Scripts
• Build AI Applications with .NET 10
• Improve Entity Framework Core Query Performance

Więcej praktycznych rozmów o Microsoft 365 znajdziesz na M365 FM.