Collegare i punti: integrare WPF, ASP.NET Core e gRPC

By Mirko Peters · 2026-08-13

Introduzione allo sviluppo moderno con .NET Vantaggi e sfide dell'integrazione Vantaggi e sfide Introduzione allo sviluppo moderno con .NET Vantaggi e sfide dell'integrazione Vantaggi e sfide Vantaggi e sfide

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

Introduzione allo sviluppo moderno con .NET: integrazione

Vantaggi e sfide

Integrare WPF, ASP.NET Core MVC e gRPC nei tuoi progetti porta molti vantaggi. Questo approccio ti offre una soluzione unificata per la comunicazione tra desktop, web e servizi. Il podcast Modern .NET Development di m365.fm, condotto da Mirko Peters e con la partecipazione dell'MVP Microsoft Gábor Ruzsinszki, mette spesso in evidenza come questa integrazione aiuti a costruire applicazioni moderne e scalabili.

Ecco una tabella che mostra i principali vantaggi della combinazione di queste tecnologie:

Ci sono anche alcune sfide. Devi gestire la sincronizzazione dei dati tra WPF e ASP.NET Core MVC. Devi garantire un'esperienza utente coerente tra desktop e web. Sicurezza e autenticazione diventano più complesse quando usi gRPC su ASP.NET Core per la comunicazione tra servizi. Devi inoltre gestire il versionamento e gli aggiornamenti di ciascuna parte della soluzione.

Suggerimento: puoi usare librerie condivise per mantenere coerente la logica di business in WPF, ASP.NET Core MVC e gRPC su ASP.NET Core. Questo riduce la duplicazione del codice e ti aiuta a mantenere la soluzione.

Scenari reali

Dagli esempi concreti si impara molto. Molte organizzazioni hanno migrato applicazioni WPF legacy verso ASP.NET Core MVC e gRPC su ASP.NET Core. Queste migrazioni mostrano come modernizzare il software e migliorarne le prestazioni.

Ecco una tabella con alcuni esempi:

Potresti partire da un'applicazione desktop WPF su cui i tuoi utenti contano ogni giorno. Vuoi raggiungere più utenti, quindi crei una versione web con ASP.NET Core MVC. Usi gRPC su ASP.NET Core per collegare le app desktop e web a servizi di backend condivisi. Questa architettura ti permette di riutilizzare la logica di business e mantenere i dati sincronizzati.

Puoi usare gRPC anche per collegare i microservizi della soluzione. gRPC su ASP.NET Core offre una comunicazione rapida e affidabile tra i servizi. È importante quando servono aggiornamenti in tempo reale o prestazioni elevate.

Quando segui questi pattern di integrazione, crei soluzioni flessibili e pronte per il futuro. Puoi aggiungere nuove funzionalità, supportare più piattaforme e scalare le applicazioni man mano che crescono le esigenze.

Evoluzione e modernizzazione di .NET

Da .NET Framework a .NET Core

Hai visto come .NET sia cambiato molto negli anni. Il passaggio da .NET Framework a .NET Core ha portato grandi miglioramenti per sviluppatori e aziende. Quando usi .NET 6 o .NET 7, le tue applicazioni girano più velocemente e consumano meno memoria delle versioni precedenti. Noti un throughput migliore e tempi di esecuzione più brevi, utili quando sviluppi applicazioni web con molto traffico. Motori di esecuzione ottimizzati e nuove funzionalità del runtime rendono il codice più efficiente. Ogni nuova versione porta più velocità e una gestione della memoria migliore. Puoi inoltre distribuire le app su sistemi operativi diversi, il che semplifica il lavoro.

Ecco una tabella che mostra le differenze principali in termini di distribuzione e manutenzione tra .NET Framework e .NET Core:

Multipiattaforma e cloud-native

Ora puoi creare ed eseguire applicazioni .NET su Windows, Linux e macOS. Questa flessibilità multipiattaforma ti offre più scelte per la distribuzione. Puoi usare microservizi e container per suddividere le applicazioni in parti più piccole. Questo rende più semplice scalare e aggiornare le soluzioni. L'integrazione profonda con Azure ti permette di usare strumenti e servizi pensati per gli sviluppatori .NET. Puoi anche usare il calcolo serverless con Azure Functions, il che significa concentrarti sul codice invece che sulla gestione dei server. Queste funzionalità ti aiutano a creare app ad alte prestazioni e scalabili che funzionano bene nel cloud. L'ecosistema di sviluppatori solido e gli strumenti moderni rendono il tuo lavoro più rapido e affidabile.

Modernizzare le app legacy

Potresti avere applicazioni legacy che necessitano di aggiornamenti per restare utili e sicure. Modernizzare le applicazioni legacy inizia con un piano chiaro. Per prima cosa, elenca tutte le dipendenze, come librerie di terze parti e DLL interne. Poi, cerca vecchi pattern come le pagine WebForms o Forms Authentication. Controlla la qualità del codice e individua le parti fortemente accoppiate o le API obsolete. Quindi, decidi se riscrivere parti dell'app o sostituire le librerie datate. Passa alle moderne tecnologie ASP.NET come Razor Pages o ASP.NET Core MVC. Adotta nuove pratiche come dependency injection, test automatizzati e pipeline CI/CD. Usa strumenti come .NET Upgrade Assistant per aiutarti nel processo.

