Entity Framework Core: Log-Abfragen für eine einzige db-context-Instanz

EF-Core (oder jede ORM für diese Angelegenheit) ich möchte, um zu verfolgen die Anzahl der Abfragen, die ORM für die Datenbank während eine operation an meiner software.

Habe ich benutzt SQLAlchemy unter Python frühere, und auf das stack-dies ist faily einfach einzurichten. Ich haben in der Regel unit-tests, die behaupten, auf die Anzahl der Anfragen für ein Szenario, gegen eine in-memory SQLite Datenbank.

Nun möchte ich das gleiche tun mit EF-Core, und habe mir die Protokollierung Dokumentation.

In meinem test-setup code ich tun wie die Dokumentation sagt:

using (var db = new BloggingContext())
{
    var serviceProvider = db.GetInfrastructure<IServiceProvider>();
    var loggerFactory = serviceProvider.GetService<ILoggerFactory>();
    loggerFactory.AddProvider(new MyLoggerProvider());
}

Aber ich laufen in Probleme, die ich vermute, sind die Ergebnisse der folgenden (auch von den docs):

Brauchen Sie nur zu registrieren, den logger mit einem einzigen context-Instanz.
Sobald Sie sich registriert haben, wird es für alle anderen Instanzen
der Kontext, in derselben AppDomain.

Die Probleme sehe ich in meinen tests zeigt an, dass mein logger Umsetzung wird gemeinsam von mehreren Kontexten (dies ist in übereinstimmung mit den docs, da ich Sie lese). Und da a) mein test runner führt tests in parallell und b) meine gesamte test-suite erstellt Hunderte von db - Kontexte- es funktioniert nicht sehr gut.

Frage/Fragen:

Ist, was ich will möglich?
I. e. registriere ich einen logger mit einem db-Kontext ist nur, dass db-context-Instanz?
Gibt es andere Möglichkeiten das zu erreichen, was ich versuche zu tun?

Was ist Ihr test-runner; NUnit, MsTest, XUnit?
Xunit-Test-runner
Haben Sie das herausgefunden? Ich habe versucht, die Filterung für Microsoft.EntityFrameworkCore.Storage.Internal.SqliteRelationalConnection aber nicht alles bekommen.
Würde einschließlich Thread.CurrentThread.ManagedThreadId in Ihren logs helfen?
Haben Sie versucht, miniprofiler.com
werde es versuchen.

InformationsquelleAutor codeape | 2017-04-28

c#entity-framework-core logging unit-testing xunit

Call DbContextOptionsBuilder.UseLoggerFactory(loggerFactory) Methode log alle SQL-Ausgabe von einem bestimmten context-Instanz. Sie konnte Spritzen, ein logger-Werk in den Kontext der Konstruktor.

Hier ist ein Beispiel:

//this context writes SQL to any logs and to ReSharper test output window
using (var context = new TestContext(_loggerFactory))
{
    var customers = context.Customer.ToList();
}

//this context doesn't
using (var context = new TestContext())
{
    var products = context.Product.ToList();
}

In der Regel, ich benutze diese Funktion für die manuelle Prüfung. Um die original-Kontext-Klasse sauber, eine abgeleitete überprüfbare Kontext deklariert ist überschrieben mit OnConfiguring Methode:

public class TestContext : FooContext
{
    private readonly ILoggerFactory _loggerFactory;

    public TestContext() { }

    public TestContext(ILoggerFactory loggerFactory)
    {
        _loggerFactory = loggerFactory;
    }

    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        base.OnConfiguring(optionsBuilder);

        optionsBuilder.UseLoggerFactory(_loggerFactory);
    }
}

Es ist genug, um log-SQL-Abfragen. Vergessen Sie nicht, bringen Sie eine geeignete logger (wie die Konsole) zu loggerFactory bevor Sie übergeben es an Zusammenhang.

Teil II: Pass-Protokolle, um xUnit-Ausgang und ReSharper test output-Fenster

Erstellen wir ein loggerFactory in einer test-Klasse-Konstruktor:

public class TestContext_SmokeTests : BaseTest
{
    public TestContext_SmokeTests(ITestOutputHelper output)
        : base(output)
    {
        var serviceProvider = new ServiceCollection().AddLogging().BuildServiceProvider();

        _loggerFactory = serviceProvider.GetService<ILoggerFactory>();

        _loggerFactory.AddProvider(new XUnitLoggerProvider(this));
    }

    private readonly ILoggerFactory _loggerFactory;
}

Der test-Klasse ist abgeleitet von BaseTest unterstützt das schreiben an xUnit Ausgabe:

