Roadmap di sviluppo

Generazione automatizzata di test con supporto per due livelli principali:

Test Unitari:
Creazione di test per classi e metodi individuali, con focus sulla logica di business.

Test di Integrazione:
Creazione di test per verificare l'integrazione tra componenti, simulando interazioni con database e servizi esterni.

Il set di comandi lino integration consente di creare e organizzare integrazioni interne o esterne basate su contratti ben definiti.

Il comando lino integration new genera la struttura base dell’integrazione, includendo un progetto Contratto .csproj e progetti di Implementazione, come Http o InProcess, supportando sia modular monoliths che microservizi.

Le risorse di integrazione vengono create con lino integration resource new e rappresentano servizi esposti dal contratto, definiti come interfacce. Ogni risorsa può contenere operazioni create con lino integration operation new, che generano le classi Request e Response.

Infine, il comando lino resource consume collega moduli o servizi a un’integrazione esistente, automatizzando il consumo e la configurazione delle dipendenze.

Lino è ora disponibile commercialmente in versione Early Access, segnando la fine della fase beta e l’inizio della sua adozione in ambienti di sviluppo reali.

Tutte le principali funzionalità previste per la versione 1.0.0 sono già implementate, rendendo il prodotto completo e pronto per applicazioni pratiche.

In questo periodo iniziale, il nostro obiettivo è il miglioramento continuo — regolazioni delle prestazioni, miglioramenti di stabilità e piccole ottimizzazioni basate sull’utilizzo reale da parte dei clienti.

Chi acquista Lino in questa fase avrà accesso completo agli aggiornamenti, supporto tecnico dedicato e l’opportunità di partecipare attivamente all’evoluzione del prodotto fino al rilascio ufficiale della versione 1.0.0.

Lino ora genera progetti completamente compatibili con .NET 10, consolidando la sua integrazione con l’ultima versione della piattaforma Microsoft.

La migrazione da .NET 9 a .NET 10 è stata fondamentale per garantire che i progetti creati sfruttino i più recenti progressi dell’ecosistema .NET — incluse ottimizzazioni delle prestazioni, miglioramenti nei tempi di compilazione, nuove funzionalità di C# 13 e una migliore esperienza con ASP.NET Core.

Questo aggiornamento assicura che tutto il codice generato sia pronto per il futuro della piattaforma, con template rivisti, configurazioni di Target Framework aggiornate e scaffolding adattato ai nuovi standard di linguaggio e runtime.

È stata implementata la generazione automatica dei file .http, con l’obiettivo di semplificare i test e la documentazione degli endpoint REST durante lo sviluppo.

Questa funzionalità consente di organizzare le richieste ed eseguirle facilmente direttamente negli strumenti compatibili, velocizzando la validazione delle API e migliorando l’esperienza dello sviluppatore.

Principali vantaggi:
_ Creazione automatica di file pronti per il test degli endpoint.
_ Facilita la documentazione e la condivisione di esempi di richieste.
_ Si integra nel flusso di sviluppo senza necessità di configurazioni aggiuntive.
_ Velocizza la validazione delle API in diversi ambienti.

È stata aggiunta la possibilità di generare eventi di integrazione a partire dalla selezione esplicita delle proprietà dell’entità che devono comporre l’evento. Senza questa funzione, gli eventi esponevano normalmente l’intera entità o richiedevano la creazione manuale di DTO specifici, aumentando la verbosità e potenzialmente esponendo dati non necessari.

Con il nuovo approccio, gli sviluppatori hanno un controllo granulare sulle proprietà incluse, ottenendo eventi più snelli, sicuri e allineati alle best practice della messaggistica moderna.

Principali vantaggi:
_ Selezione solo delle proprietà rilevanti per l’evento.
_ Riduzione dell’overhead e prevenzione dell’esposizione non necessaria dei dati.
_ Messaggi più piccoli nelle code e nei topic, migliorando l’efficienza.
_ Maggiore facilità nell’evoluzione dei contratti di integrazione.

Ora è possibile registrare automaticamente tutti i validatori basati su FluentValidation utilizzando la libreria Tolitech.FluentValidation.Generators.

Nel modello tradizionale, i validatori devono essere scoperti e registrati manualmente o tramite riflessione a runtime, generando codice ripetitivo e impattando le prestazioni. Con l’uso dei Source Generators, questo processo viene eseguito a tempo di compilazione, risultando in un codice più ottimizzato, sicuro e facilmente tracciabile.

