Comment enregistrer des requêtes à l'aide d'Entity Framework 7?

Je suis en utilisant Entity Framework 7 sur le canal nightly build (je suis en train d'utiliser la version EntityFramework.7.0.0-beta2-11524) et je suis en train de log de requêtes EF génère juste de la curiosité.

Je suis en train d'écrire un simple programme en mode console, j'ai essayé d'utiliser le même la journalisation technique que EF6 utilise, mais DbContext.Database.Logn'est pas disponible sur Entity Framework 7. Est-il un moyen de journal ou il suffit de prendre un coup d'oeil sur le SQL généré par EF7?

source d'informationauteur Mahmoud Ali

  1. 8

    Pour ceux qui utilisent EF7 aucun des ci-dessus a fonctionné pour moi. Mais c'est la façon dont je l'ai eu à travailler. (de @avi cherry commentaire)

    Dans votre de Démarrage.cs vous proably ont une méthode Configure avec un tas de configurations. Il devrait ressembler à ci-dessous (en plus de votre stuff).

        public void Configure(IApplicationBuilder app, ILoggerFactory loggerFactory)
    {
        //this is the magic line
        loggerFactory.AddDebug(LogLevel.Debug); //formerly LogLevel.Verbose

        //your other stuff

    }
  2. 7

    Vous pouvez vous connecter à la console en utilisant ce code, je suis sûr qu'il sera enveloppé dans une api simple plus tard:

    using System;
using Microsoft.Data.Entity.Infrastructure;
using Microsoft.Data.Entity.Utilities;
using Microsoft.Framework.Logging;

public static class SqlCeDbContextExtensions
{
    public static void LogToConsole(this DbContext context)
    {
        var loggerFactory = ((IAccessor<IServiceProvider>)context).GetService<ILoggerFactory>();
        loggerFactory.AddProvider(new DbLoggerProvider());
    }
}

    Et la DbLoggerProvider est mis en œuvre ici: https://github.com/ErikEJ/EntityFramework7.SqlServerCompact/tree/master/src/Provider40/Extensions/Logging

  3. 5

    J'ai du mal avec toutes les réponses ci-dessus, que l'EF bits ne cessait de changer, de sorte que le code ne compile pas. À compter d'aujourd'hui (19Feb2016) avec EF7.0.0-rc1-final (version Préliminaire) et SQLite, voici ce qui fonctionne pour moi:

    De la EF7 documentation:

    using System;
using System.IO;
using Microsoft.Extensions.Logging;

namespace EFLogging
{
    public class EFLoggerProvider : ILoggerProvider
    {
        public ILogger CreateLogger(string categoryName)
        {
            return new EFLogger();
        }

        public void Dispose()
        {
            //N/A
        }

        private class EFLogger : ILogger
        {
            public IDisposable BeginScopeImpl(object state)
            {
                return null;
            }

            public bool IsEnabled(LogLevel logLevel)
            {
                return true;
            }

            public void Log(LogLevel logLevel, int eventId, object state, Exception exception, Func<object, Exception, string> formatter)
            {
                File.AppendAllText(@".\EF.LOG", formatter(state, exception));
                Console.WriteLine(formatter(state, exception));
            }
        }
    }
}

    À l'aide de certaines des idées ci-dessus et la EF7 Docs:

    using System;
using Microsoft.Data.Entity;
using Microsoft.Data.Entity.Infrastructure;
using Microsoft.Extensions.DependencyInjection;  //Add this to EF7 docs code
using Microsoft.Extensions.Logging;

namespace DataAccessLayer
{
    public static class DbContextExtensions
    {
        public static void LogToConsole(this DbContext context)
        {
            var serviceProvider = context.GetInfrastructure<IServiceProvider>();
            var loggerFactory = serviceProvider.GetService<ILoggerFactory>();
            loggerFactory.AddProvider(new EFLoggerProvider(logLevel));
        }
    }
}

    EDIT: @jnm2 souligné si vous ajoutez "à l'aide de Microsoft.Extensions.DependencyInjection", le EF7 docs SONT corrects. Merci!

    Et enfin, dans mon Application.OnStartup méthode:

    using (var db = new MyDbContext())
{
    db.LogToConsole();
}

    Ce code va créer un fichier journal et aussi de sortie de la journalisation de l'info de la sortie de Visual Studio fenêtre. J'espère que cette aide -- je suis sûr que dans quelques semaines, les bits va changer à nouveau.

  4. 4

    Si vous utilisez MS SQL Serverd'une façon que j'ai utilisé dans le passé est de faire usage de la générateur de profils SQL Server et de capturer la totalité de l'interaction avec le Serveur SQL server, celui-ci saisit l'exacte SQL soumis et peut être coupé n collé dans le SQL Server Management Studio pour la poursuite de l'examen/analyse.
    Je sais que cela ne répond pas directement à votre question sur Entity Framework, mais j'ai trouvé cette approche générique très utile pour n'importe quelle langue/outils.

    Une astuce est dans les Propriétés de la Trace lors de la configuration d'une nouvelle trace, je trouve qu'il est utile pour ajuster la sélection par défaut des événements dans l'onglet Sélection des Événements. Surtout que j'ai désactivé la Vérification de Connexion/Déconnexion à moins d'être spécifiquement le suivi de cette question.

  5. 4

    Avec la dernière version de EF7-beta8, Anthony réponse du besoin d'un peu de peaufinage. Voici ce que j'ai fait pour le faire fonctionner.

    internal static class DbContextExtensions
{
    public static void LogToConsole(this DbContext context)
    {
        var loggerFactory = context.GetService<ILoggerFactory>();
        loggerFactory.AddConsole(LogLevel.Verbose);
    }
}
  6. 3

    Je pense que j'ai compris cela. Avec le courant EF7 bits, ILoggerFactory est enregistré avec le conteneur d'injection de dépendance qui EF. Vous pouvez obtenir une référence au conteneur, qui est un IServiceProvider, via le ScopedServiceProvider propriété de DbContext quand il est jeté à l'IDbContextServices. À partir de là, vous pouvez obtenir le ILoggerFactory et configurer à l'aide du AddToConsole méthode d'extension de Microsoft.Cadre.La journalisation.La Console NuGet package.

    public static void LogToConsole(this DbContext context)
{
    //IServiceProvider represents registered DI container
    IServiceProvider contextServices = ((IDbContextServices)context).ScopedServiceProvider;

    //Get the registered ILoggerFactory from the DI container
    var loggerFactory = contextServices.GetRequiredService<ILoggerFactory>();

    //Add a logging provider with a console trace listener
    loggerFactory.AddConsole(LogLevel.Verbose);
}

    Voici un résumé que j'ai créé pour cet extrait: https://gist.github.com/tonysneed/4cac4f4dae2b22e45ec4

  7. 2

    Cela a fonctionné pour moi avec EF7 rc2-16485:

    "EntityFramework.MicrosoftSqlServer": "7.0.0-rc2-16485",
"Microsoft.Extensions.Logging.Console": "1.0.0-rc2-15888",

public static class DbContextExtensions
{
    public static void LogToConsole(this DbContext context)
    {
        var contextServices = ((IInfrastructure<IServiceProvider>) context).Instance;
        var loggerFactory = contextServices.GetRequiredService<ILoggerFactory>();
        loggerFactory.AddConsole(LogLevel.Verbose);
    }
}
  8. 2

    Avec ASP.NET Core 2.0 vous obtenez la journalisation SQL automatiquement. Pas besoin de faire grand chose de plus.

  9. 1

    Comme une alternative pour les réponses ci-dessus, j'ai trouvé cette réponse de loin la solution la plus simple pour moi de raisonner sur:

    private readonly ILoggerFactory loggerFactory;

//Using dependency injection
public FooContext(ILoggerFactory loggerFactor) {
    this.loggerFactory = loggerFactory;
}

protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder) {
    optionsBuilder.UseLoggerFactory(loggerFactory);    //Register logger in context
}