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

Je suis en utilisant Linq to SQL. J'ai un DataContext contre qui je suis .SubmitChanges () ing. Il y a une erreur d'insérer le champ d'identité, et j'aimerais voir la requête c'est à l'aide d'insérer ce champ d'identité.

Je ne vois pas la requête elle-même au sein de l'espion express; où puis-je trouver dans le débogueur?

source d'informationauteur tsilb

  1. 8

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

    Il suffit de coller dans votre fenêtre d'observation

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

    Beaucoup de gens ont écrit leur propre "DebugWriter" et l'attacher de la sorte:

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

    Ce sera de sortie tout ce que Linq-to-Sql est en train de faire de Visual Studio fenêtre de débogage.

  3. 11

    Plus de Portman la réponse desi vous êtes une application de 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 l'outil idéal pour le travail:

    Linq to SQL Profiler - visuelles en temps Réel débogueur pour Linq to SQL

  4. 3

    Exécuter le générateur de profils SQL si vous l'avez. Il va montrer tout le trafic vers votre base de données, y compris le texte de la commande SQL.

  5. 1

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

    Après la lecture de cette question, je suis allé à la recherche de quelque chose de plus robuste. Il s'avère Damien Garde aussi a écrit un très bel article sur la construction de différents auteurs pour aborder les différentes choses comme la sortie de la Mémoire, de Débogage, d'un Fichier, des Destinations Multiples ou même en utilisant de simples Délégués.

    Je me suis retrouvé à l'aide d'un couple de ses idées et la rédaction d'un ActionTextWriter qui peut gérer plus d'un délégué, et j'ai pensé que je voudrais 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 la Console dans Visual Studio via le Debug.Écrire:

    //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 voulez faire plus simple à utiliser en improvisant, vous pouvez toujours étendre ActionTextWriter... écrire le générique de l'approche et de la réutilisation, à droite?

    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);
        }
    }
}
  6. 1
    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();
  7. 0

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