Principali vantaggi:
_ Eliminazione della registrazione manuale dei validatori.
_ Rimozione dell’uso della riflessione, con miglioramento delle prestazioni e minore allocazione di risorse.
_ Garanzia di sicurezza dei tipi e validazione già a tempo di compilazione.
_ Maggiore facilità di manutenzione ed evoluzione del progetto.

È stato aggiunto il supporto per rilevare e registrare automaticamente tutte le classi di configurazione delle entità (EntityTypeConfiguration) di Entity Framework Core utilizzando i Source Generators.

Attualmente, questo processo dipende dalla riflessione o dalla registrazione manuale all’interno di OnModelCreating, aumentando la complessità, impattando sulle prestazioni e rendendo la manutenzione più difficile. Con questa nuova funzionalità, i mapping vengono risolti a tempo di compilazione, eliminando la necessità di riflessione e centralizzando la configurazione in modo più efficiente.

Principali vantaggi:
_ Sostituisce l’uso della riflessione in EF Core.
_ Riduce i tempi di avvio dell’applicazione.
_ Garantisce l’applicazione corretta di tutte le configurazioni.
_ Aumenta la robustezza e la chiarezza nella modellazione del dominio.

Sistema di controllo degli accessi basato su permessi (PBAC) utilizzando le Policy di ASP.NET Core.
I permessi vengono creati automaticamente tramite Source Generators e registrati come Policy in .NET.
Ogni servizio che utilizza questi permessi genera eventi che alimentano e aggiornano automaticamente il database dei permessi del sistema.

Caratteristiche principali:
_ Generazione automatica dei permessi tramite Source Generators
_ Registrazione automatica delle Policy in ASP.NET Core
_ Aggiornamento dinamico del database dei permessi tramite eventi/messaggistica
_ Supporto a RBAC ibrido, combinando la semplicità dei ruoli con la granularità dei permessi

Benefici:
_ Massime prestazioni e scalabilità
_ Gestione automatizzata e manutenzione semplificata
_ Flessibilità per diversi scenari di sicurezza

Implementazione del supporto nativo per il tipo IFormFile negli endpoint creati con le Minimal APIs. Questa funzionalità consentirà la generazione automatica di rotte con supporto per l’upload di file, tra cui:

_ Definizione di endpoint compatibili con upload tramite multipart/form-data;
_ Validazione automatica dei tipi MIME e delle dimensioni massime consentite;
_ Supporto per storage locale e integrazione con servizi cloud come Azure Blob Storage e AWS S3;

Ideale per applicazioni che richiedono un upload sicuro e performante di file come immagini, documenti e contenuti multimediali.

A partire da questa versione, Lino CLI esegue un merge automatico intelligente dei file generati. In precedenza, i file creati da Lino sostituivano direttamente quelli esistenti, rischiando di sovrascrivere modifiche manuali effettuate dallo sviluppatore.

Ora, con la nuova strategia di 3-way merge (file originale generato, versione modificata dall’utente e nuovo file generato), Lino è in grado di preservare le personalizzazioni e applicare aggiornamenti strutturali del template.

Benefici di questo approccio:
_ Evita la sovrascrittura accidentale del codice manuale.
_ Facilita l’evoluzione continua di progetti basati su template.
_ Riduce i conflitti manuali durante gli aggiornamenti.
_ Migliora l’integrazione tra personalizzazioni locali e l’evoluzione del framework.

Ora i progetti generati con Lino CLI possono registrare automaticamente le Minimal API utilizzando la libreria Tolitech.MinimalApis.Generators, basata su Source Generators.

Questo approccio sostituisce la necessità di:
_ Registrare manualmente ogni endpoint tramite MapGet, MapPost, ecc.
_ Utilizzare la Reflection per scansionare e mappare le route — cosa costosa in termini di performance.

Con i Source Generators, il mapping avviene in fase di compilazione, generando codice ottimizzato, pulito e tracciabile.

Principali vantaggi:
_ Elimina la verbosità e la ripetizione della registrazione manuale delle route.
_ Rimuove la necessità della Reflection, riducendo il consumo di CPU e memoria.
_ Migliora l’organizzazione del codice e la separazione delle responsabilità.
_ Generazione automatica e sicura delle route con validazione in fase di compilazione.
_ Facilita la manutenzione e la scalabilità del progetto.

Ora utilizziamo la libreria Tolitech.DependencyInjection.Generators, che sostituisce l'approccio basato su Reflection di Tolitech.DependencyInjection.Extensions.

