Garantir des clés de message uniques avec un analyseur Roslyn personnalisé

Assurer l'unicité des MessageKeys dans les projets C#

Implémentation d'un Roslyn Analyzer pour valider des MessageKeys uniques à l'aide d'une analyse statique au moment de la compilation.

using System;
using System.Collections.Generic;
using System.Collections.Immutable;
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Diagnostics;
namespace UniqueMessageKeyAnalyzer
{
    [DiagnosticAnalyzer(LanguageNames.CSharp)]
    public class MessageKeyAnalyzer : DiagnosticAnalyzer
    {
        private static readonly DiagnosticDescriptor Rule = new DiagnosticDescriptor(
            \"UMK001\",
            \"Duplicate MessageKey detected\",
            \"MessageKey '{0}' is defined multiple times\",
            \"Design\",
            DiagnosticSeverity.Error,
            isEnabledByDefault: true);
        public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Rule);
        public override void Initialize(AnalysisContext context)
        {
            context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
            context.EnableConcurrentExecution();
            context.RegisterSyntaxNodeAction(AnalyzeNode, SyntaxKind.ObjectInitializerExpression);
        }
        private static void AnalyzeNode(SyntaxNodeAnalysisContext context)
        {
            var initializer = (InitializerExpressionSyntax)context.Node;
            var messageKeyAssignments = new List<string>();
            foreach (var expression in initializer.Expressions)
            {
                if (expression is AssignmentExpressionSyntax assignment &&
                    assignment.Left.ToString() == \"MessageKey\")
                {
                    var value = context.SemanticModel.GetConstantValue(assignment.Right);
                    if (value.HasValue && value.Value is string messageKey)
                    {
                        if (messageKeyAssignments.Contains(messageKey))
                        {
                            var diagnostic = Diagnostic.Create(Rule, assignment.GetLocation(), messageKey);
                            context.ReportDiagnostic(diagnostic);
                        }
                        else
                        {
                            messageKeyAssignments.Add(messageKey);
                        }
                    }
                }
            }
        }
    }
}

Validation des clés de message uniques à l'aide de LINQ

Une approche alternative utilisant LINQ et la réflexion pour valider des MessageKeys uniques dans des scénarios de tests d'exécution.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
namespace MessageKeyValidation
{
    public class Program
    {
        public static void Main(string[] args)
        {
            var errorCodes = typeof(ErrorMessages)
                .GetFields(BindingFlags.Public | BindingFlags.Static)
                .Select(field => field.GetValue(null) as ErrorMessageCode)
                .Where(code => code != null)
                .ToList();
            var duplicateKeys = errorCodes
                .GroupBy(code => code.MessageKey)
                .Where(group => group.Count() > 1)
                .Select(group => group.Key)
                .ToList();
            if (duplicateKeys.Any())
            {
                Console.WriteLine(\"Duplicate MessageKeys found:\");
                foreach (var key in duplicateKeys)
                {
                    Console.WriteLine(key);
                }
            }
            else
            {
                Console.WriteLine(\"All MessageKeys are unique.\");
            }
        }
    }
    public class ErrorMessages
    {
        public static readonly ErrorMessageCode Error1 = new ErrorMessageCode { MessageKey = \"00001\" };
        public static readonly ErrorMessageCode Error2 = new ErrorMessageCode { MessageKey = \"00002\" };
        public static readonly ErrorMessageCode Error3 = new ErrorMessageCode { MessageKey = \"00001\" }; // Duplicate
    }
    public class ErrorMessageCode
    {
        public string MessageKey { get; set; }
    }
}

Questions courantes sur les analyseurs Roslyn

1. Qu'est-ce qu'un analyseur Roslyn ?
2. Un outil qui s'intègre au compilateur pour analyser le code et appliquer des règles, telles que garantir des valeurs « MessageKey » uniques.
3. Comment un Roslyn Analyzer améliore-t-il la qualité du code ?
4. En effectuant des vérifications au moment de la compilation, cela empêche des problèmes tels que des clés en double d'atteindre la production.
5. Quelles techniques de programmation l’analyseur utilise-t-il ?
6. Il utilise RegisterSyntaxNodeAction pour analyser des nœuds de syntaxe spécifiques tels que les initialiseurs d'objets.
7. Les analyseurs Roslyn peuvent-ils être personnalisés pour d’autres règles ?
8. Oui, vous pouvez écrire des règles personnalisées à l'aide de DiagnosticDescriptor et d'autres API Roslyn pour appliquer diverses normes de code.
9. Quels sont les avantages de la validation au moment de la compilation ?
10. Il détecte les erreurs plus tôt, réduisant ainsi le temps de débogage et améliorant la fiabilité globale des applications. 🚀
11. Comment fonctionne la validation alternative du runtime ?
12. Il utilise Reflection pour inspecter dynamiquement les classes et LINQ pour identifier les clés en double lors de l'exécution.
13. Quelle approche est la meilleure : validation au moment de la compilation ou à l'exécution ?
14. Le moment de la compilation est plus efficace pour le développement, tandis que le moment de l'exécution est utile pour tester les systèmes existants ou les composants chargés dynamiquement.
15. Quels défis peuvent survenir lors de la création d’un Roslyn Analyzer ?
16. Comprendre l'API Roslyn et garantir que l'analyseur fonctionne efficacement sans ralentir le processus de construction.
17. Les analyseurs Roslyn peuvent-ils appliquer les conventions de dénomination ?
18. Oui, ils peuvent être étendus pour vérifier les modèles de dénomination et appliquer les normes de codage.
19. Comment tester un analyseur Roslyn ?
20. Utilisation de tests unitaires avec les bibliothèques Microsoft.CodeAnalysis.Testing pour valider différents scénarios.
21. La prise en charge de Roslyn Analyzer est-elle limitée à C# ?
22. Non, il peut également être utilisé pour d'autres langages .NET comme VB.NET.

Automatisation des contrôles de qualité du code avec Roslyn

L'analyseur Roslyn offre un moyen puissant d'appliquer les normes de codage et de maintenir l'intégrité des données dans vos projets. En identifiant les champs `MessageKey` en double lors de la compilation, cela aide les développeurs à éviter les erreurs d'exécution critiques et garantit le bon fonctionnement de la base de données. Cette intégration met en évidence la valeur des pratiques de programmation proactives. 🛠️

Que vous souhaitiez faire évoluer une application volumineuse ou optimiser une base de code plus petite, des outils comme Roslyn offrent une fiabilité inégalée. La possibilité d'écrire des règles personnalisées adaptées à des besoins spécifiques en fait une solution polyvalente pour appliquer des identifiants uniques et d'autres contraintes importantes, permettant des flux de travail de développement rationalisés et sans erreur. 🚀