Come ottenere la query TSQL da LINQ DataContext.SubmitChanges()

Question

Sto utilizzando Linq su SQL. Ho un DataContext contro cui sono .SubmitChanges() 'ing. Si è verificato un errore durante l'inserimento del campo identità e mi piacerebbe vedere la query che sta utilizzando per inserire questo campo identità.

Non vedo la query stessa all'interno del quickwatch; dove posso trovarlo dal debugger?

Answer 1

v'è in realtà una risposta molto semplice alla tua domanda

semplicemente incollare questo nella vostra finestra di controllo

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

Answer 2

Eseguire SQL Profiler se ce l'hai. Mostrerà tutto il traffico verso il tuo database, incluso il testo del comando SQL.

Answer 3

Un sacco di persone hanno scritto il proprio "DebugWriter" e allegando in questo modo:

// 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() 

Questa volontà tutto quello di uscita che LINQ to SQL sta facendo nella finestra di debug di Visual Studio.

Answer 4

A seguito Portman's answer, se sei un applicazione console è semplice come:

myDataContext.Log = Console.Out; 

Oppure si potrebbe usare qualcosa come Linq2SQL Profiler che è uno strumento piuttosto eccellente e di fatto lo strumento giusto per il lavoro :

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

Answer 5

Ecco descrizione dettagliata: http://debugmode.net/2011/06/26/logging-in-linq-to-sql/

Answer 6

Sono d'accordo che Linq per SQL Profiler è lo strumento giusto per questo lavoro. Ma se non vuoi spendere soldi o semplicemente devi fare qualcosa di semplice, mi piace l'approccio di DebugTextWriter.

Dopo aver letto questa domanda sono andato a cercare qualcosa di più robusto. Risulta anche Damien Guard wrote a very nice article sulla costruzione di diversi scrittori per gestire cose diverse come l'output in memoria, il debug, un file, più destinazioni o anche l'utilizzo di semplici delegati.

Finii con un paio delle sue idee e la scrittura di un ActionTextWriter in grado di gestire più di un delegato, e ho pensato di condividerle qui:

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

È possibile aggiungere il numero di azioni che vuoi . Questo esempio scrive un file di log e la console in Visual Studio via 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); 

E, naturalmente, se si vuole fare più semplici da usare a braccio, si può sempre estendere ActionTextWriter .. scrivere l'approccio generico e riutilizzare, giusto?

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