Suivez nos progrès et les fonctionnalités à venir. Nous évoluons constamment pour vous offrir la meilleure expérience de développement.
Cette mise à jour garantira une prise en charge complète de la génération de projets basés sur .NET 10 dès que la nouvelle version sera officiellement publiée par Microsoft.
Actuellement, Lino génère des projets basés sur .NET 9, en exploitant toutes les fonctionnalités disponibles de la plateforme, y compris les améliorations de performance, les fonctionnalités avancées de C# 13 et l'intégration moderne avec ASP.NET Core.
L'objectif de cette future version est d’offrir un support immédiat pour .NET 10 avec des modèles mis à jour, des configurations appropriées du Target Framework
, et un scaffolding prêt pour les nouvelles fonctionnalités du langage et du runtime.
Génération automatisée de tests avec prise en charge de deux niveaux principaux :
Tests Unitaires :
Création de tests pour des classes et méthodes individuelles, en se concentrant sur la logique métier.
Tests d'Intégration :
Création de tests pour vérifier l'intégration entre les composants, en simulant des interactions avec des bases de données et des services externes.
Implémentation de la génération automatique de fichiers .http
, afin de faciliter les tests et la documentation des endpoints REST dans les environnements de développement.
Système de contrôle d'accès basé sur les permissions (PBAC) utilisant les Policies d'ASP.NET Core.
Les permissions sont créées automatiquement via les Source Generators et enregistrées comme Policies dans .NET.
Chaque service utilisant ces permissions déclenche des événements qui alimentent et mettent à jour automatiquement la base de permissions du système.
Principales caractéristiques :
_ Génération automatique des permissions via Source Generators
_ Enregistrement automatique des Policies dans ASP.NET Core
_ Mise à jour dynamique de la base de permissions via événements/messagerie
_ Support du RBAC hybride, combinant la simplicité des rôles avec la granularité des permissions
Avantages :
_ Performance et scalabilité maximales
_ Gestion automatisée et maintenance simplifiée
_ Flexibilité pour différents scénarios de sécurité
Mise en œuvre du support natif du type IFormFile
pour les endpoints créés avec Minimal APIs. Cette fonctionnalité permettra la génération automatisée de routes avec prise en charge du téléversement de fichiers, comprenant :
_ Définition d’endpoints acceptant les uploads via multipart/form-data
;
_ Validation automatique des types MIME et des tailles maximales autorisées ;
_ Prise en charge du stockage local et intégration avec des services cloud tels que Azure Blob Storage et AWS S3 ;
Idéal pour les applications nécessitant un téléversement sécurisé et performant de fichiers tels que des images, documents ou médias.
À partir de cette version, Lino CLI effectue un merge automatique intelligent des fichiers générés.
Auparavant, les fichiers créés par Lino remplaçaient directement les fichiers existants, risquant d’écraser les modifications manuelles apportées par le développeur.
Désormais, grâce à la nouvelle stratégie de 3-way merge (fichier original généré, version modifiée par l’utilisateur et nouveau fichier généré), Lino parvient à préserver les personnalisations tout en appliquant les mises à jour structurelles du template.
Avantages de cette approche :
_ Évite les écrasements accidentels de code manuel.
_ Facilite l’évolution continue des projets basés sur des templates.
_ Réduit les conflits manuels lors des mises à jour.
_ Améliore l’intégration entre personnalisations locales et évolution du framework.
Les projets générés avec Lino CLI peuvent désormais enregistrer automatiquement les Minimal APIs en utilisant la bibliothèque Tolitech.Presentation.API.Generators, basée sur les Source Generators.
Cette approche remplace le besoin de :
_ Enregistrer manuellement chaque endpoint via MapGet
, MapPost
, etc.
_ Utiliser la Reflection pour scanner et mapper les routes — ce qui est coûteux en performance.
Avec les Source Generators, le mapping est effectué à la compilation, générant un code optimisé, propre et traçable.
Principaux avantages :
_ Élimine la verbosité et la répétition de l'enregistrement manuel des routes.
_ Supprime l'utilisation de la Reflection, réduisant l'utilisation CPU et mémoire.
_ Améliore l’organisation du code et la séparation des responsabilités.
_ Génération automatique et sûre des routes avec validation à la compilation.
_ Facilite la maintenance et la montée en charge du projet.
Nous utilisons désormais la bibliothèque Tolitech.DependencyInjection.Generators, qui remplace l’approche basée sur la Reflection de Tolitech.DependencyInjection.Extensions.
Cette nouvelle bibliothèque exploite la fonctionnalité des Source Generators de .NET pour générer automatiquement les enregistrements de dépendances à la compilation.
Cela offre plusieurs avantages :
_ Élimination de la Reflection à l’exécution, améliorant la performance de l’application.
_ Génération de code plus prévisible et traçable.
_ Compilation plus sûre, avec détection anticipée des erreurs.
_ Intégration native avec le pipeline de build de .NET.
Nous avons adopté le Central Package Manager (CPM), une approche moderne de la gestion des packages NuGet dans des solutions multi-projets.
Grâce à lui, toutes les versions des packages sont définies de manière centralisée dans le fichier Directory.Packages.props
, ce qui élimine les incohérences et facilite les mises à jour sûres et coordonnées.
Cela réduit les erreurs causées par des divergences de versions entre projets, améliore la traçabilité et simplifie la mise à jour des dépendances à grande échelle.
Lino génère désormais des solutions au nouveau format .slnx
, une évolution moderne du traditionnel .sln
.
Basé sur XML, le format .slnx
a été adopté car il est plus lisible par les humains et les outils, réduisant la complexité d'intégration avec les systèmes externes et les pipelines CI/CD.
De plus, sa structure plus propre améliore considérablement le contrôle de version — les modifications sont plus prévisibles et plus faciles à examiner.
Ce changement s'inscrit dans la direction future de l'écosystème .NET, favorisant une plus grande interopérabilité, extensibilité et automatisation dans le développement des projets.
L'abonnement Community offre désormais un support pour la génération de projets basés sur .NET 9 et Aspire 9.2.1, permettant aux utilisateurs d'explorer gratuitement et techniquement les fonctionnalités de la plateforme.
Cette version inclut :
_ Création de services et d'entités avec scaffolding automatisé ;
_ Sélection de la base de données et configuration initiale complète ;
_ Génération fonctionnelle jusqu'à l'étape EF Core Migrations
.
Bien que des fonctionnalités avancées telles que les microservices et les monolithes modulaires soient limitées aux plans payants, cette version offre une base solide pour évaluer l'architecture générée, la qualité du code et l'intégration avec l'écosystème .NET moderne.
La CLI propose désormais la commande lino database migrations add
pour faciliter la création de migrations pour n’importe quel service ou module du projet.
Cette fonctionnalité automatise la génération des scripts de migration liés à la version du build et permet une documentation cohérente des modifications.
Principaux bénéfices :
_ Création rapide de migrations par service ou module avec des commandes simples et directes.
_ Génération automatique des scripts .sql
compatibles avec le versionnage du projet.
_ Facilite le contrôle de version de la base de données même dans des architectures distribuées.
_ Standardise et documente les modifications structurelles de la base de manière sécurisée et auditée.
_ Intégration naturelle au flux de build et de déploiement de l’application.
La nouvelle fonctionnalité de gestion des versions permet de lister les versions existantes et d’effectuer un bump de version sur les services et applications web générés par l’outil, conformément à la convention SemVer (Versionnage Sémantique). Cela garantit une meilleure traçabilité, standardisation et contrôle dans le cycle de release.
Grâce à la commande version
, il est facile de définir et de mettre à jour le numéro de version de chaque service ou application, facilitant les audits et intégrant les bonnes pratiques dans le flux de développement.
La commande build
a également été améliorée pour générer des images Docker avec le tag de version défini, simplifiant le packaging et préparant les applications à la publication.
Ces améliorations renforcent la cohérence et la prévisibilité dans la gestion des releases, offrant plus de transparence aux équipes de développement et d’exploitation.
Personnaliser les propriétés à prendre en compte lors de la génération d’artefacts de type Command (Post, Put, Patch) et Query (Get).
Cette fonctionnalité offre :
_ Une interface interactive dans la CLI pour sélectionner les propriétés pendant le processus de scaffolding des entités ;
_ Génération automatique d’objets avec uniquement les champs sélectionnés pour l’input/output ;
_ Prise en charge complète de la personnalisation des payloads dans les APIs REST, augmentant la flexibilité et le contrôle sur les données échangées ;
_ Intégration avec la validation et les contrats de données générés, respectant les règles de contrainte et de cohérence.
Cette amélioration vise à offrir une plus grande granularité dans la modélisation des artefacts, permettant au développeur de contrôler précisément ce qui sera exposé, persisté ou consulté via l’architecture générée par la CLI.
Un mécanisme automatique de versionnage et de sauvegarde des fichiers a été mis en place dans Lino CLI, afin de garantir la sécurité et la traçabilité lors des processus de génération et de réécriture des fichiers.
Tous les fichiers générés sont stockés dans le dossier /.lino/files/.../received/
, assurant une organisation temporelle et une localisation facile.
Les fichiers remplacés restent stockés dans le dossier /.lino/files/.../replaced/
, permettant la récupération des versions antérieures si nécessaire. Cette structure de sauvegarde offre un meilleur contrôle et une sécurité accrue, permettant un audit complet des fichiers générés, notamment dans des environnements de développement collaboratifs et automatisés.
Implémentation complète de l’authentification et de l’autorisation pour projets frontend et backend, basée sur JWT (JSON Web Tokens) et un contrôle granulaire des permissions via des Authorization Policies
personnalisées d’ASP.NET Core.
Points forts :
_ Connexion sécurisée avec émission et validation des JWT.
_ Autorisation basée sur des politiques personnalisées (Claims et Roles).
_ Intégration automatique entre APIs et frontends (Blazor) générés.
_ Protection des routes et composants basée sur les permissions utilisateur.
Avantages :
_ Sécurité robuste pour applications modernes.
_ Standardisation du modèle d’accès par profil et domaine.
_ Expérience sécurisée et intégrée entre les couches de l’application.
_ Facilité d’extension ou d’adaptation selon le contexte de l’entreprise.
Il est désormais possible d’ajouter un ou plusieurs frontends aux projets générés, avec un support initial pour Blazor Web Apps
— incluant les modèles Server et WebAssembly.
Ces frontends sont automatiquement intégrés aux API générées par l’outil, permettant la création de pages CRUD complètes avec des appels directs aux endpoints backend et la persistance dans la base de données.
Points forts :
_ Génération d’UI basée sur les entités du domaine.
_ Communication native avec les API générées.
_ Fonctionnalité de bout en bout : frontend, backend et base de données fonctionnant ensemble.
_ Possibilité de plusieurs frontends dans un même projet (ex : admin, portail, public).
Avantages :
_ Rapidité dans le développement des interfaces.
_ Moins de retravail et d’intégration manuelle.
_ Standard unifié de navigation, style et accès aux données.
_ Productivité accrue grâce à la génération automatique de pages CRUD.
Nous avons implémenté le pattern Transactional Outbox pour garantir la fiabilité dans l’envoi des événements d’intégration.
Au lieu de publier l’événement directement pendant la transaction de l’application, il est maintenant enregistré dans une table spécifique au sein de la même transaction de base de données.
Ensuite, un background job lit cette outbox et effectue l’envoi réel de l’événement.
Avantages de cette approche :
_ Garantit la cohérence entre les modifications en base et la publication des événements.
_ Évite la perte de messages en cas de défaillances intermédiaires.
_ Permet le contrôle de la retransmission et l’audit des événements publiés.
_ S’aligne sur les bonnes pratiques d’architecture orientée événements et microservices.
Une option a été ajoutée pour inclure des Background Jobs dans les services générés — qu’ils soient simples ou modulaires — en utilisant la bibliothèque Hangfire
.
Cela permet aux projets de prendre en charge nativement la planification et l’exécution des tâches en arrière-plan, y compris :
_ Exécution récurrente (cron), planifiée ou immédiate.
_ Surveillance via un tableau de bord intégré.
_ Persistance et re-traitement sécurisé des jobs.
Ce mécanisme peut également être utilisé avec le Transactional Outbox Pattern, garantissant l’envoi fiable des événements d’intégration, même en cas de défaillances partielles ou de scénarios distribués.
Principaux avantages :
_ Automatisation des tâches récurrentes et longues sans bloquer le flux principal.
_ Haute résilience et persistance des tâches en arrière-plan.
_ Intégration prête à l'emploi avec le pattern Outbox pour des événements fiables.
_ Configuration et personnalisation faciles des jobs par service.
_ Tableau de bord intégré pour l’inspection et le contrôle des exécutions.
La possibilité de configurer le support de la messagerie asynchrone avec RabbitMQ
a été ajoutée, en utilisant l’abstraction et les fonctionnalités avancées de MassTransit
.
Ainsi, les services générés peuvent communiquer de manière découplée et résiliente, en utilisant des événements et des commandes distribués.
Points forts de l’intégration :
_ Configuration automatisée du transport avec RabbitMQ.
_ Publication et écoute d’événements via MassTransit avec injection de dépendances native.
_ Compatible avec le pattern Transactional Outbox pour une plus grande fiabilité.
Avantages :
_ Haute scalabilité grâce à une communication basée sur les événements.
_ Découplage entre producteurs et consommateurs.
_ Tolérance accrue aux pannes et re-traitement automatique.
_ Facilité de maintenance et d’extension des flux métiers asynchrones.
Un mécanisme robuste de Unit of Work a été implémenté avec un contrôle total des transactions, la gestion des événements de domaine, la publication des événements d’intégration (Outbox Pattern), le rollback automatique et le support du pattern Result
pour commit/rollback en fonction du succès ou de l’échec de l’opération.
Points forts :
_ Création explicite des transactions avec contrôle du niveau d’isolation.
_ Publication des Domain Events synchronisée avec la persistance des données.
_ Publication des Integration Events de manière découplée via Outbox Pattern.
_ Rollback automatique et gestion des exceptions avec support de la validation des contraintes.
_ Commit conditionné au Result
de l’opération.
_ Journalisation structurée des événements, transactions et erreurs.
Avantages :
_ Cohérence transactionnelle entre les écritures en base et les événements générés.
_ Flexibilité pour utiliser SaveChanges standard ou contrôle total du flux.
_ Facilité pour les tests unitaires et le traçage des erreurs.
_ Séparation claire entre Domaine et Infrastructure, avec support de MediatR.
Il est désormais possible de définir, individuellement pour chaque service généré, la base de données à utiliser — avec un support natif pour SQL Server et PostgreSQL.
Cette approche permet à chaque service d’avoir sa base de données dédiée, garantissant une isolation complète et facilitant la mise en œuvre de pratiques architecturales orientées microservices réels.
Dans le cas des services modulaires, l’application continue d’utiliser une seule base de données par service, avec une séparation de chaque module via un schema
, garantissant organisation et cohésion.
Principaux avantages :
_ Isolation des données entre services, améliorant la sécurité et la clarté des responsabilités.
_ Adoption progressive possible des microservices avec bases indépendantes.
_ Séparation par schéma dans les services modulaires pour faciliter la maintenance et la compréhension du domaine.
_ Flexibilité totale dans le choix du SGBD le plus adapté pour chaque service.
_ Facilité pour les tests, les déploiements isolés et la scalabilité horizontale.
Le Lino CLI permet désormais au développeur de choisir, lors de la génération du projet, entre la création de services simples (traditionnels) ou de services modulaires, avec une liberté totale pour combiner les deux selon les besoins de la solution.
Cette approche offre un support direct à différents styles architecturaux :
Services simples : idéaux pour composer des solutions basées sur des microservices ou pour construire des applications monolithiques traditionnelles de manière simple et isolée.
Services modulaires : organisent le domaine de l’application en Bounded Contexts, facilitant l’adoption d’un monolithe modulaire avec une séparation claire des responsabilités et une meilleure cohésion entre composants.
Vous pouvez ajouter autant de services que vous le souhaitez — simples, modulaires ou les deux — selon le contexte de l’application.
Avantages de cette approche :
_ Plus de flexibilité dans la modélisation de l’architecture.
_ Facilité à évoluer progressivement d’un monolithe vers des microservices.
_ Séparation claire des responsabilités par domaine ou contexte.
_ Meilleure organisation du code et alignement avec les bonnes pratiques d’architecture moderne.
_ Réduction du couplage et amélioration de la maintenabilité.
Développez avec des microservices ou adoptez un monolithe modulaire — vous choisissez la voie idéale pour votre application.
Ajout du support natif pour la cache hybride à l’aide de la bibliothèque Microsoft.Extensions.Caching.Hybrid
.
Cette implémentation combine un cache en mémoire (MemoryCache) avec un cache distribué (DistributedCache), offrant le meilleur des deux mondes.
Cette approche permet des réponses extrêmement rapides pour les requêtes fréquentes, tout en maintenant la synchronisation et la scalabilité dans des environnements distribués.
Avantages de la stratégie hybride :
_ Haute performance grâce à une lecture immédiate de la mémoire locale.
_ Persistance et partage des données entre les instances via le cache distribué.
_ Réduction des appels à la base de données et aux API externes.
_ Meilleure scalabilité horizontale pour les applications avec plusieurs réplicas.
_ Synchronisation intelligente entre les deux niveaux de cache.
Idéal pour les scénarios exigeant performance et cohérence sans sacrifier la flexibilité architecturale.
Lino CLI génère désormais des projets avec un soutien intégré à plusieurs langues, incluant la traduction automatique pour les cultures suivantes :
en
, pt-BR
, es
, fr
, it
, de
, ja
, ko
, zh-Hans
et ru
.
Les fichiers de ressources (resx) sont générés automatiquement à partir de la langue principale, et les contenus sont traduits automatiquement, prêts à être utilisés immédiatement dans des applications globales.
Avantages du support multilingue :
_ Facilite la création d’applications adaptées à différentes régions et cultures.
_ Réduit le temps nécessaire à l’internationalisation.
_ Intégration native avec le système de localisation .NET.
_ Améliore l’expérience utilisateur finale dans les applications multilingues.
_ Permet de faire évoluer rapidement des solutions pour le marché mondial.
Les codes générés par Lino CLI utilisent désormais LoggerMessage pour enregistrer les logs de manière plus efficace et performante.
Contrairement aux méthodes d’extension classiques de ILogger
, qui provoquent du boxing des types valeurs et impactent l’allocation mémoire à l’exécution, le pattern LoggerMessage crée des Actions
fortement typées et statiques pour chaque message de log.
Avantages de cette approche :
_ Réduction significative des allocations mémoire.
_ Évite le boxing
des types valeurs comme int
, Guid
, DateTime
, etc.
_ Meilleure performance dans les scénarios à fort volume de logs.
_ Standardisation et centralisation des messages de log.
_ Plus de clarté dans l’audit, le diagnostic et la surveillance.
Cette amélioration est particulièrement pertinente dans les API et services backend où la performance et la traçabilité sont essentielles.
Lino CLI propose désormais une prise en charge optionnelle des Strongly Typed Ids, permettant de représenter les identifiants d'entités par des types fortement typés spécifiques, au lieu de types génériques comme Guid
ou int
.
Cette fonctionnalité aide à éviter les erreurs courantes comme l’attribution incorrecte d’un identifiant d’une entité à une autre, tout en rendant le code plus expressif et cohérent avec le domaine de l’application.
Avantages de l’utilisation de Strongly Typed Ids :
_ Meilleure sécurité de type à la compilation.
_ Évite les attributions accidentelles entre différentes entités.
_ Améliore la lisibilité et la clarté de l’intention du code.
_ Facilite le suivi et le débogage des identifiants dans le domaine.
_ Intégration avec EF Core, la sérialisation JSON et la validation.
L’activation de cette fonctionnalité est optionnelle et peut être définie lors de la génération du projet.
Les projets générés peuvent désormais être configurés avec un support pour l’analyse statique du code, en utilisant les principaux analyseurs de l’écosystème .NET.
Ces outils sont intégrés directement dans le build et aident à identifier les problèmes de formatage, de style, d’architecture et les possibles erreurs logiques dès le développement.
Avantages :
_ Favorise la cohérence et la standardisation du code dès le départ.
_ Détecte les bugs et mauvaises pratiques précocement.
_ Facilite les revues de code et l’intégration technique.
_ Améliore la qualité et la maintenabilité de la base de code.
_ Évite les erreurs courantes et améliore le respect des bonnes pratiques .NET.
La configuration peut être personnalisée par projet, permettant une plus grande flexibilité dans le niveau de rigueur souhaité.
Création de la bibliothèque Tolitech.Results, qui implémente le Result Pattern de manière complète et fluide sur .NET.
Cette bibliothèque encapsule le résultat des opérations — qu’elles soient réussies ou échouées — dans des objets structurés contenant le statut HTTP, les messages, les erreurs, les titres, les détails et des données optionnelles (avec support de Result<T>
).
Avantages de l’utilisation du Result Pattern :
_ Standardisation du retour des opérations dans toute l’application.
_ Réduction des exceptions utilisées comme contrôle de flux.
_ Facilité dans la composition et l’enchaînement des opérations.
_ Meilleur support à la communication entre couches et services.
_ Intégration fluide avec les API HTTP, validations et messages d’erreur.
_ Meilleure expérience de débogage et de journalisation structurée.
De plus, des extensions telles que Tolitech.Results.Http et Tolitech.Results.Guards étendent l’intégration avec les API REST et les validations défensives.