Modernizzare le applicazioni legacy può richiedere tempo e risorse. Per una singola app aziendale con 50.000 a 100.000 righe di codice, potresti impiegare da quattro a sei mesi. I costi variano spesso da 100.000 $ a 1 milione di $, con una mediana di circa 180.000 $. Se gestisci un portfolio di applicazioni legacy con molte app, il processo può durare da due a tre anni, suddiviso in progetti più piccoli. Ottieni prestazioni, sicurezza e manutenzione più semplice quando modernizzi i sistemi legacy.

Modernizzare le applicazioni desktop WPF

WPF nello sviluppo enterprise

Usi WPF per creare rapidamente applicazioni desktop. Visual Studio ti offre strumenti per progettare e scrivere codice con facilità. Molte organizzazioni scelgono WPF perché semplifica la distribuzione. Puoi distribuire le app tramite unità condivise o programmi di installazione ClickOnce. Questo rende WPF un'opzione preferita per gli strumenti interni e la prototipazione rapida.

WPF dà il meglio quando servono prestazioni grafiche elevate e reattività. Con WPF gestisci grandi set di dati o visualizzazioni complesse. Si distingue come valida alternativa alle tecnologie basate sul web.

Microsoft continua a sviluppare WPF. Trovi nuove funzionalità come l'accelerazione hardware e il tema Fluent per un'interfaccia utente moderna. WPF si adatta alle applicazioni line-of-business critiche in molti settori. WPF è presente in circa 500.000 a 1.000.000 di applicazioni attivamente sviluppate in tutto il mondo. Con WPF crei e distribuisci app rapidamente, con una configurazione più semplice rispetto ad altri stack tecnologici.

Strategie di migrazione

Spesso devi modernizzare applicazioni legacy Windows Presentation Foundation. Vuoi modernizzare le applicazioni desktop WPF per sfruttare le nuove funzionalità di .NET.

Migrazione a .NET Core/5+/6+/8+

Inizi facendo il backup dei progetti. Installi .NET Upgrade Assistant. Fai clic destro sul progetto in Esplora soluzioni e selezioni Aggiorna. Scegli tra aggiornamento in-place o side-by-side. Selezioni il framework di destinazione e i componenti da aggiornare.

Prepari l'ambiente con Visual Studio 2019 e .NET Core 3.0. Verifichi la compatibilità delle API con .NET Portability Analyzer. Crei un nuovo file .csproj per il progetto. Specifichi il nome dell'assembly e lo spazio dei nomi predefinito. Disattivi la generazione automatica di AssemblyInfo.

Gli strumenti che usi per la migrazione includono:

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

Uno Platform per il cross-platform

Modernizzi WPF esplorando soluzioni cross-platform. Uno Platform ti permette di eseguire app simili a WPF su Windows, Linux, macOS, iOS, Android e WebAssembly. Riutilizzi la logica di business e i componenti UI. Raggiungi più utenti e dispositivi con meno sforzo. Uno Platform aiuta a modernizzare le app desktop per un pubblico più ampio.

Integrazione con ASP.NET e gRPC

Modernizzi le applicazioni desktop WPF collegandole a tecnologie web e di servizi. Usi ASP.NET Core per creare API web e interfacce utente. Usi gRPC per una comunicazione veloce e affidabile tra l'app desktop e i servizi backend. Condividi la logica di business tra WPF, ASP.NET e gRPC. Mantieni i dati sincronizzati e migliori le prestazioni. Modernizzi il flusso di lavoro integrando WPF con gli stack web e di servizi moderni.

ASP.NET Core MVC per app web

Panoramica di ASP.NET Core

Usi ASP.NET Core MVC per creare applicazioni web moderne, veloci, sicure e facili da manutenere. Questo framework ti offre un modo unificato per creare sia interfacce utente web sia API. Puoi eseguire l'applicazione ASP.NET Core su Windows, Linux o macOS. La natura cross-platform di ASP.NET Core significa che puoi distribuire le app in molti ambienti, cloud compreso.

Ecco una tabella che mostra le funzionalità principali che rendono ASP.NET Core MVC una scelta solida per lo sviluppo web:

Inizi a usare ASP.NET Core installando il .NET SDK e configurando il primo progetto. La procedura di configurazione di ASP.NET Core è semplice e ben documentata. Puoi usare Visual Studio o la riga di comando per creare il tuo progetto ASP.NET Core MVC.

Creazione di API

Crei API con ASP.NET Core MVC per collegare le tue app web, le app mobile e i client desktop. Il framework supporta la progettazione RESTful, che ti aiuta a organizzare endpoint e modelli di dati. Puoi usare i controller per gestire le richieste e restituire dati in formato JSON. In questo modo è semplice per altre applicazioni utilizzare la tua API.

Per creare API scalabili e facili da manutenere, dovresti seguire queste best practice:

