Cómo obtener la consulta de TSQL de LINQ DataContext.SubmitChanges()

Question

Estoy utilizando Linq para SQL. Tengo un DataContext contra el cual soy .SubmitChanges() 'ing. Hay un error al insertar el campo de identidad, y me gustaría ver la consulta que está usando para insertar este campo de identidad.

No veo la consulta en sí dentro del reloj; ¿Dónde puedo encontrarlo desde el depurador?

Answer 1

realidad, hay una respuesta muy simple a su pregunta

basta con pegar esto en su ventana de inspección

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

Answer 2

Ejecute el Analizador de SQL si lo tiene. Mostrará todo el tráfico a su base de datos, incluido el texto de comando SQL.

Answer 3

Hay mucha gente que han escrito su propia "DebugWriter" y lo conecta de esta manera:

salida de todo

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

Esta voluntad que LINQ to SQL está haciendo en la ventana de depuración de Visual Studio.

Answer 4

Además de Portman's answer, si usted es una aplicación de consola que es tan simple como:

myDataContext.Log = Console.Out; 

o usted podría utilizar algo como Linq2SQL Profiler, que es un lugar excelente herramienta y de hecho la herramienta adecuada para el trabajo :

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

Answer 5

He aquí la descripción detallada: http://debugmode.net/2011/06/26/logging-in-linq-to-sql/

Answer 6

Acepto que Linq to SQL Profiler es la herramienta adecuada para este trabajo. Pero si no quiere gastar el dinero o simplemente necesita hacer algo simple, me gusta el enfoque DebugTextWriter.

Después de leer esta pregunta, salí en busca de algo más sólido. Resulta que Damien Guard también se ocupó de wrote a very nice article para crear diferentes escritores para que se ocupen de cosas diferentes, como la salida a memoria, depuración, un archivo, múltiples destinos o incluso el uso de simples delegados.

terminé usando un par de sus ideas y escribir un ActionTextWriter que puede manejar más de un delegado, y pensé que iba a compartir aquí:

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

Puede añadir tantas acciones como desee . En este ejemplo se escribe en un archivo de registro y la consola en Visual Studio a través de 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); 

Y por supuesto, si usted quiere hacer más simples de usar fruto de la casualidad, siempre se puede extender ActionTextWriter .. . escribir el enfoque genérico y la reutilización, ¿verdad?

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