String-Literale durch private const-Anweisungen ersetzen

Question

Ich baue einen Analysator für C# -Code, der Fehler erzeugt, wenn ein String-Literal anstelle einer Const-Zeichenfolge für bestimmte Argumente für bestimmte Funktionen verwendet wird. Ie.

class MyClass 
{ 
    private void MyMethod(IWriter writer) 
    { 
    writer.WriteInteger("NamedValue", 4); 
    } 
} 

Sollte sich:

class MyClass 
{ 
    private const string IoNamedValueKey = "NamedValue"; 
    private void MyMethod(IWriter writer) 
    { 
    writer.WriteInteger(IoNamedValueKey , 4); 
    } 
} 

ich das bisschen habe zu arbeiten, wo er den Fehler anzeigt, aber ich möchte auch eine CodeFixProvider bereitzustellen. Ich habe in zwei Probleme gerannt:

1. Ich muss die private const string IoNamedValueKey = "NamedValue"; Anweisung hinzufügen, idealerweise nur über die beleidigende Methode.
2. Aber nur wenn es nicht schon existiert.

Ich bin nicht ganz sicher, dass die Vorlage Ansatz für die CodeFixProvider die entsprechenden Überlastungen für meine Zwecke verwendet (es ersetzt nur Namen geben mit Großbuchstaben-Varianten), so würde, was der beste Weg vorwärts aus dem RegisterCodeFixesAsync Verfahren ?

public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context) 
{ 
    // ... now what? 
} 

Nach roslynquoter der erforderliche Knoten, wie unten aufgebaut werden kann, aber ich bin an einem Verlust noch etwas darüber, wie es in den Kontext zu injizieren.

CompilationUnit() 
.WithMembers(
    SingletonList<MemberDeclarationSyntax>(
     FieldDeclaration(
      VariableDeclaration(
       PredefinedType(
        Token(SyntaxKind.StringKeyword))) 
      .WithVariables(
       SingletonSeparatedList<VariableDeclaratorSyntax>(
        VariableDeclarator(
         Identifier("IoNamedValueKey")) 
        .WithInitializer(
         EqualsValueClause(
          LiteralExpression(
           SyntaxKind.StringLiteralExpression, 
           Literal("NamedValue"))))))) 
     .WithModifiers(
      TokenList(
       new []{ 
        Token(SyntaxKind.PrivateKeyword), 
        Token(SyntaxKind.ConstKeyword)})))) 
.NormalizeWhitespace() 

Answer 1

Sie sollten eine CodeAction registrieren, die das geänderte Dokument durch die context einführt. Für

• die SyntaxNodes generieren - siehe Roslyn der UniqueNameGenerator und NameGenerator, werden sie nicht ausgesetzt durch die API, aber es wäre sehr leicht zu re - Sie verwenden CSharp SyntaxFactory
• Erste eindeutigen Namen für Ihren consant verwenden können -Ermöglicht eine vereinfachte Version von ihnen. Hier

ist ein Beispiel Kratzer, was Ihr Code aussehen könnte ( aktualisiert):

public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context) 
    { 
     var root = await context.Document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false); 

     var diagnostic = context.Diagnostics.First(); 
     var diagnosticSpan = diagnostic.Location.SourceSpan; 

     var argument = root.FindNode(diagnosticSpan); 
     if (!IsBadStringLiteralArgument(argument)) 
     { 
      return; 
     } 

     // Register a code action that will invoke the fix. 
     context.RegisterCodeFix(
      CodeAction.Create(
       title: title, 
       createChangedDocument: (ct) => InlineConstField(context.Document, root, argument, ct), 
       equivalenceKey: title), 
      diagnostic); 
    } 

    private async Task<Document> InlineConstField(Document document, SyntaxNode root, SyntaxNode argument, CancellationToken cancellationToken) 
    { 
     var stringLiteral = (argument as ArgumentSyntax).Expression as LiteralExpressionSyntax; 
     string suggestdName = this.GetSuggestedName(stringLiteral); 
     var containingMember = argument.FirstAncestorOrSelf<MemberDeclarationSyntax>(); 
     var semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false); 
     var containingMemberSymbol = semanticModel.GetDeclaredSymbol(containingMember); 


     var takenNames = containingMemberSymbol.ContainingType.MemberNames; 
     string uniqueName = this.GetUniqueName(suggestdName, takenNames); 
     FieldDeclarationSyntax constField = CreateConstFieldDeclaration(uniqueName, stringLiteral).WithAdditionalAnnotations(Formatter.Annotation); 

     var newRoot = root.ReplaceNode(containingMember, new[] { constField, containingMember }); 
     newRoot = Formatter.Format(newRoot, Formatter.Annotation, document.Project.Solution.Workspace); 
     return document.WithSyntaxRoot(newRoot); 
    } 

    private FieldDeclarationSyntax CreateConstFieldDeclaration(string uniqueName, LiteralExpressionSyntax stringLiteral) 
    { 
     return SyntaxFactory.FieldDeclaration(
      SyntaxFactory.List<AttributeListSyntax>(), 
      SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.PrivateKeyword), SyntaxFactory.Token(SyntaxKind.ConstKeyword)), 
      SyntaxFactory.VariableDeclaration(
       SyntaxFactory.ParseTypeName("string"), 
       SyntaxFactory.SingletonSeparatedList(
        SyntaxFactory.VariableDeclarator(
         SyntaxFactory.Identifier(uniqueName), 
         argumentList: null, 
         initializer: SyntaxFactory.EqualsValueClause(stringLiteral))))); 

    }