Säkerställa unika meddelandenycklar med en anpassad Roslyn-analysator

Säkerställa unika meddelandenycklar i C#-projekt

Implementering av en Roslyn Analyzer för att validera unika MessageKeys med statisk analys vid kompilering.

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

Validerar unika meddelandenycklar med LINQ

Ett alternativt tillvägagångssätt som använder LINQ och reflektion för att validera unika MessageKeys i runtime-testscenarier.

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

Vanliga frågor om Roslyn Analyzers

1. Vad är en Roslyn Analyzer?
2. Ett verktyg som integreras med kompilatorn för att analysera kod och genomdriva regler, som att säkerställa unika "MessageKey"-värden.
3. Hur förbättrar en Roslyn Analyzer kodkvaliteten?
4. Genom att utföra kontroller vid kompilering, förhindrar det problem som dubbletter av nycklar från att nå produktionen.
5. Vilka programmeringstekniker använder analysatorn?
6. Den använder RegisterSyntaxNodeAction för att analysera specifika syntaxnoder som objektinitierare.
7. Kan Roslyn Analyzers anpassas för andra regler?
8. Ja, du kan skriva anpassade regler med DiagnosticDescriptor och andra Roslyn API:er för att genomdriva en mängd olika kodstandarder.
9. Vilka är fördelarna med kompileringstidsvalidering?
10. Det fångar upp fel tidigt, vilket minskar felsökningstiden och förbättrar den övergripande applikationens tillförlitlighet. 🚀
11. Hur fungerar den alternativa körtidsvalideringen?
12. Den använder Reflection för att dynamiskt inspektera klasser och LINQ för att identifiera dubbletter av nycklar under exekvering.
13. Vilket tillvägagångssätt är bättre: kompileringstid eller körtidsvalidering?
14. Kompileringstid är mer effektiv för utveckling, medan runtime är användbar för att testa äldre system eller dynamiskt laddade komponenter.
15. Vilka utmaningar kan uppstå när man skapar en Roslyn Analyzer?
16. Förstå Roslyn API och se till att analysatorn fungerar effektivt utan att sakta ner byggprocessen.
17. Kan Roslyn Analyzers tillämpa namnkonventioner?
18. Ja, de kan utökas för att kontrollera namnmönster och genomdriva kodningsstandarder.
19. Hur testar man en Roslyn Analyzer?
20. Använda enhetstester med Microsoft.CodeAnalysis.Testing-bibliotek för att validera olika scenarier.
21. Är Roslyn Analyzer-stödet begränsat till C#?
22. Nej, det kan också användas för andra .NET-språk som VB.NET.

Automatisera kodkvalitetskontroller med Roslyn

Roslyn Analyzer ger ett kraftfullt sätt att genomdriva kodningsstandarder och upprätthålla dataintegritet i dina projekt. Genom att identifiera dubbletter av "MessageKey"-fält under kompileringen, hjälper det utvecklare att undvika kritiska runtime-fel och säkerställer smidig databasoperationer. Denna integration belyser värdet av proaktiv programmering. 🛠️

Oavsett om du skalar en stor applikation eller optimerar en mindre kodbas, erbjuder verktyg som Roslyn oöverträffad tillförlitlighet. Möjligheten att skriva anpassade regler skräddarsydda för specifika behov gör det till en mångsidig lösning för att upprätthålla unika identifierare och andra viktiga begränsningar, vilket möjliggör strömlinjeformade, felfria utvecklingsarbetsflöden. 🚀