public interface IWriter
{
    void WriteLine(string str);
}

public class BaseTest : IWriter
{
    public ITestOutputHelper Output { get; }

    public BaseTest(ITestOutputHelper output)
    {
        Output = output;
    }

    public void WriteLine(string str)
    {
        Output.WriteLine(str ?? Environment.NewLine);
    }
}

Den meisten schwierige Teil ist die Umsetzung einer logging-Anbieter akzeptieren IWriter als parameter:

public class XUnitLoggerProvider : ILoggerProvider
{
    public IWriter Writer { get; private set; }

    public XUnitLoggerProvider(IWriter writer)
    {
        Writer = writer;
    }
    public void Dispose()
    {
    }

    public ILogger CreateLogger(string categoryName)
    {
        return new XUnitLogger(Writer);
    }

    public class XUnitLogger : ILogger
    {
        public IWriter Writer { get; }

        public XUnitLogger(IWriter writer)
        {
            Writer = writer;
            Name = nameof(XUnitLogger);
        }

        public string Name { get; set; }

        public void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception exception,
            Func<TState, Exception, string> formatter)
        {
            if (!this.IsEnabled(logLevel))
                return;

            if (formatter == null)
                throw new ArgumentNullException(nameof(formatter));

            string message = formatter(state, exception);
            if (string.IsNullOrEmpty(message) && exception == null)
                return;

            string line = $"{logLevel}: {this.Name}: {message}";

            Writer.WriteLine(line);

            if (exception != null)
                Writer.WriteLine(exception.ToString());
        }

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

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

    public class XUnitScope : IDisposable
    {
        public void Dispose()
        {
        }
    }
}

Wir hier getan haben! Alle SQL-logs wird gezeigt, in Reiter/Resharper test output-Fenster.

Bitte, erklären, wie Sie _loggerFactory um es so zu benutzen: new TestContext(_loggerFactory)?
Verwenden Sie DI um ILoggerFactory Umsetzung. Registrieren Sie sich in Startup: services.AddLogging();. Dann injizieren Sie die ILoggerFactory Schnittstelle per Konstruktor an die Klasse, welche Anrufe new TestContext(_loggerFactory).
docs.microsoft.com/en-us/ef/core/miscellaneous/logging Schreibe:"Es ist sehr wichtig, dass Anwendungen nicht erstellen Sie eine neue ILoggerFactory-Instanz für jede context-Instanz. Dies führt zu einem Speicherverlust und schlechte Leistung." Also eigentlich ist es unmöglich zu erstellen loggerFactory für "einzigen Zusammenhang"... loggerFactory sollten global sein! Oder Sie verwenden sollten, pool loggerFactories.
das OP-Problem zu testen (und mir war das gleiche). Sie brauchen nicht zu kümmern, Speicherverlust in integration tests die meiste Zeit: xUnit neu erstellt test-Klassen pro Testfall standardmäßig, also ist es OK den trick wie oben beschrieben.
sowieso um den sql, der ausgeführt wird, aber nicht tatsächlich ausführen ?
Kannst du bitte zeigen wie man DI um die ILoggerFactory? Es ist nicht wirklich klar, wie das alles funktioniert zusammen.
was genau meinst du? In diesem Beispiel wird eine factory-Instanz wird erstellt, indem .GetService<ILoggerFactory>() Anruf, dann alles, was Sie brauchen, ist die übergabe der Fabrik an TestContext Konstruktor.
Ich habe alles getan, es lief gut, aber versuchen, es insgesamt in der ersten Zeile ausgelöst me up... wo bekommt man die _loggerFactory aus? using (var context = new TestContext(_loggerFactory)) - ok, ich glaube, ich kann meine Frage selbst beantwortet, bevor Sie führen Sie den test aus, den Sie Draht, ServiceCollection und seine von dort erhalten Sie die Referenz. Ich werde es geben ein anderes gehen.
du hast Recht, _loggerFactory ist in einer test-Klasse-Konstruktor

InformationsquelleAutor Ilya Chumakov

Lesen Sie diese:
docs.microsoft.com/en-us/ef/core/miscellaneous/logging

Ist es sehr wichtig, dass Anwendungen nicht erstellen Sie eine neue
ILoggerFactory-Instanz für jede context-Instanz. Dadurch wird
Ergebnis im Speicher und schlechte Leistung.1

