Dla osób korzystających z Entity Framework 6 i nowszych, jeśli chcesz wyświetlić wyjściowy SQL w Visual Studio (tak jak ja), musisz użyć nowej funkcji rejestrowania/przechwytywania.

Dodanie następującej linii spowoduje wyplucie wygenerowanego SQL (wraz z dodatkowymi szczegółami związanymi z wykonaniem) w Panelu wyjściowym Visual Studio:

using (MyDatabaseEntities context = new MyDatabaseEntities())
{
    context.Database.Log = s => System.Diagnostics.Debug.WriteLine(s);
    // query the database using EF here.
}

Więcej informacji o logowaniu w EF6 w tej serii bloga: http://blog.oneunicorn.com/2013/05/08/ef6-sql-logging-part-1-simple-logging/

Uwaga: Upewnij się, że projekt jest uruchamiany w trybie debugowania.

Począwszy od EF6. 1 Możesz używać Interceptorów do rejestracji rejestratora bazy danych. Zobacz rozdziały "przechwytywanie" i "rejestrowanie operacji na bazie danych" do pliku tutaj

<interceptors> 
  <interceptor type="System.Data.Entity.Infrastructure.Interception.DatabaseLogger, EntityFramework"> 
    <parameters> 
      <parameter value="C:\Temp\LogOutput.txt"/> 
      <parameter value="true" type="System.Boolean"/> 
    </parameters> 
  </interceptor> 
</interceptors>

Jeśli używasz DbContext, możesz wykonać następujące czynności, aby uzyskać SQL:

var result = from i in myContext.appEntities
             select new Model
             {
                 field = i.stuff,
             };
var sql = result.ToString();

Dotyczy EF 6.0 i nowszych: Dla tych z Was, którzy chcą dowiedzieć się więcej na temat funkcji logowania i dodawania do niektórych już udzielonych odpowiedzi.

Każde polecenie wysłane z EF do bazy danych może być teraz rejestrowane. Aby wyświetlić wygenerowane zapytania z EF 6.x, Użyj DBContext.Database.Log property

Co Jest Rejestrowane

 - SQL for all different kinds of commands. For example:
    - Queries, including normal LINQ queries, eSQL queries, and raw queries from methods such as SqlQuery.
    - Inserts, updates, and deletes generated as part of SaveChanges
    - Relationship loading queries such as those generated by lazy loading
 - Parameters
 - Whether or not the command is being executed asynchronously
 - A timestamp indicating when the command started executing
 - Whether or not the command completed successfully, failed by throwing an exception, or, for async, was canceled
 - Some indication of the result value
 - The approximate amount of time it took to execute the command. Note that this is the time from sending the command to getting the result object back. It does not include time to read the results.

Przykład:

using (var context = new BlogContext()) 
{ 
    context.Database.Log = Console.Write; 

    var blog = context.Blogs.First(b => b.Title == "One Unicorn"); 

    blog.Posts.First().Title = "Green Eggs and Ham"; 

    blog.Posts.Add(new Post { Title = "I do not like them!" }); 

    context.SaveChangesAsync().Wait(); 
}

Wyjście:

SELECT TOP (1)
    [Extent1].[Id] AS [Id],
    [Extent1].[Title] AS [Title]
    FROM [dbo].[Blogs] AS [Extent1]
    WHERE (N'One Unicorn' = [Extent1].[Title]) AND ([Extent1].[Title] IS NOT NULL)
-- Executing at 10/8/2013 10:55:41 AM -07:00
-- Completed in 4 ms with result: SqlDataReader

SELECT
    [Extent1].[Id] AS [Id],
    [Extent1].[Title] AS [Title],
    [Extent1].[BlogId] AS [BlogId]
    FROM [dbo].[Posts] AS [Extent1]
    WHERE [Extent1].[BlogId] = @EntityKeyValue1
-- EntityKeyValue1: '1' (Type = Int32)
-- Executing at 10/8/2013 10:55:41 AM -07:00
-- Completed in 2 ms with result: SqlDataReader

UPDATE [dbo].[Posts]
SET [Title] = @0
WHERE ([Id] = @1)
-- @0: 'Green Eggs and Ham' (Type = String, Size = -1)
-- @1: '1' (Type = Int32)
-- Executing asynchronously at 10/8/2013 10:55:41 AM -07:00
-- Completed in 12 ms with result: 1