• Struttura il progetto usando la Clean Architecture. Organizza il codice con Controller, Service, Repository e Model o DTO.
• Usa Async e Await per le operazioni di I/O. Questo migliora le prestazioni e permette all'app di gestire più utenti contemporaneamente.
• Aggiungi una gestione globale delle eccezioni con middleware. Questo ti aiuta a gestire gli errori in un unico punto.
• Abilita il versionamento delle API. Questo mantiene le tue API compatibili con client diversi.
• Usa il logging per tracciare errori e azioni importanti.

Puoi collegare le API ASP.NET Core MVC ad altri servizi, come i client gRPC o WPF. Questo ti permette di creare soluzioni potenti che funzionano su più piattaforme.

Sicurezza e autenticazione

Proteggi la tua applicazione ASP.NET Core sfruttando le funzionalità di sicurezza integrate. Il framework protegge da minacce comuni come CSRF, XSS e SQL injection. Puoi aggiungere autenticazione e autorizzazione per controllare chi può accedere alle tue API. Molti sviluppatori usano i token JWT per proteggere gli endpoint e tutelare i dati sensibili.

Dovresti tenere sempre aggiornata la tua applicazione ASP.NET Core. Gli aggiornamenti regolari ti aiutano a correggere i problemi di sicurezza e a migliorare le prestazioni. Puoi inoltre usare il middleware per gestire autenticazione e autorizzazione in tutta l'app.

Suggerimento: proteggi le tue API con un'autenticazione solida e mantieni aggiornate le dipendenze. Questo ti aiuta a creare applicazioni web sicure e affidabili.

Opzioni di distribuzione

Esistono molti modi per distribuire le tue applicazioni ASP.NET Core MVC. Ogni opzione offre vantaggi diversi. Dovresti scegliere quella più adatta alle esigenze del progetto e alle competenze del tuo team.

1. Distribuzione locale (on-premises)

Puoi distribuire l'app sui tuoi server. Questo metodo ti offre il pieno controllo dell'ambiente. Su Windows installi IIS (Internet Information Services), mentre su Linux usi Kestrel con un reverse proxy come Nginx o Apache. Gestisci tu stesso aggiornamenti, sicurezza e scalabilità.

Suggerimento: usa Kestrel per ottenere prestazioni elevate. Abbinalo a Nginx o Apache per gestire HTTPS e il bilanciamento del carico.

2. Distribuzione nel cloud

Puoi distribuire l'app nel cloud. Le scelte più diffuse includono Microsoft Azure, Amazon Web Services (AWS) e Google Cloud Platform (GCP). Le piattaforme cloud offrono scalabilità semplice, alta disponibilità e servizi gestiti.

Puoi usare Azure App Service per distribuire l'app con pochi clic. Carichi il codice e Azure si occupa del resto. Puoi inoltre usare Azure DevOps per le distribuzioni automatizzate.

3. Containerizzazione con Docker

Puoi impacchettare l'app in un container Docker. Questo metodo rende l'app portabile e facile da distribuire ovunque. Scrivi un Dockerfile semplice per definire l'ambiente dell'app.

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

Crei ed esegui il container in locale, poi lo carichi in un registro dei container. Puoi distribuire i container su Kubernetes o su servizi cloud come Azure Kubernetes Service (AKS).

4. Integrazione continua e distribuzione continua (CI/CD)

Puoi automatizzare il processo di distribuzione con pipeline CI/CD. Strumenti come GitHub Actions, Azure DevOps e GitLab CI ti aiutano a compilare, testare e distribuire l'app automaticamente.

Nota: CI/CD riduce gli errori e accelera il ciclo di rilascio. Puoi ripristinare rapidamente le modifiche se qualcosa va storto.

5. Hosting multipiattaforma

Puoi ospitare le applicazioni ASP.NET Core MVC su Windows, Linux o macOS. Questa flessibilità ti permette di scegliere l'ambiente migliore per le tue esigenze.

Tabella riepilogativa: opzioni di distribuzione

Dovresti valutare i requisiti prima di scegliere un metodo di distribuzione. Ogni opzione ha i suoi punti di forza. Puoi combinarle per ottenere risultati ancora migliori. Ad esempio, puoi usare i container nel cloud con pipeline CI/CD per distribuzioni rapide e affidabili.

gRPC in .NET

Cos'è gRPC

Usi grpc per creare una comunicazione rapida e affidabile tra le tue applicazioni. grpc sta per Google Remote Procedure Call. È un framework open source che ti permette di richiamare metodi su un server da un client come se fossero locali. Puoi usare grpc per scenari di chiamate di procedura remota ad alte prestazioni. Questo significa che invii e ricevi dati rapidamente, anche quando le app girano su macchine diverse.

grpc usa Protocol Buffers, un modo di serializzare i dati indipendente da linguaggio e piattaforma. Definisci i contratti dei servizi in un file .proto. Questo file descrive i messaggi e i servizi che vuoi usare. Da questo file generi il codice per client e server. Puoi usare grpc in molti tipi di applicazioni, tra cui app desktop WPF, applicazioni web ASP.NET e servizi cloud.

gRPC vs REST