Wenn Sie sich einloggen möchten, um statische destination (z.B. Konsole) Ilja Antwort funktioniert, aber wenn Sie möchten, melden Sie zuerst benutzerdefinierte Puffer, wenn jeder dbContext sammelt log-Nachrichten an seinen eigenen Puffer (und dass, was Sie gerne tun würden, im multiuser-service), dann UPSSS - Speicher-Lecks (und das memory leak ist etwa 20 mb pro fast leeres Modell)...

Wenn EF6 hatte einfache Lösung zum abonnieren eines Log-Ereignisses in einer Linie, jetzt Spritzen Sie Ihre Anmeldung auf diese Weise:

        var messages = new List<string>();
        Action<string> verbose = (text) => {
            messages.Add(text);
        }; //add logging message to buffer

        using (var dbContext = new MyDbContext(BuildOptionsBuilder(connectionString, inMemory), verbose))
        {
             //..
        };

schreiben Sie die pooling-monster.

P. S. Jemand sagen, zu Ef-Core-Architekten, dass Sie Falsches Verständnis von DI-und diejenigen, die Lust auf service Locator-Punkte, die Sie als "Container" und fließend UseXXX, dass Sie leihen sich von ASP.Kern ist, nicht ersetzen können "vulgär DI von constructor"! Mindestens log Funktion sollte normalerweise injizierbare durch Konstruktor.

*P. P. S. Lesen Sie auch diese https://github.com/aspnet/EntityFrameworkCore/issues/10420 . Dies bedeutet, dass das hinzufügen von LoggerFactory brach Zugriff auf InMemory data provider. Dies ist eine Abstraktion, Leck, wie es ist. EF-Core hat Probleme mit der Architektur.

ILoggerFactory pooling-code:

public class StatefullLoggerFactoryPool
{
    public static readonly StatefullLoggerFactoryPool Instance = new StatefullLoggerFactoryPool(()=> new StatefullLoggerFactory());
    private readonly Func<StatefullLoggerFactory> construct;
    private readonly ConcurrentBag<StatefullLoggerFactory> bag = new ConcurrentBag<StatefullLoggerFactory>();

    private StatefullLoggerFactoryPool(Func<StatefullLoggerFactory> construct) =>
        this.construct = construct;

    public StatefullLoggerFactory Get(Action<string> verbose, LoggerProviderConfiguration loggerProviderConfiguration)
    {
        if (!bag.TryTake(out StatefullLoggerFactory statefullLoggerFactory))
            statefullLoggerFactory = construct();
        statefullLoggerFactory.LoggerProvider.Set(verbose, loggerProviderConfiguration);
        return statefullLoggerFactory;
    }

    public void Return(StatefullLoggerFactory statefullLoggerFactory)
    {
        statefullLoggerFactory.LoggerProvider.Set(null, null);
        bag.Add(statefullLoggerFactory);
    }
}

 public class StatefullLoggerFactory : LoggerFactory
{
    public readonly StatefullLoggerProvider LoggerProvider;
    internal StatefullLoggerFactory() : this(new StatefullLoggerProvider()){}

    private StatefullLoggerFactory(StatefullLoggerProvider loggerProvider) : base(new[] { loggerProvider }) =>
        LoggerProvider = loggerProvider;
}

public class StatefullLoggerProvider : ILoggerProvider
{
    internal LoggerProviderConfiguration loggerProviderConfiguration;
    internal Action<string> verbose;
    internal StatefullLoggerProvider() {}

    internal void Set(Action<string> verbose, LoggerProviderConfiguration loggerProviderConfiguration)
    {
        this.verbose = verbose;
        this.loggerProviderConfiguration = loggerProviderConfiguration;
    }

    public ILogger CreateLogger(string categoryName) =>
        new Logger(categoryName, this);

    void IDisposable.Dispose(){}
}

public class MyDbContext : DbContext
{
    readonly Action<DbContextOptionsBuilder> buildOptionsBuilder;
    readonly Action<string> verbose;
    public MyDbContext(Action<DbContextOptionsBuilder> buildOptionsBuilder, Action<string> verbose=null): base()
    {
        this.buildOptionsBuilder = buildOptionsBuilder;
        this.verbose = verbose;
    }

