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

Question

Sto usando Linq to SQL. Ho un DataContext contro il quale 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

In realtà esiste una risposta molto semplice alla tua domanda

Basta incollarlo nella finestra dell'orologio

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

Answer 2

Molte persone hanno scritto il proprio " DebugWriter " e allegandolo 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()

Questo produrrà tutto ciò che Linq-to-Sql sta facendo nella finestra di debug di Visual Studio.

Answer 3

Oltre a Risposta di Portman , se sei un'applicazione console è semplice come:

myDataContext.Log = Console.Out;

Oppure potresti usare qualcosa come Linq2SQL Profiler che è uno strumento piuttosto eccellente e in effetti lo strumento giusto per il lavoro:

  

Linq to SQL Profiler - Debugger visivo in tempo reale per Linq a SQL

Answer 4

Esegui SQL Profiler se ce l'hai. Mostrerà tutto il traffico al tuo database, incluso il testo 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

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

Dopo aver letto questa domanda sono andato alla ricerca di qualcosa di più robusto. Si scopre che Damien Guard ha anche ha scritto un articolo molto carino sulla costruzione di diversi scrittori per gestire cose diverse come l'output su Memory, Debug, un File, Multiple Destinations o persino usando semplici Delegati.

Ho finito usando un paio di sue idee e scrivendo un ActionTextWriter in grado di gestire più di un delegato, e ho pensato di condividerlo 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);
            }
        }
    }
}

Puoi aggiungere tutte le azioni che vuoi. Questo esempio scrive su un file di registro e sulla console in Visual Studio tramite 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 vuoi renderne più semplice l'uso fuori dal bracciale, puoi sempre estendere ActionTextWriter ... scrivere l'approccio generico e riutilizzarlo, 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

Ecco una descrizione dettagliata: http: // debugmode. net / 2011/06/26 / logging-in-LINQ to SQL /