Comment obtenir la requête SQL à partir de LINQ DataContext.SubmitChanges ()

Question

J'utilise Linq to SQL. J'ai un DataContext contre lequel je suis. SubmitChanges () 'ing. Une erreur est survenue lors de l'insertion du champ d'identité. J'aimerais voir la requête utilisée pour insérer ce champ d'identité.

Je ne vois pas la requête elle-même dans le quickwatch; Où puis-je le trouver dans le débogueur?

Answer 1

Il existe en fait une réponse très simple à votre question

Il suffit de coller ceci dans la fenêtre de surveillance

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

Answer 2

Beaucoup de gens ont écrit leur propre " DebugWriter " et l'attacher comme si:

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

Ceci affichera tout ce que Linq-to-Sql est en train de faire dans la fenêtre de débogage de Visual Studio.

Answer 3

Suite à réponse de Portman , si vous êtes une application console, c’est aussi simple que:

myDataContext.Log = Console.Out;

Ou vous pouvez utiliser quelque chose comme Linq2SQL Profiler qui est un excellent outil et en fait le bon outil pour le travail:

  

Profiler de Linq en SQL - Débogueur visuel en temps réel pour Linq vers SQL

Answer 4

Exécutez SQL Profiler si vous l’avez. Tout le trafic sur votre base de données sera affiché, y compris le texte de la commande 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

Je conviens que Linq to SQL Profiler est le bon outil pour ce travail. Mais si vous ne voulez pas dépenser de l'argent ou si vous avez juste besoin de faire quelque chose de simple, j'aime bien l'approche DebugTextWriter.

Après avoir lu cette question, je suis parti à la recherche de quelque chose de plus robuste. Il s'avère que Damien Guard a également a écrit un très bon article sur la création d’écrivains différents qui traitent de choses différentes, telles que la sortie en mémoire, le débogage, un fichier, plusieurs destinations ou même l’utilisation de simples délégués.

J'ai fini par utiliser quelques-unes de ses idées et écrire un ActionTextWriter pouvant gérer plus d'un délégué, et j'ai pensé le partager ici:

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

Vous pouvez ajouter autant d’actions que vous le souhaitez. Cet exemple écrit dans un fichier journal et dans la console de 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);

Et bien sûr, si vous souhaitez simplifier l'utilisation à la volée, vous pouvez toujours étendre ActionTextWriter ... écrire l'approche générique et la réutiliser, n'est-ce pas?

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

Voici une description détaillée: http: // debugmode. net / 2011/06/26 / logging-in-linq-to-sql /