     private Action returnLoggerFactory;
    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        if (verbose != null)
        {
            var loggerFactory = StatefullLoggerFactoryPool.Instance.Get(verbose, new LoggerProviderConfiguration { Enabled = true, CommandBuilderOnly = false });
            returnLoggerFactory = () => StatefullLoggerFactoryPool.Instance.Return(loggerFactory);
            optionsBuilder.UseLoggerFactory(loggerFactory);
        }
        buildOptionsBuilder(optionsBuilder);
    }

    //NOTE: not threadsafe way of disposing
    public override void Dispose()
    {
        returnLoggerFactory?.Invoke();
        returnLoggerFactory = null;
        base.Dispose();
    }
}

    private static Action<DbContextOptionsBuilder> BuildOptionsBuilder(string connectionString, bool inMemory)
    {
        return (optionsBuilder) =>
        {
            if (inMemory)
                optionsBuilder.UseInMemoryDatabase(
                  "EfCore_NETFramework_Sandbox"
                );
            else
                //Assembly.GetAssembly(typeof(Program))
                optionsBuilder.UseSqlServer(
                        connectionString,
                        sqlServerDbContextOptionsBuilder => sqlServerDbContextOptionsBuilder.MigrationsAssembly("EfCore.NETFramework.Sandbox")
                        );
        };
    }

class Logger : ILogger
{
    readonly string categoryName;
    readonly StatefullLoggerProvider statefullLoggerProvider;
    public Logger(string categoryName, StatefullLoggerProvider statefullLoggerProvider)
    {
        this.categoryName = categoryName;
        this.statefullLoggerProvider = statefullLoggerProvider;
    }

    public IDisposable BeginScope<TState>(TState state) =>
        null;

    public bool IsEnabled(LogLevel logLevel) =>
        statefullLoggerProvider?.verbose != null;

    static readonly List<string> events = new List<string> {
            "Microsoft.EntityFrameworkCore.Database.Connection.ConnectionClosing",
            "Microsoft.EntityFrameworkCore.Database.Connection.ConnectionClosed",
            "Microsoft.EntityFrameworkCore.Database.Command.DataReaderDisposing",
            "Microsoft.EntityFrameworkCore.Database.Connection.ConnectionOpened",
            "Microsoft.EntityFrameworkCore.Database.Connection.ConnectionOpening",
            "Microsoft.EntityFrameworkCore.Infrastructure.ServiceProviderCreated",
            "Microsoft.EntityFrameworkCore.Infrastructure.ContextInitialized"
        };

    public void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception exception, Func<TState, Exception, string> formatter)
    {
        if (statefullLoggerProvider?.verbose != null)
        {
            if (!statefullLoggerProvider.loggerProviderConfiguration.CommandBuilderOnly ||
                (statefullLoggerProvider.loggerProviderConfiguration.CommandBuilderOnly && events.Contains(eventId.Name) ))
            {
                var text = formatter(state, exception);
                statefullLoggerProvider.verbose($"MESSAGE; categoryName={categoryName} eventId={eventId} logLevel={logLevel}" + Environment.NewLine + text);
            }
        }
    }
}

InformationsquelleAutor Roman Pokrovskij

-3

Können Sie mit einem begrenzten Kontext. Ich verwendete EF-Coed zuerst erstellen Sie zwei unterschiedliche Kontexte

Kunden eingegrenzten Kontext wird nicht protokolliert alle Abfragen

public class CustomerModelDataContext : DbContext
{
    public DbSet<Customer> Customers { get; set; }

    public DbSet<PostalCode> PostalCodes { get; set; }

    public CustomerModelDataContext()
        : base("ConnectionName")
    {
        Configuration.LazyLoadingEnabled = true;
        Configuration.ProxyCreationEnabled = true;
        Database.SetInitializer<CustomerModelDataContext>(new Initializer<CustomerModelDataContext>());
        //Database.Log = message => DBLog.WriteLine(message);
    }

    protected override void OnModelCreating(DbModelBuilder modelBuilder)
    {
        base.OnModelCreating(modelBuilder);
    }
}

API eingegrenzten Kontext protokolliert die Abfragen

public class ApiModelDataContext : DbContext
{
    public DbSet<ApiToken> ApiTokens { get; set; }

    public DbSet<ApiClient> ApiClients { get; set; }

    public DbSet<ApiApplication> ApiApplications { get; set; }

    public ApiModelDataContext() 
        : base("ConnectionName")
    {
        Configuration.LazyLoadingEnabled = true;
        Configuration.ProxyCreationEnabled = true;
        Database.SetInitializer<ApiModelDataContext>(new Initializer<ApiModelDataContext>());
        Database.Log = message => DBLog.WriteLine(message);
    }

    protected override void OnModelCreating(DbModelBuilder modelBuilder)
    {
        base.OnModelCreating(modelBuilder);
    }
}

diese melden sich die Abfrage, um die debug-Ausgabe-Fenster in VS

public static class DBLog
{
    public static void WriteLine(string message)
    {
        Debug.WriteLine(message);
    }
}

Nichts davon gilt für EF-Core-obwohl.

InformationsquelleAutor migabriel

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.