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

Question

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

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

Answer 1

En realidad, hay una respuesta muy simple a su pregunta

Solo pega esto en la ventana de tu reloj

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

Answer 2

Mucha gente ha estado escribiendo su propio " DebugWriter " y adjuntándolo así:

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

Esto mostrará todo lo que Linq-to-Sql está haciendo en la ventana de depuración de Visual Studio.

Answer 3

Además de La respuesta de Portman , si eres una aplicación de consola, es tan simple como:

myDataContext.Log = Console.Out;

O podría usar algo como Linq2SQL Profiler, que es una herramienta bastante excelente y, de hecho, la herramienta adecuada para el trabajo:

  

Linq to SQL Profiler: depurador visual en tiempo real para Linq a SQL

Answer 4

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

Answer 5

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

Answer 6

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

Después de leer esta pregunta, salí a buscar algo más robusto. Resulta que Damien Guard también escribió un artículo muy agradable sobre la creación de diferentes escritores para tratar diferentes cosas como la salida a memoria, depuración, un archivo, múltiples destinos, o incluso el uso de delegados simples.

Terminé usando un par de sus ideas y escribiendo un ActionTextWriter que puede manejar más de un delegado, y pensé en compartirlo 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 agregar tantas acciones como desee. Este ejemplo 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 desea simplificar el uso, siempre puede extender ActionTextWriter ... escribir el enfoque genérico y reutilizar, ¿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

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