Questa nuova libreria sfrutta la funzionalità dei Source Generators di .NET per generare automaticamente le registrazioni delle dipendenze in fase di compilazione.

Questo offre diversi vantaggi:
_ Eliminazione della Reflection a runtime, migliorando le prestazioni dell'applicazione.
_ Generazione di codice più prevedibile e tracciabile.
_ Compilazione più sicura, con errori rilevati in anticipo.
_ Integrazione nativa con la pipeline di build di .NET.

Abbiamo adottato il Central Package Manager (CPM), un approccio moderno alla gestione dei pacchetti NuGet in soluzioni con più progetti. Con esso, tutte le versioni dei pacchetti sono definite centralmente nel file Directory.Packages.props, eliminando le incoerenze e facilitando aggiornamenti sicuri e coordinati. Ciò riduce gli errori causati da discrepanze di versione tra i progetti, migliora la tracciabilità e semplifica l'aggiornamento su larga scala delle dipendenze.

Lino ora genera soluzioni nel nuovo formato .slnx, un'evoluzione moderna del tradizionale .sln.
Basato su XML, il formato .slnx è stato adottato perché più leggibile sia per gli esseri umani che per gli strumenti, riducendo la complessità nell'integrazione con sistemi esterni e pipeline CI/CD.

Inoltre, la sua struttura più pulita migliora significativamente il controllo delle versioni: le modifiche sono più prevedibili e facili da revisionare.
Questo cambiamento è in linea con la direzione futura dell'ecosistema .NET, promuovendo maggiore interoperabilità, estensibilità e automazione nello sviluppo dei progetti.

L'abbonamento Community ora supporta la generazione di progetti basati su .NET 9 e Aspire 9.2.1, consentendo agli utenti di esplorare gratuitamente e in modo tecnico le funzionalità della piattaforma.

Questa versione include:
_ Creazione di servizi ed entità con scaffolding automatizzato;
_ Selezione del database e configurazione iniziale completa;
_ Generazione funzionale fino alla fase di EF Core Migrations.

Sebbene funzionalità avanzate come i microservizi e i monoliti modulari siano limitate ai piani a pagamento, questa versione offre una solida base per valutare l'architettura generata, la qualità del codice e l'integrazione con l'ecosistema .NET moderno.

La CLI ora offre il comando lino database migrations add per facilitare la creazione di migrazioni per qualsiasi servizio o modulo del progetto.

Questa funzionalità automatizza la generazione di script di migrazione legati alla versione del build e consente una documentazione coerente delle modifiche.

Principali vantaggi:
_ Creazione rapida di migrazioni per servizio o modulo con comandi semplici e diretti.
_ Generazione automatica di script .sql compatibili con il versionamento del progetto.
_ Facilita il controllo delle versioni del database anche in architetture distribuite.
_ Standardizza e documenta in modo sicuro e auditabile le modifiche strutturali del database.
_ Integrazione naturale con il flusso di build e deploy dell’applicazione.

La nuova funzionalità di versionamento consente di elencare le versioni esistenti e incrementare la versione (bump) di servizi e applicazioni web generate dallo strumento, seguendo la convenzione SemVer (Versionamento Semantico). Questo garantisce maggiore tracciabilità, standardizzazione e controllo nel ciclo di rilascio.

Tramite il comando version è possibile definire e aggiornare facilmente il numero di versione di ciascun servizio o applicazione, facilitando gli audit e integrando buone pratiche nel flusso di sviluppo.

Anche il comando build è stato migliorato per generare immagini Docker già con il tag della versione definita, semplificando il packaging e preparando le applicazioni alla pubblicazione.

Questi miglioramenti aumentano la coerenza e la prevedibilità nella gestione dei rilasci, offrendo maggiore trasparenza ai team di sviluppo e operations.

Personalizzare quali proprietà considerare nella generazione di artefatti di tipo Command (Post, Put, Patch) e Query (Get).

Questa funzionalità offre:
_ Interfaccia interattiva nella CLI per la selezione delle proprietà durante il processo di scaffolding delle entità;
_ Generazione automatica di oggetti contenenti solo i campi selezionati per input/output;
_ Supporto completo alla personalizzazione dei payload nelle API REST, migliorando flessibilità e controllo sui dati scambiati;
_ Integrazione con la validazione e i contratti dati generati, rispettando le regole di obbligatorietà e coerenza.

Questo miglioramento mira a offrire maggiore granularità nella modellazione degli artefatti, consentendo allo sviluppatore di controllare con precisione cosa viene esposto, salvato o interrogato tramite l'architettura generata dalla CLI.