Ti sarai chiesto come si confronta gRPC con REST. REST usa HTTP e JSON per scambiare dati tra client e server. gRPC usa HTTP/2 e Protocol Buffers. Questo offre prestazioni migliori, perché HTTP/2 supporta il multiplexing e lo streaming. I Protocol Buffers generano messaggi più piccoli di JSON, quindi i dati viaggiano più velocemente.

Ecco una tabella che ti aiuta a confrontare gRPC e REST:

Scegli gRPC quando ti servono sistemi altamente scalabili o comunicazione in tempo reale. Usi REST quando vuoi API semplici che funzionano con i browser. Molti sviluppatori usano entrambi nella stessa soluzione.

Configurare i servizi gRPC

Configurare i servizi gRPC in .NET richiede pochi passaggi. Per prima cosa crei un nuovo progetto in Visual Studio o con la .NET CLI. Selezioni il modello « gRPC Service ». Questo modello ti fornisce un file .proto di esempio e il codice per avviare il servizio.

Definisci il servizio e i messaggi nel file .proto. Ad esempio:

syntax = "proto3";

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

message HelloRequest {
  string name = 1;
}

message HelloReply {
  string message = 1;
}

Compila il progetto. Gli strumenti generano le classi C# per il client e il server gRPC. Implementi la logica del servizio in C#. Puoi ospitare i servizi gRPC in asp.net core o persino all'interno di un'app WPF per scenari avanzati.

Per testare i servizi gRPC usi strumenti come grpc-dotnet, Grpc.Net.Client e Grpc.AspNetCore.Server. Queste librerie ti aiutano a creare, ospitare e consumare servizi gRPC in .NET. Puoi anche usare FINT per testare gli endpoint gRPC.

Colleghi il client WPF o l'app ASP.NET al servizio gRPC aggiungendo il codice client generato. In questo modo le app comunicano tra loro in modo rapido e sicuro. Puoi passare da tecnologie meno recenti come WCF a gRPC per ottenere una soluzione moderna e scalabile.

Suggerimento: usa gRPC quando ti serve una comunicazione veloce, affidabile e altamente scalabile tra le tue applicazioni .NET.

Consumare gRPC in WPF e ASP.NET

Puoi collegare le tue applicazioni WPF e ASP.NET Core ai servizi gRPC. In questo modo condividi dati e logica di business tra app desktop e web. Ottieni una comunicazione veloce e affidabile che funziona bene per le soluzioni moderne.

Integrazione del client WPF

Puoi aggiungere gRPC alla tua app desktop WPF. Inizia installando il pacchetto NuGet Grpc.Net.Client. Questo pacchetto ti offre gli strumenti per richiamare i servizi gRPC dal tuo progetto WPF.

Segui questi passaggi per configurare un client gRPC in WPF:

1. Aggiungi il file .proto
   Inserisci il file .proto del tuo servizio gRPC nel progetto WPF. Imposta la sua azione di compilazione su « Protobuf » nel file di progetto.

2. Installa i pacchetti NuGet
   Apri Gestione pacchetti NuGet. Installa Grpc.Net.Client e Google.Protobuf.

3. Configura il client gRPC
   Crea un canale e un client nel codice. Ad esempio:

   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. Gestisci il threading
   Usa async e await per mantenere reattiva l'interfaccia utente. Non bloccare il thread principale.

Suggerimento: puoi condividere i modelli dati tra i progetti WPF e ASP.NET Core usando librerie condivise. Il codice resta così pulito e coerente.

Integrazione del client ASP.NET

Puoi usare i client gRPC anche nelle applicazioni ASP.NET Core. È utile quando la tua web app deve richiamare altri servizi, come microservizi o API di backend.

Ecco come configurare un client gRPC in ASP.NET Core:

1. Aggiungi il file .proto
   Includi il file .proto nel progetto ASP.NET Core. Imposta la sua azione di compilazione su « Protobuf ».

2. Installa i pacchetti NuGet
   Aggiungi Grpc.Net.ClientFactory e Google.Protobuf tramite NuGet.

3. Registra il client gRPC
   In Startup.cs o Program.cs, registra il client con la dependency injection:

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

4. Inietta e usa il client
   Inietta il client nel controller o nel servizio:

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

Nota: puoi usare i client gRPC nei servizi in background, nei controller o in qualsiasi parte della tua app ASP.NET Core.

Ora puoi collegare le tue app WPF e ASP.NET Core allo stesso backend gRPC. Questo ti offre una soluzione unificata e ad alte prestazioni per le esigenze del business.

Esempio pratico di integrazione

Architettura della soluzione

Puoi creare una soluzione moderna collegando WPF, ASP.NET Core MVC e gRPC. Questa architettura ti aiuta a offrire un'esperienza fluida tra desktop e web. Parti da un'applicazione desktop WPF. Aggiungi ASP.NET Core MVC per l'interfaccia web. Usi gRPC per collegare entrambi i client ai tuoi servizi di backend.

Ecco un semplice diagramma che ti aiuta a capire la struttura:

Puoi usare questa configurazione in molti scenari. Ad esempio, puoi modernizzare un'app WPF legacy aggiungendo ASP.NET Core MVC e gRPC. Puoi anche creare nuove soluzioni che richiedono sia client desktop sia client web. Questa architettura funziona bene per i microservizi perché gRPC supporta comunicazioni ad alta velocità.

