Roadmap di sviluppo

Questo aggiornamento garantirà il supporto completo alla generazione di progetti basati su .NET 10, non appena la nuova versione sarà ufficialmente rilasciata da Microsoft.

Attualmente, Lino genera progetti basati su .NET 9, sfruttando tutte le funzionalità disponibili della piattaforma, inclusi miglioramenti nelle prestazioni, funzionalità avanzate di C# 13 e un'integrazione moderna con ASP.NET Core.

L’obiettivo di questa futura versione è offrire supporto immediato a .NET 10 con template aggiornati, configurazioni adeguate di Target Framework e scaffolding pronto per le nuove funzionalità del linguaggio e del runtime.

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.

Implementazione della generazione automatica di file .http, con l’obiettivo di facilitare il test e la documentazione degli endpoint REST negli ambienti di sviluppo.

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.Presentation.API.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.