Entity Framework 4.1 - EFTracingProvider

Question

¿Hay alguna forma de que el EFTracing provider funcione con EF 4.1?

EFTracing parece necesitar un objectcontext y yo uso dbcontext.

¡Gracias de antemano!

Answer 1

Sí, puedes. Estoy usando el community version con los primeros DbContexts de base de datos y los DbContexts de primer código. Esta respuesta se basa en un discussion thread en el sitio del proyecto.

Para DbContexts/diseñador de bases de datos y uno (a través de ADO.NET DbContext Generator templates), sólo tiene que añadir el siguiente constructor:

public abstract class MyDbContext : DbContext 
{ 
    protected MyDbContext(string nameOrConnectionString) 
     : base(EFTracingProviderUtils.CreateTracedEntityConnection(nameOrConnectionString), true) 
    { 
     // enable sql tracing 
     ((IObjectContextAdapter) this).ObjectContext.EnableTracing(); 
    } 
} 

Para el código de primera DbContexts es un poco más complicado ya que el EFTracingProvider quiere una cadena de conexión entidad completa. Debe crear una instancia de EFTracingConnection manualmente. El siguiente ejemplo funcionará tanto para la base de datos primero como para el primer contexto de código.

public abstract class MyDbContext : DbContext 
{ 
    protected MyDbContext(string nameOrConnectionString) 
     : base(CreateTracingConnection(nameOrConnectionString), true) 
    { 
     // enable sql tracing 
     ((IObjectContextAdapter) this).ObjectContext.EnableTracing(); 
    } 

    private static DbConnection CreateTracingConnection(string nameOrConnectionString) 
    { 
     try 
     { 
      // this only supports entity connection strings http://msdn.microsoft.com/en-us/library/cc716756.aspx 
      return EFTracingProviderUtils.CreateTracedEntityConnection(nameOrConnectionString); 
     } 
     catch (ArgumentException) 
     { 
      // an invalid entity connection string is assumed to be a normal connection string name or connection string (Code First) 

      ConnectionStringSettings connectionStringSetting = 
       ConfigurationManager.ConnectionStrings[nameOrConnectionString]; 
      string connectionString; 
      string providerName; 

      if (connectionStringSetting != null) 
      { 
       connectionString = connectionStringSetting.ConnectionString; 
       providerName = connectionStringSetting.ProviderName; 
      } 
      else 
      { 
       providerName = "System.Data.SqlClient"; 
       connectionString = nameOrConnectionString; 
      } 

      return CreateTracingConnection(connectionString, providerName); 
     } 
    } 

    private static EFTracingConnection CreateTracingConnection(string connectionString, string providerInvariantName) 
    { 
     // based on the example at http://jkowalski.com/2010/04/23/logging-sql-statements-in-entity-frameworkcode-first/ 
     string wrapperConnectionString = 
      String.Format(@"wrappedProvider={0};{1}", providerInvariantName, connectionString); 

     EFTracingConnection connection = 
      new EFTracingConnection 
       { 
        ConnectionString = wrapperConnectionString 
       }; 

     return connection; 
    } 
} 

Answer 2

Si está utilizando DBContext y MVC Modelo En primer lugar, es decir, utilizando EntityConnections entonces el siguiente ejemplo de código debería ser todo lo que necesita:

public partial class BrickHouseFitnessContext : DbContext 
{ 

    public BrickHouseFitnessContext(): base(EntityConnectionWrapperUtils.CreateEntityConnectionWithWrappers(ConfigurationManager.ConnectionStrings["BrickHouseFitnessContext"].ConnectionString, "EFTracingProvider"), true) 
    { 
    } 

también:

en el archivo Web.config añadir las siguientes secciones:

<system.data> 
<DbProviderFactories> 
    <add name="EF Tracing Data Provider" invariant="EFTracingProvider" description="Tracing Provider Wrapper" type="EFTracingProvider.EFTracingProviderFactory, EFTracingProvider, Version=1.0.0.0, Culture=neutral, PublicKeyToken=def642f226e0e59b" /> 
    <add name="EF Generic Provider Wrapper" invariant="EFProviderWrapper" description="Generic Provider Wrapper" type="EFProviderWrapperToolkit.EFProviderWrapperFactory, EFProviderWrapperToolkit, Version=1.0.0.0, Culture=neutral, PublicKeyToken=def642f226e0e59b" /> 
</DbProviderFactories> 

y:

<add key="EFTracingProvider.logToConsole" value="true" /> 
<add key="EFTracingProvider.logToFile" value="C:\BrickHouseFitnessSqlLog.txt" /> 

No hay ninguna necesidad de incluir los ExtendedEntities o la otra clase derivada ObjectContext mencionado en el artículo original. Ejecuta ese código y deberías ver tu archivo de registro como se especifica, con todos los comandos SQL en él. Estoy omitiendo la inicialización de la base de datos cuando el rastreo está habilitado,

Answer 3

Si bien las respuestas anteriores funcionan, las he encontrado problemáticas, una solución mucho más simple es usar el paquete Clutch.Diagnostics.EntityFramework de NuGet que usa MiniProfiler detrás de las escenas. Es significativamente más simple trabajar que EFTracingProvider, y es una solución mucho más flexible.

El proyecto se encuentra en GitHub en https://github.com/Kukkimonsuta/Clutch

Para EFTracingProvider como la funcionalidad instalar el paquete NuGet y luego implementar IDbTracingListener así:

using System; 
using System.Data.Common; 
using System.Diagnostics; 
using Clutch.Diagnostics.EntityFramework; 

/// <summary> 
/// 
/// </summary> 
public class DbTracingListener : IDbTracingListener 
{ 
    /// <summary> 
    /// 
    /// </summary> 
    /// <param name="connection"></param> 
    /// <param name="command"></param> 
    /// <param name="result"></param> 
    /// <param name="duration"></param> 
    public void CommandExecuted(DbConnection connection, DbCommand command, object result, TimeSpan duration) 
    { 
     Debug.WriteLine(command.CommandText); 
     Debug.WriteLine(string.Format("Executed in: {0}", duration)); 
    } 

    /// <summary> 
    /// 
    /// </summary> 
    /// <param name="connection"></param> 
    /// <param name="command"></param> 
    public void CommandExecuting(DbConnection connection, DbCommand command) 
    { 

    } 

    /// <summary> 
    /// 
    /// </summary> 
    /// <param name="connection"></param> 
    /// <param name="command"></param> 
    /// <param name="exception"></param> 
    /// <param name="duration"></param> 
    public void CommandFailed(DbConnection connection, DbCommand command, Exception exception, TimeSpan duration) 
    { 

    } 

    /// <summary> 
    /// 
    /// </summary> 
    /// <param name="connection"></param> 
    /// <param name="command"></param> 
    /// <param name="result"></param> 
    /// <param name="duration"></param> 
    public void CommandFinished(DbConnection connection, DbCommand command, object result, TimeSpan duration) 
    { 

    } 
}