Suggerimento: puoi condividere la logica di business tra WPF, ASP.NET Core MVC e ASP.NET Core usando librerie condivise. Così il codice resta pulito e si riduce la duplicazione.

Creazione di un servizio gRPC in ASP.NET Core

Puoi creare un semplice servizio gRPC in ASP.NET Core. Questo servizio permetterà ai tuoi client WPF e ASP.NET Core MVC di comunicare con il backend. Inizia aprendo Visual Studio e creando un nuovo progetto. Scegli il modello "gRPC Service". Questo modello ti fornisce tutto ciò che serve per iniziare.

Segui questi passaggi:

1. Apri Visual Studio e seleziona "Crea un nuovo progetto".
2. Scegli "gRPC Service" e fai clic su Avanti.
3. Assegna un nome al progetto e seleziona ASP.NET Core 8.0 o versione successiva.
4. Fai clic su Crea.

Nel progetto vedrai un servizio di esempio "Greeter". Il servizio usa un file .proto per definire il contratto. Puoi modificare questo file per aggiungere i tuoi metodi e messaggi.

Ecco un esempio di file .proto:

syntax = "proto3";

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

message HelloRequest {
  string name = 1;
}

message HelloReply {
  string message = 1;
}

Implementi il servizio in C#. Il modello ti fornisce il file GreeterService.cs. Puoi aggiungere lì la tua logica.

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

Avvii il progetto ASP.NET Core. Il servizio gRPC resta in ascolto delle richieste dei client. Ora puoi collegare le tue app WPF e ASP.NET Core MVC a questo servizio.

Nota: gRPC usa HTTP/2, quindi assicurati che il server lo supporti. Visual Studio se ne occupa per te quando usi il modello.

Consumo di gRPC in WPF

Puoi collegare la tua applicazione WPF al servizio gRPC. In questo modo l'app desktop usa lo stesso backend dell'app web. Inizia aggiungendo il file .proto al progetto WPF. Imposta la sua azione di compilazione su "Protobuf".

Segui questi passaggi per configurare il client:

1. Installa i pacchetti NuGet Grpc.Net.Client e Google.Protobuf.
2. Aggiungi il file .proto al progetto.
3. Crea un canale gRPC nel codice.

Ecco un esempio di frammento di codice:

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

Usi async e await per mantenere reattiva l'app WPF. Puoi chiamare i metodi gRPC dai tuoi view model o dai servizi. Questo approccio ti permette di condividere dati e logica tra i client WPF e ASP.NET Core MVC.

Suggerimento: puoi riutilizzare i modelli di dati inserendoli in una libreria condivisa. Così è più facile mantenere sincronizzati i progetti WPF e ASP.NET Core MVC.

Ora hai una soluzione in cui WPF e ASP.NET Core MVC usano entrambi gRPC per comunicare con il backend. Questa configurazione ti offre velocità, affidabilità e un'architettura moderna.

Contratti di dati e Protobuf

Definisci i contratti di dati in gRPC usando i Protocol Buffers, noti anche come Protobuf. Protobuf ti permette di descrivere la struttura dei messaggi in un file .proto. Questo file funge da contratto tra client e server. Lo usi per generare classi C# che entrambe le parti comprendono.

Quando aggiungi un file .proto al progetto .NET, devi configurarlo correttamente. La tabella seguente mostra le impostazioni principali che usi:

Conviene mantenere i file .proto semplici e chiari. Usa nomi chiari per messaggi e campi. Evita parole riservate e caratteri speciali. Inserisci sempre numeri di versione nei nomi dei messaggi o dei package se prevedi di aggiornare i contratti in futuro.

Ecco alcune best practice per lavorare con Protobuf in .NET:

• Conserva i file .proto in una cartella o libreria condivisa. Questo ti aiuta a mantenere i contratti sincronizzati tra WPF, ASP.NET Core e gli altri progetti.
• Usa l'opzione Both per GrpcServices se vuoi generare sia il codice client sia quello server dallo stesso file .proto.
• Mantieni semplici i tipi di dati. Per la maggior parte dei campi usa tipi di base come string, int32 o bool.
• Aggiungi commenti ai file .proto. I commenti aiutano gli altri sviluppatori a capire i tuoi contratti.

Suggerimento: quando aggiorni un file .proto, assicurati di rigenerare il codice C# in tutti i progetti che lo usano. In questo modo client e server restano sincronizzati.

Gestione degli errori e logging

Per mantenere affidabili le tue applicazioni .NET ti servono una gestione degli errori e un logging solidi. Quando usi insieme WPF, ASP.NET Core e gRPC, dovresti seguire alcune strategie chiave:

• Configura gestori globali delle eccezioni sia in ASP.NET Core sia in WPF. Questo ti aiuta a intercettare errori che altrimenti potrebbero passare inosservati.
• Usa un logging centralizzato. Questo rende più facile individuare i problemi e mantenere il codice.
• In ASP.NET Core, usa l'interfaccia IExceptionHandler per gestire le eccezioni in tutta l'app.
• In WPF, crea un gestore globale delle eccezioni per intercettare gli errori non gestiti e registrarli.
• Registra sempre eventi, errori e avvisi importanti. Puoi usare strumenti come Serilog, NLog o i provider di logging integrati.
• Assicurati che i log contengano dettagli sufficienti per trovare e risolvere rapidamente i problemi.

