Garantindo MessageKeys exclusivos com um analisador Roslyn personalizado

Garantindo a exclusividade de MessageKeys em projetos C#

Implementação de um Roslyn Analyzer para validar MessageKeys exclusivas usando análise estática em tempo de compilação.

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

Validando MessageKeys exclusivas usando LINQ

Uma abordagem alternativa usando LINQ e reflexão para validar MessageKeys exclusivas em cenários de teste de tempo de execução.

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

Perguntas comuns sobre analisadores Roslyn

1. O que é um analisador Roslyn?
2. Uma ferramenta que se integra ao compilador para analisar código e impor regras, como garantir valores `MessageKey` exclusivos.
3. Como um Roslyn Analyzer melhora a qualidade do código?
4. Ao realizar verificações em tempo de compilação, evita que problemas como chaves duplicadas cheguem à produção.
5. Quais técnicas de programação o analisador usa?
6. Ele usa RegisterSyntaxNodeAction para analisar nós de sintaxe específicos, como inicializadores de objetos.
7. Os Analisadores Roslyn podem ser personalizados para outras regras?
8. Sim, você pode escrever regras personalizadas usando DiagnosticDescriptor e outras APIs Roslyn para impor uma variedade de padrões de código.
9. Quais são as vantagens da validação em tempo de compilação?
10. Ele detecta erros antecipadamente, reduzindo o tempo de depuração e melhorando a confiabilidade geral do aplicativo. 🚀
11. Como funciona a validação de tempo de execução alternativa?
12. Ele usa Reflection para inspecionar classes dinamicamente e LINQ para identificar chaves duplicadas durante a execução.
13. Qual abordagem é melhor: validação em tempo de compilação ou em tempo de execução?
14. O tempo de compilação é mais eficiente para desenvolvimento, enquanto o tempo de execução é útil para testar sistemas legados ou componentes carregados dinamicamente.
15. Que desafios podem surgir ao criar um Roslyn Analyzer?
16. Compreender a API Roslyn e garantir que o analisador funcione de forma eficiente sem retardar o processo de construção.
17. Os Analisadores Roslyn podem impor convenções de nomenclatura?
18. Sim, eles podem ser estendidos para verificar padrões de nomenclatura e impor padrões de codificação.
19. Como você testa um analisador Roslyn?
20. Usando testes de unidade com bibliotecas Microsoft.CodeAnalysis.Testing para validar diferentes cenários.
21. O suporte do Roslyn Analyzer está limitado a C#?
22. Não, ele também pode ser usado para outras linguagens .NET, como VB.NET.

Automatizando verificações de qualidade de código com Roslyn

O Roslyn Analyzer oferece uma maneira poderosa de impor padrões de codificação e manter a integridade dos dados em seus projetos. Ao identificar campos `MessageKey` duplicados durante a compilação, ajuda os desenvolvedores a evitar erros críticos de tempo de execução e garante operações suaves do banco de dados. Esta integração destaca o valor das práticas de programação proativas. 🛠️

Esteja você dimensionando um aplicativo grande ou otimizando uma base de código menor, ferramentas como Roslyn oferecem confiabilidade incomparável. A capacidade de escrever regras personalizadas adaptadas a necessidades específicas torna-o uma solução versátil para impor identificadores exclusivos e outras restrições importantes, permitindo fluxos de trabalho de desenvolvimento simplificados e sem erros. 🚀