INSERT [dbo].[Posts]([Title], [BlogId])
VALUES (@0, @1)
SELECT [Id]
FROM [dbo].[Posts]
WHERE @@ROWCOUNT > 0 AND [Id] = scope_identity()
-- @0: 'I do not like them!' (Type = String, Size = -1)
-- @1: '1' (Type = Int32)
-- Executing asynchronously at 10/8/2013 10:55:41 AM -07:00
-- Completed in 2 ms with result: SqlDataReader

Aby zalogować się do zewnętrznego plik:

using (var context = new BlogContext()) 
{  
    using (var sqlLogFile = new StreamWriter("C:\\temp\\LogFile.txt"))
    {          
         context.Database.Log = sqlLogFile.Write;     
         var blog = context.Blogs.First(b => b.Title == "One Unicorn"); 
         blog.Posts.First().Title = "Green Eggs and Ham"; 
         context.SaveChanges();
   }
}

Więcej informacji tutaj: rejestrowanie i przechwytywanie operacji bazy danych

W EF 4.1 możesz wykonać następujące czynności:

var result = from x in appEntities
             where x.id = 32
             select x;

System.Diagnostics.Trace.WriteLine(result .ToString());

To da ci wygenerowany SQL.

Moja odpowiedź dotyczy EF core. Odwołuję się do tego problemu z githubem i docs on configuring DbContext:

Proste

Zastąp metodę OnConfiguring twojej klasy DbContext(YourCustomDbContext) Jak pokazano tutaj aby użyć ConsoleLoggerProvider; Twoje zapytania powinny logować się do konsoli:

public class YourCustomDbContext : DbContext
{
    #region DefineLoggerFactory
    public static readonly LoggerFactory MyLoggerFactory
        = new LoggerFactory(new[] {new ConsoleLoggerProvider((_, __) => true, true)});
    #endregion


    #region RegisterLoggerFactory
    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
        => optionsBuilder
            .UseLoggerFactory(MyLoggerFactory); // Warning: Do not create a new ILoggerFactory instance each time                
    #endregion
}

Kompleks

Ten złożony przypadek pozwala uniknąć nadpisania DbContext OnConfiguring metoda., który jest zniechęcany w docs: "Takie podejście nie nadaje się do testowania, chyba że testy są ukierunkowane na pełną bazę danych."

Ten złożony przypadek wykorzystuje:

• metoda IServiceCollection w Startup klasa ConfigureServices (zamiast nadpisywać metodę OnConfiguring; korzyścią jest luźniejsze sprzężenie pomiędzy DbContext i ILoggerProvider, których chcesz użyć)
• implementacja ILoggerProvider (zamiast używać ConsoleLoggerProvider implementacja pokazana powyżej; benefit is our implementation shows how we would log to File (I don ' t see a File Dostawca logowania dostarczony z rdzeniem EF))

Tak:

public class Startup

    public void ConfigureServices(IServiceCollection services)
    {
        ...
        var lf = new LoggerFactory();
        lf.AddProvider(new MyLoggerProvider());

        services.AddDbContext<YOUR_DB_CONTEXT>(optionsBuilder => optionsBuilder
                .UseSqlServer(connection_string)
                //Using the LoggerFactory 
                .UseLoggerFactory(lf));
        ...
    }
}

Oto implementacja MyLoggerProvider (i jej MyLogger, która dołącza swoje logi do pliku, który możesz skonfigurować; Twoje zapytania EF Core pojawią się w pliku.)

public class MyLoggerProvider : ILoggerProvider
{
    public ILogger CreateLogger(string categoryName)
    {
        return new MyLogger();
    }

    public void Dispose()
    { }

    private class MyLogger : ILogger
    {
        public bool IsEnabled(LogLevel logLevel)
        {
            return true;
        }

        public void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception exception, Func<TState, Exception, string> formatter)
        {
            File.AppendAllText(@"C:\temp\log.txt", formatter(state, exception));
            Console.WriteLine(formatter(state, exception));
        }

        public IDisposable BeginScope<TState>(TState state)
        {
            return null;
        }
    } 
}

Są dwa sposoby:

1. aby wyświetlić wygenerowany SQL, po prostu wywołaj ToTraceString(). Możesz dodać go do okna obserwuj i ustawić punkt przerwania, aby zobaczyć, jakie będzie zapytanie w danym punkcie dla dowolnego zapytania LINQ.
2. możesz dołączyć znacznik do wybranego serwera SQL, który pokaże Ci ostateczne zapytanie w wszystkich jego krwawych szczegółach. W przypadku MySQL, najprostszym sposobem śledzenia zapytań jest po prostu śledzenie dziennika zapytań za pomocą tail -f. Możesz dowiedzieć się więcej o MySQL ' s urządzenia rejestrujące w oficjalnej dokumentacji . W przypadku SQL Server najprostszym sposobem jest użycie dołączonego SQL Server profiler.