È stato implementato un meccanismo automatico di versionamento e backup dei file in Lino CLI, con l'obiettivo di garantire sicurezza e tracciabilità nei processi di generazione e sovrascrittura dei file.

Tutti i file generati vengono archiviati nella cartella /.lino/files/.../received/, garantendo un'organizzazione temporale e una facile individuazione.

I file sostituiti rimangono archiviati nella cartella /.lino/files/.../replaced/, consentendo il recupero delle versioni precedenti quando necessario. Questa struttura di backup offre un maggiore controllo e sicurezza, permettendo un audit completo dei file generati, specialmente in ambienti di sviluppo collaborativi e automatizzati.

Implementazione completa di autenticazione e autorizzazione per progetti frontend e backend, basata su JWT (JSON Web Tokens) e controllo granulare dei permessi tramite Authorization Policies personalizzate di ASP.NET Core.

Punti salienti:
_ Login sicuro con emissione e validazione dei JWT.
_ Autorizzazione basata su policy personalizzate (Claims e Roles).
_ Integrazione automatica tra API e frontend (Blazor) generati.
_ Protezione di rotte e componenti basata sui permessi utente.

Vantaggi:
_ Sicurezza robusta per applicazioni moderne.
_ Standardizzazione del modello di accesso per profilo e dominio.
_ Esperienza sicura e integrata tra i livelli dell’applicazione.
_ Facilità di estensione o adattamento in base allo scenario aziendale.

Ora è possibile aggiungere uno o più frontend ai progetti generati, con supporto iniziale per Blazor Web Apps — inclusi i modelli Server e WebAssembly.

Questi frontend sono integrati automaticamente con le API generate dallo strumento, consentendo la creazione di pagine CRUD complete con chiamate dirette agli endpoint backend e persistenza nel database.

Punti salienti:
_ Generazione di UI basata sulle entità del dominio.
_ Comunicazione nativa con le API generate.
_ Funzionalità end-to-end: frontend, backend e database che lavorano insieme.
_ Possibilità di più frontend nello stesso progetto (es: admin, portale, pubblico).

Benefici:
_ Rapidità nello sviluppo delle interfacce.
_ Meno rifacimenti e integrazioni manuali.
_ Standard unificato di navigazione, stile e accesso ai dati.
_ Maggiore produttività con generazione automatica delle pagine CRUD.

Abbiamo implementato il pattern Transactional Outbox per garantire l’affidabilità nell’invio degli eventi di integrazione. Invece di pubblicare l’evento direttamente durante la transazione dell’applicazione, ora esso viene registrato in una tabella specifica all’interno della stessa transazione del database.

Successivamente, un background job legge questa outbox ed esegue il reale invio dell’evento.

Vantaggi di questo approccio:
_ Garantisce la consistenza tra modifiche al database e pubblicazione degli eventi.
_ Evita la perdita di messaggi in caso di errori intermedi.
_ Permette il controllo delle ritrasmissioni e l’audit degli eventi pubblicati.
_ Si allinea alle migliori pratiche di architettura orientata agli eventi e ai microservizi.

È stata aggiunta l’opzione per includere Background Jobs nei servizi generati — siano essi semplici o modulari — utilizzando la libreria Hangfire.

Di conseguenza, i progetti ora supportano nativamente la pianificazione e l'esecuzione di attività in background, tra cui:
_ Esecuzione ricorrente (cron), pianificata o immediata.
_ Monitoraggio tramite pannello di controllo integrato.
_ Persistenza e ripetizione sicura dei job.

Questo meccanismo può anche essere utilizzato insieme al Transactional Outbox Pattern, garantendo l'invio affidabile degli eventi di integrazione anche in caso di errori parziali o ambienti distribuiti.

Principali vantaggi:
_ Automazione delle attività ricorrenti e lunghe senza bloccare il flusso principale.
_ Elevata resilienza e persistenza dei job in background.
_ Integrazione pronta con il pattern Outbox per eventi affidabili.
_ Configurazione e personalizzazione semplice dei job per servizio.
_ Dashboard integrata per ispezione e controllo delle esecuzioni.

È stata aggiunta la possibilità di configurare il supporto per la messaggistica asincrona con RabbitMQ, utilizzando l’astrazione e le funzionalità avanzate di MassTransit.

Di conseguenza, i servizi generati possono comunicare in modo disaccoppiato e resiliente, utilizzando eventi e comandi distribuiti.