Nota: una buona gestione degli errori e un buon logging ti aiutano a individuare i problemi in anticipo. Inoltre rendono le applicazioni più facili da supportare e migliorare nel tempo.

Autenticazione e sicurezza

Protezione dei servizi gRPC

Devi proteggere i tuoi servizi gRPC per tutelare dati e utenti. Inizia usando HTTPS per tutte le comunicazioni gRPC. Questo passaggio cifra i dati tra client e server. Dovresti inoltre usare autenticazione e autorizzazione per controllare l'accesso. Quando configuri autenticazione e autorizzazione, stabilisci chi può chiamare i tuoi metodi gRPC e quali azioni può eseguire. Per verificare l'identità di ciascun client puoi usare certificati o token. Molti sviluppatori usano a questo scopo i token JWT. Convalida sempre questi token sul server prima di elaborare qualsiasi richiesta.

Suggerimento: usa l'autorizzazione basata sui ruoli per limitare l'accesso ai metodi gRPC sensibili. Assegna ruoli agli utenti e verifica le loro autorizzazioni prima di consentire di eseguire le azioni.

Autenticazione in WPF e ASP.NET

Devi implementare autenticazione e autorizzazione sia nelle applicazioni WPF sia in quelle ASP.NET. In ASP.NET puoi usare il middleware integrato per gestire autenticazione e autorizzazione. Questo middleware verifica le credenziali dell'utente e applica le regole di autorizzazione a ogni richiesta. Puoi aggiungere la funzionalità di autenticazione/autorizzazione configurando i servizi nel file Startup o Program. Per WPF, spesso ci si collega a un servizio back-end per autenticazione e autorizzazione. Il client WPF invia le credenziali dell'utente al server, che restituisce un token se le credenziali sono valide. Il client usa poi questo token per le richieste successive. Conserva sempre i token in modo sicuro lato client.

La tabella seguente mostra i metodi di autenticazione e autorizzazione più comuni:

Nota: conserva sempre i token in un archivio sicuro nelle app WPF. Non memorizzare mai dati sensibili in chiaro.

Gestione dei token

Devi gestire i token con attenzione per mantenere sicure le tue applicazioni. Quando usi autenticazione e autorizzazione, il server emette un token dopo un accesso riuscito. Il client archivia questo token e lo invia con ogni richiesta. Dovresti impostare tempi di scadenza dei token per ridurre il rischio. Quando un token scade, il client deve richiederne uno nuovo. In ASP.NET puoi configurare la durata dei token e la logica di aggiornamento. Per gRPC, verifica sempre il token prima di elaborare una richiesta. Se il token manca o non è valido, nega l'accesso usando le tue regole di autorizzazione.

Dovresti anche revocare i token quando un utente effettua il logout o quando rilevi attività sospette. Questo passaggio impedisce accessi non autorizzati. Rivedi regolarmente la configurazione di autenticazione e autorizzazione per assicurarti che soddisfi le tue esigenze di sicurezza.

Suggerimento: automatizza il rinnovo dei token nei client per mantenere attive le sessioni senza interruzioni per l'utente.

Distribuzione e manutenzione

Distribuzione multilivello

Puoi organizzare la tua soluzione .NET usando una distribuzione multilivello. Questo approccio separa l'applicazione in livelli. Ogni livello ha un compito specifico. Ad esempio, potresti avere un livello di presentazione per WPF o ASP.NET Core MVC, un livello di servizio per la comunicazione gRPC e un livello dati per il database. Questa struttura ti aiuta a gestire il codice e a scalare la soluzione.

Una tipica configurazione multilivello è la seguente:

Distribuisci ogni livello su server o contenitori diversi. Questa separazione migliora sicurezza e prestazioni. Puoi aggiornare un livello senza influire sugli altri.

Suggerimento: usa gRPC nel livello di servizio per collegare in modo rapido e affidabile i livelli di presentazione e dati.

Pipeline CI/CD

Puoi automatizzare la build e il processo di distribuzione con pipeline CI/CD. CI sta per Continuous Integration (integrazione continua). CD sta per Continuous Deployment (distribuzione continua). Queste pipeline ti aiutano a rilasciare aggiornamenti più rapidamente e con meno errori.

Ecco i passaggi principali di una pipeline CI/CD:

1. Esegui il push del codice in un sistema di controllo del codice sorgente come GitHub o Azure DevOps.
2. La pipeline compila l'applicazione ed esegue i test.
3. Se i test vanno a buon fine, la pipeline distribuisce l'app in un ambiente di test o di produzione.

Puoi usare strumenti come GitHub Actions, Azure Pipelines o GitLab CI. Questi strumenti supportano progetti .NET, ASP.NET Core e gRPC. Puoi configurare distribuzioni automatiche per i servizi WPF, web e gRPC.

Nota: le pipeline CI/CD ti aiutano a individuare i problemi in anticipo. Puoi annullare le modifiche se qualcosa va storto.