Aby zapytanie było zawsze pod ręką, bez zmiany kodu dodaj to do DbContext i zaznacz to w oknie wyjściowym w visual studio.

    protected override void OnModelCreating(DbModelBuilder modelBuilder)
    {
        Database.Log = (query)=> Debug.Write(query);
    }

Podobne do @ Matt Nibecker answer, ale dzięki temu nie musisz dodawać go do bieżącego kodu, za każdym razem, gdy potrzebujesz zapytania.

EF Core 5.0

Ta oczekiwana na loooong funkcja jest dostępna w EF Core 5.0! To z cotygodniowych aktualizacji statusu :

var query = context.Set<Customer>().Where(c => c.City == city);
Console.WriteLine(query.ToQueryString())

Wyniki tego wyjścia podczas korzystania z dostawcy bazy danych SQL Server:

DECLARE p0 nvarchar(4000) = N'London';

SELECT [c].[CustomerID], [c].[Address], [c].[City], [c].[CompanyName],
[c].[ContactName], [c].[ContactTitle], [c].[Country], [c].[Fax], [c].[Phone],
[c].[PostalCode], [c].[Region]
FROM [Customers] AS [c]
WHERE [c].[City] = @__city_0

Zauważ, że deklaracje parametrów właściwego typu są również zawarte w wyjściu. Pozwala to na kopiowanie/wklejanie do serwera SQL Studio zarządzania, lub podobne narzędzia, takie, że zapytanie może być wykonane za debugowanie/analiza.

Woohoo!!!

Robię test integracji i potrzebowałem go do debugowania Wygenerowanej instrukcji SQL w Entity Framework Core 2.1, więc używam DebugLoggerProvider lub ConsoleLoggerProvider w następujący sposób:

