So erhalten Sie die TSQL-Abfrage von LINQ DataContext.SubmitChanges()

Question

Ich verwende Linq zu SQL. Ich habe einen DataContext, gegen den ich .SubmitChanges() 'ing bin. Beim Einfügen des Identitätsfelds ist ein Fehler aufgetreten, und ich möchte die Abfrage sehen, mit der dieses Identitätsfeld eingefügt wird.

Ich sehe die Abfrage nicht selbst in der Quickwatch; Wo kann ich es im Debugger finden?

Answer 1

Es ist eigentlich eine sehr einfache Antwort auf Ihre Frage

Nur dieses Fenster in Ihrer Uhr einfügen

((System.Data.Objects.ObjectQuery)myLinqQueryVar).ToTraceString() 

Answer 2

Führen Sie SQL Profiler, wenn Sie es haben. Es wird der gesamte Datenverkehr zu Ihrer Datenbank angezeigt, einschließlich SQL-Befehlstext.

Answer 3

Viele Menschen haben ihre eigenen "DebugWriter" zu schreiben und es wie so angebracht:

// Add this class somewhere in your project... 
class DebugTextWriter : System.IO.TextWriter { 
    public override void Write(char[] buffer, int index, int count) { 
     System.Diagnostics.Debug.Write(new String(buffer, index, count)); 
    } 

    public override void Write(string value) { 
     System.Diagnostics.Debug.Write(value); 
    } 

    public override Encoding Encoding { 
     get { return System.Text.Encoding.Default; } 
    } 
} 

// Then attach it to the Log property of your DataContext... 
myDataContext.Log = new DebugTextWriter() 

Dies wird alles ausgeben, die Linq-to-Sql ist Visual Studio Debug-Fenster tun in.

Answer 4

Zusätzlich zu Portman's answer, wenn Sie eine Konsolenanwendung sind, es so einfach wie:

myDataContext.Log = Console.Out; 

Oder Sie so etwas wie Linq2SQL Profiler, die ein ziemlich ausgezeichnetes Werkzeug und das richtige Werkzeug für den Job in der Tat nutzen könnte :

Linq to SQL Profiler - Real-time visual debugger for Linq to SQL

Answer 5

ist hier detaillierte Beschreibung: http://debugmode.net/2011/06/26/logging-in-linq-to-sql/

Answer 6

Ich stimme zu, dass Linq zu SQL Profiler das richtige Werkzeug für diesen Job ist. Aber wenn Sie das Geld nicht ausgeben oder einfach etwas Einfaches tun wollen, mag ich den DebugTextWriter Ansatz.

Nachdem ich diese Frage gelesen hatte, machte ich mich auf die Suche nach etwas robusterem. Es stellt sich heraus, Damien Guard auch wrote a very nice article über den Aufbau verschiedener Autoren mit verschiedenen Dingen wie die Ausgabe zu Speicher, Debug, eine Datei, mehrere Ziele oder sogar mit einfachen Delegaten.

gewickelt ich mit ein paar seiner Ideen und eine ActionTextWriter schreiben, die mehr als einen Delegierten umgehen kann, und ich dachte, dass ich es teilen würde hier:

using System; 
using System.Collections.Generic; 
using System.IO; 
using System.Text; 

namespace Writers 
{ 
    public class ActionTextWriter : TextWriter 
    { 
     protected readonly List<Action<string>> Actions = new List<Action<string>>(); 

     public ActionTextWriter(Action<string> action) 
     { 
      Actions.Add(action); 
     } 

     public ActionTextWriter(IEnumerable<Action<string>> actions) 
     { 
      Actions.AddRange(actions); 
     } 

     public ActionTextWriter(params Action<string>[] actions) 
     { 
      Actions.AddRange(actions); 
     } 

     public override Encoding Encoding 
     { 
      get { return Encoding.Default; } 
     } 

     public override void Write(char[] buffer, int index, int count) 
     { 
      Write(new string(buffer, index, count)); 
     } 

     public override void Write(char value) 
     { 
      Write(value.ToString()); 
     } 

     public override void Write(string value) 
     { 
      if (value == null) 
      { 
       return; 
      } 

      foreach (var action in Actions) 
      { 
       action.Invoke(value); 
      } 
     } 
    } 
} 

Sie können so viele Aktionen wie Sie wollen . Dieses Beispiel schreibt in eine Protokolldatei und die Konsole in Visual Studio über Debug.Write:

// Create data context 
var fooDc = new FooDataContext(); 

// Create writer for log file. 
var sw = new StreamWriter(@"C:\DataContext.log") {AutoFlush = true}; 

// Create write actions. 
Action<string> writeToDebug = s => Debug.Write(s); 
Action<string> writeToLog = s => sw.Write(s); 

// Wire up log writers. 
fooDc.Log = new ActionTextWriter(writeToDebug, writeToLog); 

Und natürlich, wenn Sie wollen einfachere, um die Manschette zu verwenden, aus, können Sie immer ActionTextWriter erweitern .. Schreiben Sie den generischen Ansatz und wiederverwenden, oder?

using System.Diagnostics; 
using System.IO; 

namespace Writers 
{ 
    public class TraceTextWriter : ActionTextWriter 
    { 
     public TraceTextWriter() 
     { 
      Actions.Add(s => Trace.Write(s)); 
     } 
    } 

    public class FileTextWriter : ActionTextWriter 
    { 
     public FileTextWriter(string path, bool append = false) 
     { 
      var sw = new StreamWriter(path, append) {AutoFlush = true}; 
      Actions.Add(sw.Write); 
     } 
    } 
} 

Answer 7

FooDataContext dc = new FooDataContext(); 

StringBuilder sb = new StringBuilder(); 
dc.Log = new StringWriter(sb); 

var result=from r in dc.Tables select d; 

..... 
string query=sb.ToString();