Monitoraggio e aggiornamenti

Devi monitorare le tue applicazioni per mantenerle in salute. Gli strumenti di monitoraggio tengono traccia di errori, prestazioni e utilizzo. Puoi usare Application Insights, Prometheus o Grafana. Questi strumenti funzionano con servizi .NET, ASP.NET Core e gRPC.

Dovresti configurare avvisi per gli eventi importanti. Ad esempio, puoi ricevere un messaggio se il servizio gRPC non funziona o se la web app rallenta. Gli aggiornamenti regolari mantengono il sistema sicuro e veloce. Dovresti applicare le patch ai server, aggiornare le librerie e rivedere spesso i log.

Una semplice checklist per la manutenzione:

• Monitora tutti i servizi, inclusi gli endpoint gRPC.
• Configura avvisi per errori e rallentamenti.
• Aggiorna il runtime .NET e le librerie.
• Controlla i log e risolvi rapidamente i problemi.

Suggerimento: pianifica finestre di manutenzione regolari. Questo ti aiuta ad applicare gli aggiornamenti senza interrompere gli utenti.

Best practice e prossimi passi

Design pattern

Migliori i tuoi progetti .NET usando design pattern collaudati. Questi pattern ti aiutano a scrivere codice facile da comprendere, testare e manutenere. Nello sviluppo .NET moderno usi spesso pattern come Dependency Injection, Repository e MVVM (Model-View-ViewModel).

• Dependency Injection ti permette di gestire le dipendenze tra le classi. Registri i servizi nel codice di avvio e li inietti dove necessari. Questo pattern rende il codice flessibile e testabile.
• Repository Pattern separa la logica di accesso ai dati dalla logica di business. Crei classi repository per gestire le operazioni sul database. Questo mantiene il codice organizzato.
• MVVM funziona bene per le applicazioni WPF. Separi l'interfaccia utente, la logica di business e i modelli di dati. Questo pattern ti aiuta a costruire app desktop reattive e manutenibili.

Suggerimento: The Modern .NET Development Podcast su m365.fm spesso mostra come questi pattern ti aiutano a scalare le soluzioni e a prepararti ai cambiamenti futuri.

Strategie di test

Per consegnare software affidabile ti servono strategie di test solide. Il test ti aiuta a individuare i bug in anticipo e a verificare che il codice funzioni come previsto. In .NET si usano diversi tipi di test:

Scrivi unit test per la logica di business. Usa i test di integrazione per verificare come interagiscono i tuoi servizi e i database. Per le app WPF e web, aggiungi test dell'interfaccia utente per garantire che l'esperienza utente resti fluida.

• Usa il test-driven development (TDD) per scrivere i test prima del codice.
• Automatizza i test nelle pipeline CI/CD per ottenere un feedback rapido.
• Usa i mock per isolare i test dalle dipendenze.

Nota: i test automatizzati ti fanno risparmiare tempo e riducono gli errori durante gli aggiornamenti.

Documentazione e collaborazione

Mantieni i progetti in buona salute scrivendo una documentazione chiara e lavorando bene con il team. Una buona documentazione aiuta i nuovi sviluppatori a capire il codice. Inoltre rende più semplice manutenere ed estendere le applicazioni.

• Scrivi file README che spiegano lo scopo del progetto e i passaggi di configurazione.
• Usa i commenti XML nel codice per descrivere classi e metodi.
• Crea la documentazione delle API con strumenti come Swagger per ASP.NET Core.

Collabori meglio quando usi sistemi di controllo versione come Git. Tieni traccia delle modifiche, revisioni il codice e risolvi i conflitti come team. Le capacità comunicative contano quanto quelle tecniche. The Modern .NET Development Podcast spesso parla di come una comunicazione efficace e una documentazione chiara aiutino i team ad avere successo, soprattutto con la diffusione degli strumenti di AI nello sviluppo.

Suggerimento: pianifica revisioni del codice regolari e condividi le conoscenze con il team. Questa pratica porta a codice migliore e a un team più solido.

Risorse per l'apprendimento

Puoi far crescere le tue competenze di sviluppo .NET usando diverse risorse di apprendimento. L'ecosistema .NET cambia rapidamente, quindi devi restare aggiornato su strumenti, framework e best practice più recenti. Ecco alcune risorse di riferimento che ti aiutano a mantenere le tue conoscenze aggiornate e concrete.

📚 Podcast e programmi consigliati

• Modern .NET Development Podcast (m365.fm)
  Ascolta Mirko Peters e il Microsoft MVP Gábor Ruzsinszki mentre discutono di temi .NET reali. Ricevi consigli di esperti su WPF, ASP.NET Core, gRPC e altro. Il podcast tratta l'AI nello sviluppo, le capacità comunicative e le funzionalità future di .NET.

  Suggerimento: iscriviti al Modern .NET Development Podcast sulla piattaforma che preferisci per ricevere aggiornamenti regolari.

• .NET Rocks!
  Questo programma presenta interviste a leader del settore. Scopri nuove tendenze, strumenti e tecniche in .NET.

📖 Documentazione ufficiale e guide