[Fact]
public async Task MyAwesomeTest
    {
        //setup log to debug sql queries
        var loggerFactory = new LoggerFactory();
        loggerFactory.AddProvider(new DebugLoggerProvider());
        loggerFactory.AddProvider(new ConsoleLoggerProvider(new ConsoleLoggerSettings()));

        var builder = new DbContextOptionsBuilder<DbContext>();
        builder
            .UseSqlServer("my connection string") //"Server=.;Initial Catalog=TestDb;Integrated Security=True"
            .UseLoggerFactory(loggerFactory);

        var dbContext = new DbContext(builder.Options);

        ........

SQL Management Studio = > narzędzia = > SQL Server profiler

File = > New Trace...

Użyj szablonu = > Blank

Event selection = > T-SQL

Lefthandside sprawdź dla: SP.StmtComplete

Filtry kolumnowe mogą być użyte do wybrania konkretnej nazwy aplikacji lub nazwy bazy danych

Uruchom ten profil, a następnie uruchom zapytanie.

Kliknij tutaj, aby Informacje źródłowe

IQueryable query = from x in appEntities
                   where x.id = 32
                   select x;
var queryString = query.ToString();

Zwróci zapytanie sql. Praca przy użyciu datacontext z EntityFramework 6

Cóż, w tej chwili używam do tego celu Express profiler, wadą jest to, że działa tylko na MS SQL Server. Możesz znaleźć to narzędzie tutaj: https://expressprofiler.codeplex.com/

Nekromancja.
Ta strona jest pierwszym wynikiem wyszukiwania podczas wyszukiwania rozwiązania dla dowolnego. NET Framework, więc tutaj jako usługa publiczna, Jak to się robi w EntityFramework Core (dla. Net Core 1 & 2):

var someQuery = (
    from projects in _context.projects
    join issues in _context.issues on projects.Id equals issues.ProjectId into tmpMapp
    from issues in tmpMapp.DefaultIfEmpty()
    select issues
) //.ToList()
;

// string sql = someQuery.ToString();
// string sql = Microsoft.EntityFrameworkCore.IQueryableExtensions.ToSql(someQuery);
// string sql = Microsoft.EntityFrameworkCore.IQueryableExtensions1.ToSql(someQuery);
// using Microsoft.EntityFrameworkCore;
string sql = someQuery.ToSql();
System.Console.WriteLine(sql);

A następnie te metody rozszerzeń (IQueryableExtensions1 dla. NET Core 1.0, IQueryableExtensions dla. NET Core 2.0):

using System;
using System.Linq;
using System.Reflection;
using Microsoft.EntityFrameworkCore.Internal;
using Microsoft.EntityFrameworkCore.Query;
using Microsoft.EntityFrameworkCore.Query.Internal;
using Microsoft.EntityFrameworkCore.Storage;
using Remotion.Linq.Parsing.Structure;


namespace Microsoft.EntityFrameworkCore
{

    // https://stackoverflow.com/questions/1412863/how-do-i-view-the-sql-generated-by-the-entity-framework
    // http://rion.io/2016/10/19/accessing-entity-framework-core-queries-behind-the-scenes-in-asp-net-core/

    public static class IQueryableExtensions
    {
        private static readonly TypeInfo QueryCompilerTypeInfo = typeof(QueryCompiler).GetTypeInfo();

        private static readonly FieldInfo QueryCompilerField = typeof(EntityQueryProvider).GetTypeInfo().DeclaredFields
            .First(x => x.Name == "_queryCompiler");

        private static readonly PropertyInfo NodeTypeProviderField =
            QueryCompilerTypeInfo.DeclaredProperties.Single(x => x.Name == "NodeTypeProvider");

        private static readonly MethodInfo CreateQueryParserMethod =
            QueryCompilerTypeInfo.DeclaredMethods.First(x => x.Name == "CreateQueryParser");

        private static readonly FieldInfo DataBaseField =
            QueryCompilerTypeInfo.DeclaredFields.Single(x => x.Name == "_database");

        private static readonly PropertyInfo DatabaseDependenciesField =
            typeof(Database).GetTypeInfo().DeclaredProperties.Single(x => x.Name == "Dependencies");

        public static string ToSql<TEntity>(this IQueryable<TEntity> query) where TEntity : class
        {
            if (!(query is EntityQueryable<TEntity>) && !(query is InternalDbSet<TEntity>))
            {
                throw new ArgumentException("Invalid query");
            }

            var queryCompiler = (QueryCompiler) QueryCompilerField.GetValue(query.Provider);
            var nodeTypeProvider = (INodeTypeProvider) NodeTypeProviderField.GetValue(queryCompiler);
            var parser = (IQueryParser) CreateQueryParserMethod.Invoke(queryCompiler, new object[] {nodeTypeProvider});
            var queryModel = parser.GetParsedQuery(query.Expression);
            var database = DataBaseField.GetValue(queryCompiler);
            var databaseDependencies = (DatabaseDependencies) DatabaseDependenciesField.GetValue(database);
            var queryCompilationContext = databaseDependencies.QueryCompilationContextFactory.Create(false);
            var modelVisitor = (RelationalQueryModelVisitor) queryCompilationContext.CreateQueryModelVisitor();
            modelVisitor.CreateQueryExecutor<TEntity>(queryModel);
            var sql = modelVisitor.Queries.First().ToString();

            return sql;
        }
    }



    public class IQueryableExtensions1
    {
        private static readonly TypeInfo QueryCompilerTypeInfo = typeof(QueryCompiler).GetTypeInfo();

        private static readonly FieldInfo QueryCompilerField = typeof(EntityQueryProvider).GetTypeInfo()
            .DeclaredFields
            .First(x => x.Name == "_queryCompiler");

        private static readonly PropertyInfo NodeTypeProviderField =
            QueryCompilerTypeInfo.DeclaredProperties.Single(x => x.Name == "NodeTypeProvider");

        private static readonly MethodInfo CreateQueryParserMethod =
            QueryCompilerTypeInfo.DeclaredMethods.First(x => x.Name == "CreateQueryParser");

        private static readonly FieldInfo DataBaseField =
            QueryCompilerTypeInfo.DeclaredFields.Single(x => x.Name == "_database");

        private static readonly FieldInfo QueryCompilationContextFactoryField = typeof(Database).GetTypeInfo()
            .DeclaredFields.Single(x => x.Name == "_queryCompilationContextFactory");


        public static string ToSql<TEntity>(IQueryable<TEntity> query) where TEntity : class
        {
            if (!(query is EntityQueryable<TEntity>) && !(query is InternalDbSet<TEntity>))
            {
                throw new ArgumentException("Invalid query");
            }

            var queryCompiler = (IQueryCompiler) QueryCompilerField.GetValue(query.Provider);

            var nodeTypeProvider = (INodeTypeProvider) NodeTypeProviderField.GetValue(queryCompiler);
            var parser =
                (IQueryParser) CreateQueryParserMethod.Invoke(queryCompiler, new object[] {nodeTypeProvider});
            var queryModel = parser.GetParsedQuery(query.Expression);
            var database = DataBaseField.GetValue(queryCompiler);
            var queryCompilationContextFactory =
                (IQueryCompilationContextFactory) QueryCompilationContextFactoryField.GetValue(database);
            var queryCompilationContext = queryCompilationContextFactory.Create(false);
            var modelVisitor = (RelationalQueryModelVisitor) queryCompilationContext.CreateQueryModelVisitor();
            modelVisitor.CreateQueryExecutor<TEntity>(queryModel);
            var sql = modelVisitor.Queries.First().ToString();

            return sql;
        }


    }


}

Użyj logowania z Entity Framework Core 3.x

Entity Framework Core emituje SQL poprzez system logowania. Jest tylko kilka małych sztuczek. Musisz podać ILoggerFactory oraz filtr. Oto przykład z tego artykułu

Utwórz fabrykę:

var loggerFactory = LoggerFactory.Create(builder =>
{
    builder
    .AddConsole((options) => { })
    .AddFilter((category, level) =>
        category == DbLoggerCategory.Database.Command.Name
        && level == LogLevel.Information);
});

Tell the DbContext to use the factory in the OnConfiguring method:

optionsBuilder.UseLoggerFactory(_loggerFactory);

Stąd możesz uzyskać o wiele bardziej wyrafinowany i zahaczyć o metodę Log, aby wyodrębnić szczegóły dotyczące wykonywanego SQL. Zobacz artykuł do pełnej dyskusji.

public class EntityFrameworkSqlLogger : ILogger
{
    #region Fields
    Action<EntityFrameworkSqlLogMessage> _logMessage;
    #endregion
    #region Constructor
    public EntityFrameworkSqlLogger(Action<EntityFrameworkSqlLogMessage> logMessage)
    {
        _logMessage = logMessage;
    }
    #endregion
    #region Implementation
    public IDisposable BeginScope<TState>(TState state)
    {
        return default;
    }
    public bool IsEnabled(LogLevel logLevel)
    {
        return true;
    }
    public void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception exception, Func<TState, Exception, string> formatter)
    {
        if (eventId.Id != 20101)
        {
            //Filter messages that aren't relevant.
            //There may be other types of messages that are relevant for other database platforms...
            return;
        }
        if (state is IReadOnlyList<KeyValuePair<string, object>> keyValuePairList)
        {
            var entityFrameworkSqlLogMessage = new EntityFrameworkSqlLogMessage
            (
                eventId,
                (string)keyValuePairList.FirstOrDefault(k => k.Key == "commandText").Value,
                (string)keyValuePairList.FirstOrDefault(k => k.Key == "parameters").Value,
                (CommandType)keyValuePairList.FirstOrDefault(k => k.Key == "commandType").Value,
                (int)keyValuePairList.FirstOrDefault(k => k.Key == "commandTimeout").Value,
                (string)keyValuePairList.FirstOrDefault(k => k.Key == "elapsed").Value
            );
            _logMessage(entityFrameworkSqlLogMessage);
        }
    }
    #endregion
}

