So erhalten Sie die TSQL -Abfrage von linq Datacontext.subMitchanges ()

Question

Ich benutze Linq nach SQL. Ich habe einen DataContext, gegen den ich subMitchanges () 'ing bin. Es gibt einen Fehler, der das Identitätsfeld einfügt, und ich würde gerne die Abfrage sehen, mit der dieses Identitätsfeld eingefügt wird.

Ich sehe die Abfrage selbst in der QuickWatch nicht. Wo finde ich es innerhalb des Debuggers?

Answer 1

Es gibt tatsächlich eine sehr einfache Antwort auf Ihre Frage

Fügen Sie dies einfach in Ihr Uhrenfenster ein

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

Answer 2

Viele Leute haben ihren eigenen "Debugwriter" geschrieben und sie so angehängt:

// 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 gibt alles aus, was Linq-to-SQL in das Debug-Fenster von Visual Studio macht.

Answer 3

Weiter Portmans Antwort, Wenn Sie eine Konsolenanwendung sind, ist es so einfach:

myDataContext.Log = Console.Out;

Oder Sie können so etwas wie ein linq2SQL -Profiler verwenden, was ein ziemlich ausgezeichnetes Werkzeug ist und tatsächlich das richtige Werkzeug für den Job:

LINQ an SQL Profiler - Visual Debugger für LINQ zu SQL

Answer 4

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

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

Ich bin damit einverstanden, dass LINQ zu SQL Profiler das richtige Werkzeug für diesen Job ist. Aber wenn Sie das Geld nicht ausgeben möchten oder nur etwas Einfaches tun müssen, mag ich den Debugtextwriter -Ansatz.

Nachdem ich diese Frage gelesen hatte, suchte ich nach etwas Robsterem. Es stellt sich auch als Damien Guard heraus schrieb einen sehr schönen Artikel über das Erstellen verschiedener Autoren, um sich mit verschiedenen Dingen wie dem Speicher, Debug, einer Datei, mehreren Zielen oder sogar mit einfachen Delegierten zu befassen.

Ich habe ein paar seiner Ideen verwendet und einen ActionTextWriter geschrieben, der mehr als einen Delegierten bearbeiten kann, und ich dachte, ich würde es hier teilen:

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 hinzufügen, wie Sie möchten. 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 können Sie immer, wenn Sie einfacher machen möchten, die Manschette zu verwenden erweitern ActionTextWriter ... Schreiben Sie den generischen Ansatz und die Wiederverwendung, 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

Hier ist eine detaillierte Beschreibung: http://debugmode.net/2011/06/26/logging-in-linq-t-sql/