Visual Studio Compiler-SQL-Validierung

Question

Wenn ich habe eine Dapper.NET Abfrage wie so bekomme:

conn.Execute("insert into My_Table values ('blah', 'blah, 'blah', 'blah')"); 

Wie kann ich Visual Studio zwingen zu tun Kompilierung-Überprüfung dieser Abfrage für ein bestimmtes Datenbankschema ? Ich bin mir bewusst, dass es Bibliotheken gibt, die eine Abfrageprüfung durchführen können (vorausgesetzt, eine Zeichenfolge und eine Verbindung), aber was ist das richtige Werkzeug für den Job hier?

Erweitern Sie Roslyn, um Strings zu untersuchen, die ich als Query Strings (mit einer Syntax ähnlich der bekannten @ "Unescaped String") markiere? Benutzerdefinierte Vorverarbeitung?

Oder stelle ich die falsche Frage? Wäre es sicherer, die gesamte Abfragelogik in gespeicherte Prozeduren innerhalb meines Datenbankprojekts zu übertragen (wodurch ich die Überprüfung der Abfrage selbst bekomme)? Jetzt, wo ich das schreibe, denke ich, werde ich tatsächlich mit dieser Lösung gehen, aber ich bin immer noch neugierig auf das Obige. Ich möchte in der Lage sein zu schreiben:

conn.Execute(#"insert into My_Table values ('blah', 
'blah, 'blah', 'blah')"); //Hashtag to mark as query 

Und den Compiler überprüfen Sie die Zeichenfolge für ein bestimmtes Datenbankschema.

Answer 1

Eine Option wäre, einen Roslyn Analyzer zu schreiben. Was der Analysator tun würde, ist, alle Aufrufe von Funktionen wie Execute() zu finden, und wenn ihr Parameter eine konstante Zeichenkette ist, validiere das mit der Bibliothek, die du erwähnt hast.

Bei der Implementierung des Analysators tritt ein Problem auf, wie Sie das zu überprüfende Datenbankschema angeben können. Sofern Sie es nicht irgendwie in Ihrem Analysator fest codieren wollen, scheint es der Weg zu sein, "additional files" (das currently requires hand-editing the csproj of any project where you want to use the analyzer) zu verwenden.

Der Analysator könnte wie folgt aussehen (beachten Sie, dass Sie wahrscheinlich robuster machen müssen den Code ändern zu):

public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics 
    => ImmutableArray.Create(BadSqlRule, MissingOptionsFileRule); 

public override void Initialize(AnalysisContext context) 
{ 
    context.RegisterCompilationStartAction(AnalyzeCompilationStart); 
    context.RegisterCompilationAction(AnalyzeCompilation); 
    context.RegisterSyntaxNodeAction(AnalyzeNode, SyntaxKind.InvocationExpression); 
} 

private Config config = null; 

private void AnalyzeCompilationStart(CompilationStartAnalysisContext context) 
{ 
    var configFile = context.Options.AdditionalFiles 
     .SingleOrDefault(f => Path.GetFileName(f.Path) == "myconfig.json"); 

    config = configFile == null 
     ? null 
     : new Config(configFile.GetText(context.CancellationToken).ToString()); 
} 

private void AnalyzeCompilation(CompilationAnalysisContext context) 
{ 
    if (config == null) 
     context.ReportDiagnostic(Diagnostic.Create(MissingOptionsFileRule, Location.None)); 
} 

private void AnalyzeNode(SyntaxNodeAnalysisContext context) 
{ 
    if (config == null) 
     return; 

    var node = (InvocationExpressionSyntax) context.Node; 

    var symbol = (IMethodSymbol) context.SemanticModel.GetSymbolInfo(
     node, context.CancellationToken).Symbol; 

    // TODO: properly check it's one of the methods we analyze 
    if (symbol.ToDisplayString().Contains(".Execute(string")) 
    { 
     var arguments = node.ArgumentList.Arguments; 
     if (arguments.Count == 0) 
      return; 

     var firstArgument = arguments.First().Expression; 

     if (!firstArgument.IsKind(SyntaxKind.StringLiteralExpression)) 
      return; 

     var sqlString = (string)((LiteralExpressionSyntax) firstArgument).Token.Value; 

     if (Verify(config, sqlString)) 
      return; 

     context.ReportDiagnostic(
      Diagnostic.Create(BadSqlRule, firstArgument.GetLocation(), sqlString)); 
    } 
}