Dla mnie, używając EF6 i Visual Studio 2015 wpisałem query w oknie immediate i dało mi wygenerowane polecenie SQL

W moim przypadku dla EF 6+, zamiast użyć tego w oknie natychmiastowym, aby znaleźć ciąg zapytania:

var sql = ((System.Data.Entity.Core.Objects.ObjectQuery)query).ToTraceString();

Skończyło się na tym, że musiałem użyć tego, aby uzyskać wygenerowane polecenie SQL:

var sql = ((System.Data.Entity.Infrastructure.DbQuery<<>f__AnonymousType3<string,string,string,short,string>>)query).ToString();

Oczywiście twój anonimowy podpis może być inny.

HTH.

Właśnie to zrobiłem:

IQueryable<Product> query = EntitySet.Where(p => p.Id == id);
Debug.WriteLine(query);

I wynik pokazany na wyjściu :

SELECT 
    [Extent1].[Id] AS [Id], 
    [Extent1].[Code] AS [Code], 
    [Extent1].[Name] AS [Name], 
    [Extent2].[Id] AS [Id1], 
    [Extent2].[FileName] AS [FileName], 
    FROM  [dbo].[Products] AS [Extent1]
    INNER JOIN [dbo].[PersistedFiles] AS [Extent2] ON [Extent1].[PersistedFileId] = [Extent2].[Id]
    WHERE [Extent1].[Id] = @p__linq__0

