Ersetzen Sie alle Variablen in C# -Code mit Methoden

Question

Ich muss Fragmente von benutzerdefinierten C# -Code analysieren und ersetzen alle Variablen, die nicht lokal mit Methodenaufrufen definiert sind. I.e.

public class Foo 
{ 
    public dynamic Bar() 
    { 
    return Math.Min(x + width, maxWidth); 
    } 
} 

hat werden:

public class Foo 
{ 
    public dynamic Bar() 
    { 
     return Math.Min(Resolve("x") + Resolve("width"), Resolve("maxWidth")); 
    } 
} 

Ich Microsoft.CodeAnalysis.CSharp und die CSharpSyntaxTree mit dem String zu prüfen, aber es gibt mir nicht genug Informationen, die ersetzen auszuführen. Oder wenn es so ist, weiß ich nicht, wo ich danach suchen soll. Ich habe das SyntaxTree-Layout unten eingefügt. Alle Variablen treten als IdentifierName-Knoten auf, aber ich weiß nicht, wie ich verschiedene IdentifierNames unterscheiden kann. Wohin geht es von hier?

CompilationUnit[0..99) { 
code: public class Foo\n{\n public dynamic Bar()\n {\n return Math.Min(x + width, maxWidth);\n }\n} 
tokens: EndOfFileToken[] 
nodes{ 
    ClassDeclaration[0..99) { 
    code: public class Foo\n{\n public dynamic Bar()\n {\n return Math.Min(x + width, maxWidth);\n }\n} 
    tokens: PublicKeyword[public ] ClassKeyword[class ] IdentifierToken[Foo\n] OpenBraceToken[{\n] CloseBraceToken[}] 
    nodes{ 
    MethodDeclaration[21..98) { 
    code: public dynamic Bar()\n {\n return Math.Min(x + width, maxWidth);\n }\n 
    tokens: PublicKeyword[ public ] IdentifierToken[Bar] 
    nodes{ 
     IdentifierName[30..38) { 
     code: dynamic 
     tokens: IdentifierToken[dynamic ] 
     } 
     ParameterList[41..45) { 
     code: ()\n 
     tokens: OpenParenToken[(] CloseParenToken[)\n] 
     } 
     Block[45..98) { 
     code: {\n return Math.Min(x + width, maxWidth);\n }\n 
     tokens: OpenBraceToken[ {\n] CloseBraceToken[ }\n] 
     nodes{ 
     ReturnStatement[50..93) { 
     code:  return Math.Min(x + width, maxWidth);\n 
     tokens: ReturnKeyword[ return ] SemicolonToken[;\n] 
     nodes{ 
      InvocationExpression[61..90) { 
      code: Math.Min(x + width, maxWidth) 
      nodes{ 
      SimpleMemberAccessExpression[61..69) { 
      code: Math.Min 
      tokens: DotToken[.] 
      nodes{ 
       IdentifierName[61..65) { 
       code: Math 
       tokens: IdentifierToken[Math] 
       } 
       IdentifierName[66..69) { 
       code: Min 
       tokens: IdentifierToken[Min] 
       } 
      } 
      } 
      ArgumentList[69..90) { 
      code: (x + width, maxWidth) 
      tokens: OpenParenToken[(] CommaToken[, ] CloseParenToken[)] 
      nodes{ 
       Argument[70..79) { 
       code: x + width 
       nodes{ 
       AddExpression[70..79) { 
       code: x + width 
       tokens: PlusToken[+ ] 
       nodes{ 
        IdentifierName[70..72) { 
        code: x 
        tokens: IdentifierToken[x ] 
        } 
        IdentifierName[74..79) { 
        code: width 
        tokens: IdentifierToken[width] 
        } 
       } 
       } 
       } 
       } 
       Argument[81..89) { 
       code: maxWidth 
       nodes{ 
       IdentifierName[81..89) { 
       code: maxWidth 
       tokens: IdentifierToken[maxWidth] 
       } 
       } 
       } 
      } 
      } 
      } 
      } 
     } 
     } 
     } 
     } 
    } 
    } 
    } 
    } 
} 
} 

Answer 1

Ich denke, Sie müssen das semantische Modell verwenden. Hier ist ein (sehr einfaches) Beispiel, das zeigt, wie ungelöste Symbole zu finden:

var tree = CSharpSyntaxTree.ParseFile(fileName); 
var root = tree.GetRoot(); 
var refs = new MetadataReference[] 
{ 
    new MetadataFileReference(@"C:\Windows\Microsoft.NET\Framework\v4.0.30319\mscorlib.dll", new MetadataReferenceProperties(MetadataImageKind.Assembly)) 
}; 
var compilation = CSharpCompilation.Create("testRoslyn", new[] { tree }, refs); 
var model = compilation.GetSemanticModel(tree); 

var unknownSymbols = 
    from node in root.DescendantNodes() 
    where node.IsKind(SyntaxKind.IdentifierName) 
    let symbolInfo = model.GetSymbolInfo(node) 
    where symbolInfo.Symbol == null && !symbolInfo.CandidateSymbols.Any() 
    select node; 

Von dort können Sie die Knoten mit Resolve(name) ersetzen können.

Answer 2

Vielleicht fügen Sie versehentlich CSharpSyntaxTree des Codes ohne Deklaration "double width = 10.0;" Wenn ja, erhalten Sie diese zusätzlichen Deklarationen in Ihrem CSharpSyntaxTree.

Alles, was Sie tun müssen, ist nur den Baum nach IdentifierToken zu scannen, die nicht im Benutzercode deklariert sind. All diese Token haben Positionen, die Sie zum Ersetzen von Variablen Access Code zu Methodenaufrufcode verwenden müssen.

Answer 3

Dieser Beitrag bietet nicht wirklich eine Lösung für Ihr Problem, sondern stattdessen eine andere Möglichkeit, die einfacher zu implementieren ist, aber eine Änderung für den Benutzer einführen. Ich poste hier nur als eine Idee.

Ziel ist es nicht, damit der Benutzer x schreiben, sondern Var.x oder Var.maxWidth

Dann, wenn Sie Ihre C# -Code Parsen, müssen Sie nur Code einfügen für eine Eigenschaft Var vom Typ CustomDynamicObject (oder einem beliebigen Namen geben will)

public (static?) CustomDynamicObject Var { get { /* create the object once and return */ }} 

Dann können Sie definieren DynamicObjectCustomDynamicObject vererben, so dass Sie alle Anrufe zu undefinierten Methoden/Eigentum abfangen

DynamicObject und Verwendung der dynamischen Funktion von .NET 4 ist nur eine Möglichkeit, Anruf abzufangen, aber Sie können für andere Techniken googlen.