Punti salienti dell’integrazione:
_ Configurazione automatica del trasporto con RabbitMQ.
_ Pubblicazione e ascolto di eventi tramite MassTransit con dependency injection nativa.
_ Compatibile con il pattern Transactional Outbox per maggiore affidabilità.

Vantaggi:
_ Alta scalabilità con comunicazione basata su eventi.
_ Disaccoppiamento tra produttori e consumatori.
_ Maggiore tolleranza ai guasti e rielaborazione automatica.
_ Facilità di manutenzione ed estensione dei flussi di lavoro asincroni.

È stato implementato un meccanismo robusto di Unit of Work con controllo totale delle transazioni, gestione degli eventi di dominio, pubblicazione di eventi di integrazione (Outbox Pattern), rollback automatico e supporto al pattern Result per commit/rollback basato sul successo o fallimento dell’operazione.

Punti salienti:
_ Creazione esplicita di transazioni con controllo del livello di isolamento.
_ Pubblicazione di Domain Events sincronizzati con la persistenza dei dati.
_ Pubblicazione di Integration Events in modo disaccoppiato tramite Outbox Pattern.
_ Rollback automatico e gestione delle eccezioni con supporto alla validazione dei vincoli.
_ Commit condizionato al Result dell’operazione.
_ Logging strutturato di eventi, transazioni e errori.

Benefici:
_ Consistenza transazionale tra scritture sul database e eventi generati.
_ Flessibilità nell’uso di SaveChanges standard o controllo totale del flusso.
_ Facilità di test unitari e tracciabilità degli errori.
_ Separazione chiara tra Dominio e Infrastruttura, con supporto a MediatR.

Ora è possibile definire, per ogni servizio generato, il database da utilizzare — con supporto nativo per SQL Server e PostgreSQL.

Questo approccio consente a ciascun servizio di avere un database esclusivo, garantendo isolamento completo e facilitando l’adozione di pratiche architetturali orientate ai microservizi reali.

Nei servizi modulari, l’applicazione continua a utilizzare un singolo database per servizio, con separazione dei moduli tramite schema, mantenendo organizzazione e coesione.

Principali vantaggi:
_ Isolamento dei dati tra i servizi, maggiore sicurezza e chiarezza delle responsabilità.
_ Possibilità di adottare progressivamente microservizi con database indipendenti.
_ Separazione per schema nei servizi modulari per facilitare la manutenzione e la comprensione del dominio.
_ Flessibilità totale nella scelta del DBMS più adatto per ciascun servizio.
_ Facilità nei test, deploy isolati e scalabilità orizzontale.

Lino CLI ora consente agli sviluppatori di scegliere, durante la generazione del progetto, tra la creazione di servizi semplici (tradizionali) o servizi modulari, con totale libertà di combinare entrambi a seconda delle necessità della soluzione.

Questo approccio supporta direttamente diversi stili architetturali:
Servizi semplici: ideali per comporre soluzioni basate su microservizi oppure per costruire applicazioni monolitiche tradizionali in modo diretto e isolato.
Servizi modulari: organizzano il dominio dell’applicazione in Bounded Contexts, facilitando l’adozione di un Monolito Modulare con chiara separazione delle responsabilità e migliore coesione tra i componenti.

È possibile aggiungere quanti servizi si desiderano — semplici, modulari o entrambi — in base al contesto dell’applicazione.

Vantaggi di questo approccio:
_ Maggiore flessibilità nella modellazione dell’architettura.
_ Facilità nella scalabilità progressiva da monolito a microservizi.
_ Chiara separazione delle responsabilità per dominio o contesto.
_ Migliore organizzazione del codice e allineamento con le migliori pratiche di architettura moderna.
_ Riduzione del coupling e aumento della manutenibilità.

Sviluppa con microservizi o adotta un monolito modulare — scegli il percorso ideale per la tua applicazione.

Aggiunto supporto nativo per la cache ibrida utilizzando la libreria Microsoft.Extensions.Caching.Hybrid.

L’implementazione combina la cache in memoria (MemoryCache) con la cache distribuita (DistributedCache), offrendo il meglio di entrambi gli approcci.

Questo approccio consente risposte estremamente rapide per richieste frequenti, mantenendo al contempo sincronizzazione e scalabilità in ambienti distribuiti.

Vantaggi della strategia ibrida:
_ Alte prestazioni grazie alla lettura immediata dalla memoria locale.
_ Persistenza e condivisione dei dati tra istanze tramite cache distribuita.
_ Riduzione delle chiamate al database e alle API esterne.
_ Migliore scalabilità orizzontale in applicazioni con più repliche.
_ Sincronizzazione intelligente tra i due livelli di cache.