Chociaż są tu dobre odpowiedzi, żaden nie rozwiązał mojego problemu całkowicie (chciałem uzyskać całe polecenie SQL, wraz z parametrami, z DbContext z dowolnego IQueryable. Poniższy kod właśnie to robi. Jest to kombinacja fragmentów kodu z Google. Przetestowałem go tylko z EF6+.

Najpierw użycie. Będziesz potrzebować wyraźne odniesienie do " System.Data./ Align = "left" / dll".

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Data.SqlClient;
using System.Data.Common;
using System.Data.Entity.Core.Objects;
using System.Data.Entity;
using System.Data;
using System.Data.Entity.Infrastructure;
using System.Reflection;

Następująca Klasa zamienia IQueryable na DataTable. Modyfikuj w zależności od potrzeb:

public class EntityFrameworkCommand
{
    DbContext Context;

    string SQL;

    ObjectParameter[] Parameters;

    public EntityFrameworkCommand Initialize<T>(DbContext context, IQueryable<T> query)
    {
        Context = context;
        var dbQuery = query as DbQuery<T>;
        // get the IInternalQuery internal variable from the DbQuery object
        var iqProp = dbQuery.GetType().GetProperty("InternalQuery", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public);
        var iq = iqProp.GetValue(dbQuery, null);
        // get the ObjectQuery internal variable from the IInternalQuery object
        var oqProp = iq.GetType().GetProperty("ObjectQuery", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public);
        var objectQuery = oqProp.GetValue(iq, null) as ObjectQuery<T>;
        SQL = objectQuery.ToTraceString();
        Parameters = objectQuery.Parameters.ToArray();
        return this;
    }

    public DataTable GetData()
    {
        DataTable dt = new DataTable();
        var connection = Context.Database.Connection;
        var state = connection.State;
        if (!(state == ConnectionState.Open))
            connection.Open();
        using (var cmd = connection.CreateCommand())
        {
            cmd.CommandText = SQL;
            cmd.Parameters.AddRange(Parameters.Select(p => new SqlParameter("@" + p.Name, p.Value)).ToArray());
            using (var da = DbProviderFactories.GetFactory(connection).CreateDataAdapter())
            {
                da.SelectCommand = cmd;
                da.Fill(dt);
            }
        }
        if (!(state == ConnectionState.Open))
            connection.Close();
        return dt;
    }
}

Aby użyć, po prostu zadzwoń jak poniżej:

var context = new MyContext();
var data = ....//Query, return type can be anonymous
    .AsQueryable();
var dt = new EntityFrameworkCommand()
    .Initialize(context, data)
    .GetData();

Jeśli chcesz mieć wartości parametrów (nie tylko @p_linq_0 ale także ich wartości), możesz użyć IDbCommandInterceptor i dodać trochę logowania do metody ReaderExecuted.

Entity Framework 4 Solution

Większość odpowiedzi była specyficzna dla EF6. Oto jeden dla tych z Was, którzy nadal używają EF4.

Ta metoda zastępuje @p__linq__0 / etc. parametry z ich rzeczywistymi wartościami, więc możesz po prostu skopiować i wkleić wyjście do SSMS i uruchomić go lub debugować.

    /// <summary>
    /// Temporary debug function that spits out the actual SQL query LINQ is generating (with parameters)
    /// </summary>
    /// <param name="q">IQueryable object</param>
    private string Debug_GetSQLFromIQueryable<T>(IQueryable<T> q)
    {
        System.Data.Objects.ObjectQuery oq = (System.Data.Objects.ObjectQuery)q;
        var result = oq.ToTraceString();
        List<string> paramNames = new List<string>();
        List<string> paramVals = new List<string>();
        foreach (var parameter in oq.Parameters)
        {
            paramNames.Add(parameter.Name);
            paramVals.Add(parameter.Value == null ? "NULL" : ("'" + parameter.Value.ToString() + "'"));
        }
        //replace params in reverse order, otherwise @p__linq__1 incorrectly replaces @p__linq__10 for instance
        for (var i = paramNames.Count - 1; i >= 0; i--)
        {
            result = result.Replace("@" + paramNames[i], paramVals[i]);
        }
        return result;
    }