• Microsoft Learn per .NET
  Trovi tutorial passo passo, esempi di codice e lezioni interattive. Microsoft Learn ti aiuta a padroneggiare tutto, da WPF a ASP.NET Core e gRPC.

• Documentazione di ASP.NET Core
  Ottieni guide dettagliate per creare app web, API e soluzioni sicure.

• Documentazione di gRPC per .NET
  Questa risorsa spiega come configurare, usare e testare i servizi gRPC in .NET.

🛠️ Community e piattaforme interattive

• Stack Overflow
  Puoi porre domande e trovare risposte da sviluppatori .NET esperti. Cerca soluzioni o condividi le tue conoscenze.

• GitHub
  Esplora i progetti .NET open source. Puoi leggere il codice, contribuire ai repository e imparare da esempi reali.

• Microsoft Q&A
  Questo forum ti permette di entrare in contatto con gli ingegneri Microsoft e la community .NET.

📅 Conferenze ed eventi online

• .NET Conf
  Puoi seguire sessioni e workshop in diretta. Scopri le ultime versioni e funzionalità di .NET.

• Meetup locali
  Unisciti ai gruppi di utenti .NET della tua zona. Incontra altri sviluppatori, condividi esperienze e lavorate insieme ai progetti.

📝 Tabella: riepilogo delle risorse di apprendimento

Nota: dedica ogni settimana del tempo a esplorare nuove risorse. L'apprendimento continuo ti aiuta a restare un passo avanti nello sviluppo moderno con .NET.

Puoi combinare queste risorse per costruire basi solide. Prova nuovi strumenti, segui i consigli di esperti e unisciti alla community .NET. Migliorerai le tue competenze e manterrai i tuoi progetti moderni ed efficienti.

Hai imparato come collegare WPF, ASP.NET e gRPC per lo sviluppo moderno con .NET. Hai visto passaggi pratici per migrazione, integrazione e sicurezza. Puoi usare gRPC per creare una comunicazione veloce tra app desktop e web. Puoi migliorare i tuoi progetti seguendo le best practice dell'episodio Modern .NET: WPF, ASP.NET Core, and gRPC with Gábor Ruzsinszki [MVP]. Ti consiglio di provare gRPC nella tua prossima soluzione. Puoi esplorare m365.fm per altri consigli di esperti.

Unisciti alla community .NET e sperimenta con progetti di esempio per far crescere le tue competenze.

Domande frequenti

Qual è il vantaggio principale di usare WPF per le applicazioni desktop?

Con WPF puoi creare interfacce utente ricche e reattive. Il framework supporta grafica avanzata e data binding. Progetti app desktop di livello enterprise in modo rapido ed efficiente.

In che modo ASP.NET Core migliora lo sviluppo web?

Con ASP.NET Core ottieni supporto multipiattaforma e prestazioni elevate. Il framework ti permette di creare app web e API sicure. Distribuisci le tue soluzioni su Windows, Linux o macOS.

Perché usare gRPC per la comunicazione tra servizi?

Con gRPC ottieni una comunicazione tra servizi veloce e affidabile. Il framework usa HTTP/2 e Protocol Buffers. Riduci la latenza e migliori la scalabilità delle tue applicazioni.

È possibile collegare WPF e ASP.NET Core tramite gRPC?

Integri WPF e ASP.NET Core usando gRPC. Il framework consente alle tue app desktop e web di condividere dati e logica di business. Crei soluzioni unificate per le esigenze di business moderne.

Quali strumenti aiutano a migrare le applicazioni .NET legacy?

Per la migrazione usi .NET Upgrade Assistant e Visual Studio. Questi strumenti analizzano il codice e ti guidano nel processo di aggiornamento. Modernizzi le tue app con meno sforzo.

Come proteggi i servizi ASP.NET Core e gRPC?

Proteggi i servizi abilitando HTTPS e usando token di autenticazione. Implementi l'autorizzazione basata sui ruoli per controllare l'accesso. Mantieni al sicuro i dati e gli utenti.

Dove trovo consigli di esperti sullo sviluppo moderno con .NET?

Puoi ascoltare il Modern .NET Development Podcast su m365.fm. Il podcast presenta esempi reali e consigli pratici. Impari dagli esperti del settore e resti aggiornato sulle nuove tecnologie.

🎧 Ascolta questo episodio

Vuoi una spiegazione pratica di Modern .NET? Questo episodio illustra l'argomento in modo chiaro e mostra perché è importante per Microsoft 365, Azure, Power Platform, sicurezza, AI e il lavoro moderno.

Ascolta questo episodio se vuoi:

• Capire i concetti chiave di Modern .NET
• Vedere come si inserisce nel più ampio ecosistema tecnologico Microsoft
• Scoprire dove può creare valore concreto per la tua organizzazione

Potresti apprezzare anche questi episodi correlati di M365 FM:

• LINQ to SQL vs EF Core per l'accesso ai dati in .NET
• Estensibilità in .NET e Clean Architecture con Miguel Castro [MVP]
• Modern Microsoft 365 Automation Beyond PowerShell Scripts
• Build AI Applications with .NET 10
• Improve Entity Framework Core Query Performance

Scopri altre conversazioni pratiche su Microsoft 365 su M365 FM.