Ideale per scenari che richiedono prestazioni e coerenza senza sacrificare la flessibilità architetturale.

Lino CLI ora genera progetti con supporto integrato a più lingue, inclusa la traduzione automatica per le seguenti culture:
en, pt-BR, es, fr, it, de, ja, ko, zh-Hans e ru.

I file di risorse (resx) sono generati automaticamente in base alla lingua principale e i contenuti sono tradotti automaticamente, pronti per l’uso immediato in applicazioni globali.

Vantaggi del supporto multilingue:
_ Facilita la creazione di applicazioni rivolte a diverse regioni e culture.
_ Riduce il tempo necessario per l’internazionalizzazione.
_ Integrazione nativa con il sistema di localizzazione .NET.
_ Migliora l’esperienza utente finale nelle applicazioni multilingue.
_ Permette di scalare rapidamente soluzioni per il mercato globale.

I codici generati da Lino CLI ora utilizzano LoggerMessage per registrare i log in modo più efficiente e con migliori prestazioni.

A differenza dei metodi di estensione convenzionali di ILogger, che causano boxing dei tipi valore e impattano sull’allocazione in fase di esecuzione, il pattern LoggerMessage crea Actions fortemente tipizzate e statiche per ogni messaggio di log.

Vantaggi di questo approccio:
_ Riduzione significativa delle allocazioni di memoria.
_ Evita il boxing di tipi valore come int, Guid, DateTime, ecc.
_ Migliori prestazioni in scenari con elevati volumi di log.
_ Standardizzazione e centralizzazione dei messaggi di log.
_ Maggiore chiarezza in audit, diagnostica e monitoraggio.

Questo miglioramento è particolarmente rilevante in API e servizi backend dove performance e tracciabilità sono fondamentali.

Lino CLI ora offre il supporto opzionale per Strongly Typed Ids, consentendo di rappresentare gli identificatori delle entità con tipi specifici fortemente tipizzati invece che con tipi generici come Guid o int.

Questa funzionalità aiuta a evitare errori comuni come assegnare per sbaglio l'identificatore di un'entità a un'altra, oltre a rendere il codice più espressivo e coerente con il dominio dell'applicazione.

Vantaggi dell'uso di Strongly Typed Ids:
_ Maggiore sicurezza dei tipi in fase di compilazione.
_ Evita assegnazioni accidentali tra entità diverse.
_ Migliora la leggibilità e la chiarezza dell'intento del codice.
_ Facilita il tracciamento e il debug degli identificatori nel dominio.
_ Integrazione con EF Core, serializzazione JSON e validazione.

La funzionalità è opzionale e può essere abilitata al momento della generazione del progetto.

I progetti generati possono ora essere configurati con il supporto per analisi statica del codice, utilizzando i principali analizzatori dell’ecosistema .NET. Questi strumenti sono integrati direttamente nella build e aiutano a identificare problemi di formattazione, stile, architettura e possibili errori logici già in fase di sviluppo.

Vantaggi:
_ Promuove coerenza e standardizzazione nel codice fin dall’inizio.
_ Rileva bug e cattive pratiche in anticipo.
_ Facilita le revisioni del codice e gli onboarding tecnici.
_ Migliora la qualità e la manutenibilità del codice.
_ Previene errori comuni e migliora l’aderenza alle best practice di .NET.

La configurazione può essere personalizzata per progetto, permettendo una maggiore flessibilità nel livello di rigore desiderato.

Creata la libreria Tolitech.Results, che implementa il Result Pattern in modo completo e fluente su .NET.

Questa libreria incapsula il risultato delle operazioni — sia che siano riuscite o fallite — in oggetti strutturati contenenti stato HTTP, messaggi, errori, titoli, dettagli e dati opzionali (con supporto per Result<T>).

Vantaggi dell’uso del Result Pattern:
_ Standardizzazione del ritorno delle operazioni in tutta l’applicazione.
_ Riduzione delle eccezioni come controllo di flusso.
_ Facilità nella composizione e concatenazione delle operazioni.
_ Migliore supporto alla comunicazione tra livelli e servizi.
_ Integrazione fluida con API HTTP, validazioni e messaggi di errore.
_ Migliore esperienza di debug e logging strutturato.

Inoltre, estensioni come Tolitech.Results.Http e Tolitech.Results.Guards ampliano l’integrazione con API REST e validazioni difensive.