Abfragen mit Nachverfolgung im Vergleich zu Abfragen ohne Nachverfolgung

Artikel
01/18/2023
5 Minuten Lesedauer

Das Nachverfolgungsverhalten steuert, ob Entity Framework Core Informationen über eine Entitätsinstanz in der Änderungsprotokollierung speichert. Wenn eine Entität nachverfolgt wird, werden alle Änderungen, die in der Entität erkannt werden, während SaveChanges() in der Datenbank beibehalten. EF Core korrigiert auch Unstimmigkeiten zwischen den Navigationseigenschaften von Entitäten in einem Nachverfolgungs-Abfrageergebnis und Entitäten, die sich in der Änderungsprotokollierung befinden.

Hinweis

Schlüssellose Entitätstypen werden nie nachverfolgt. Wenn in diesem Artikel Entitätstypen erwähnt werden, sind Entitätstypen gemeint, für die ein Schlüssel definiert ist.

Tipp

Das in diesem Artikel verwendete Beispiel finden Sie auf GitHub.

Abfragen mit Nachverfolgung

Abfragen, die Entitätstypen zurückgeben, verfügen standardmäßig über Nachverfolgung. Das bedeutet, Sie können Änderungen an diesen Entitätsinstanzen vornehmen, und diese Änderungen werden von SaveChanges() beibehalten. Im folgenden Beispiel wird die Änderung an der Bewertung des Blogs erkannt und während SaveChanges() in der Datenbank beibehalten.

var blog = context.Blogs.SingleOrDefault(b => b.BlogId == 1);
blog.Rating = 5;
context.SaveChanges();

Wenn die Ergebnisse in einer Abfrage mit Nachverfolgung zurückgegeben werden, prüft EF Core, ob die Entität bereits im Kontext ist. Wenn EF Core eine vorhandene Entität findet, wird dieselbe Instanz zurückgegeben. EF Core überschreibt im Eintrag mit den Datenbankwerten nicht die aktuellen und ursprünglichen Werte der Eigenschaften der Entität. Wenn die Entität nicht im Kontext gefunden wird, erstellt EF Core eine neue Entitätsinstanz und fügt sie dem Kontext an. Abfrageergebnisse enthalten keine Entität, die dem Kontext hinzugefügt, aber noch nicht in der Datenbank gespeichert wurde.

Abfragen ohne Nachverfolgung

Abfragen ohne Nachverfolgung sind nützlich, wenn die Ergebnisse in einem schreibgeschützten Szenario verwendet werden. Sie werden schneller ausgeführt, da keine Informationen für die Änderungsnachverfolgung eingerichtet werden müssen. Wenn Sie die aus der Datenbank abgerufenen Entitäten nicht aktualisieren müssen, sollte eine Abfrage ohne Nachverfolgung verwendet werden. Sie können eine einzelne Abfrage ändern, sodass sie keine Nachverfolgung ausführt. Keine Abfrage mit Nachverfolgung liefert Ihnen zudem Ergebnisse, die auf dem Inhalt der Datenbank basieren, wobei lokale Änderungen oder hinzugefügte Entitäten unberücksichtigt bleiben.

var blogs = context.Blogs
    .AsNoTracking()
    .ToList();

Sie können das Standardnachverfolgungsverhalten auch auf der Ebene der Kontextinstanz ändern:

context.ChangeTracker.QueryTrackingBehavior = QueryTrackingBehavior.NoTracking;

var blogs = context.Blogs.ToList();

Identitätsauflösung

Da eine Nachverfolgungsabfrage die Änderungsprotokollierung verwendet, führt EF Core in einer Nachverfolgungsabfrage eine Identitätsauflösung durch. Beim Materialisieren einer Entität gibt EF Core dieselbe Entitätsinstanz aus der Änderungsprotokollierung zurück, wenn sie bereits nachverfolgt wird. Wenn das Ergebnis mehrmals dieselbe Entität enthält, erhalten Sie für jedes Vorkommen dieselbe Instanz. Abfragen ohne Nachverfolgung verwenden weder die Änderungsprotokollierung, noch führen sie eine Identitätsauflösung durch. Sie erhalten also auch dann eine neue Instanz der Entität, wenn dieselbe Entität mehrmals im Ergebnis enthalten ist.

Sie können beide oben genannten Verhaltensweisen in derselben Abfrage kombinieren. Das heißt, Sie können eine Abfrage ohne Nachverfolgung haben, die eine Identitätsauflösung in den Ergebnissen vornimmt. Genau wie den abfragbaren Operator AsNoTracking() haben wir mit AsNoTrackingWithIdentityResolution() einen weiteren Operator hinzugefügt. Der Enumeration QueryTrackingBehavior wurde außerdem ein zugeordneter Eintrag hinzugefügt. Wenn Sie die Abfrage so konfigurieren, dass die Identitätsauflösung ohne Nachverfolgung verwendet wird, verwenden wir bei der Generierung der Abfrageergebnisse eine eigenständige Änderungsnachverfolgung im Hintergrund, sodass jede Instanz sich nur einmal materialisiert. Da sich diese Änderungsnachverfolgung von der im Kontext unterscheidet, werden die Ergebnisse nicht vom Kontext nachverfolgt. Nachdem die Abfrage vollständig aufgezählt ist, verlässt die Änderungsnachverfolgung den Gültigkeitsbereich, und die Garbage Collection erfolgt den Anforderungen entsprechend.

var blogs = context.Blogs
    .AsNoTrackingWithIdentityResolution()
    .ToList();

Konfigurieren des Standardverhaltens für die Nachverfolgung

Wenn Sie das Nachverfolgungsverhalten für viele Abfragen ändern müssen, sollten Sie darüber nachdenken, stattdessen das Standardverhalten zu ändern:

protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
    optionsBuilder
        .UseSqlServer(@"Server=(localdb)\mssqllocaldb;Database=EFQuerying.Tracking;Trusted_Connection=True")
        .UseQueryTrackingBehavior(QueryTrackingBehavior.NoTracking);
}

Dadurch werden Abfragen standardmäßig nicht nachverfolgt. Sie können jedoch AsTracking() hinzufügen, um bestimmte Abfragen nachzuverfolgen.

Nachverfolgung und benutzerdefinierte Projektionen

Selbst wenn der Ergebnistyp der Abfrage kein Entitätstyp ist, verfolgt EF Core im Ergebnis enthaltene Entitätstypen standardmäßig nach. In der folgenden Abfrage, die einen anonymen Typ zurückgibt, werden die Instanzen von Blog im Ergebnis nachverfolgt.

var blog = context.Blogs
    .Select(
        b =>
            new { Blog = b, PostCount = b.Posts.Count() });

Wenn das Resultset Entitätstypen enthält, die aus der LINQ-Komposition stammen, werden sie von EF Core nachverfolgt.

var blog = context.Blogs
    .Select(
        b =>
            new { Blog = b, Post = b.Posts.OrderBy(p => p.Rating).LastOrDefault() });

Wenn das Resultset keine Entitätstypen enthält, wird keine Nachverfolgung ausgeführt. In der folgenden Abfrage geben wir einen anonymen Typ mit einigen Werten der Entität zurück (aber keine Instanzen des aktuellen Entitätstyps). Es sind keine aus der Abfrage stammenden nachverfolgten Entitäten vorhanden.

var blog = context.Blogs
    .Select(
        b =>
            new { Id = b.BlogId, b.Url });

EF Core unterstützt die Clientauswertung in der Projektion auf oberster Ebene. Wenn EF Core eine Entitätsinstanz für die Clientauswertung materialisiert, wird sie nachverfolgt. Da wir hier blog-Entitäten an die Clientmethode StandardizeURL übergeben, verfolgt EF Core auch die Bloginstanzen nach.

var blogs = context.Blogs
    .OrderByDescending(blog => blog.Rating)
    .Select(
        blog => new { Id = blog.BlogId, Url = StandardizeUrl(blog) })
    .ToList();

public static string StandardizeUrl(Blog blog)
{
    var url = blog.Url.ToLower();

    if (!url.StartsWith("http://"))
    {
        url = string.Concat("http://", url);
    }

    return url;
}

EF Core verfolgt nicht die schlüssellosen Entitätsinstanzen nach, die im Ergebnis enthalten sind. EF Core verfolgt jedoch alle anderen Instanzen von Entitätstypen mit Schlüssel gemäß den oben aufgeführten Regeln nach.

Vorherige Versionen

Vor Version 3.0 wies EF Core bei der Nachverfolgung einige Unterschiede auf. Wesentliche Unterschiede sind:

Wie auf der Seite Clientauswertung im Vergleich zur Serverauswertung erläutert, unterstützte EF Core vor Version 3.0 die Clientauswertung in einem beliebigen Teil der Abfrage. Die Clientauswertung verursachte Materialisierungen von Entitäten, die nicht Teil des Ergebnisses waren. Daher analysierte EF Core das Ergebnis, um zu ermitteln, was nachverfolgt werden soll. Dieser Entwurf wies wie folgt bestimmte Unterschiede auf:
- Clientauswertung in der Projektion, die die Materialisierung verursachte, aber die materialisierte Entitätsinstanz nicht zurückgab, wurde nicht nachverfolgt. Im folgenden Beispiel wurden blog-Entitäten nicht nachverfolgt.
```
var blogs = context.Blogs
    .OrderByDescending(blog => blog.Rating)
    .Select(
        blog => new { Id = blog.BlogId, Url = StandardizeUrl(blog) })
    .ToList();
```
- In bestimmten Fällen wurden aus der LINQ-Komposition stammende Objekte von EF Core nicht nachverfolgt. Im folgenden Beispiel wurde Post nicht nachverfolgt.
```
var blog = context.Blogs
    .Select(
        b =>
            new { Blog = b, Post = b.Posts.OrderBy(p => p.Rating).LastOrDefault() });
```
Wenn Abfrageergebnisse schlüssellose Entitätstypen enthielten, wurde die gesamte Abfrage nicht nachverfolgt. Dies bedeutet, dass Entitätstypen mit Schlüsseln, die sich im Ergebnis befanden, auch nicht nachverfolgt wurden.
EF Core führte in Abfragen ohne Nachverfolgung eine Identitätsauflösung durch. Schwache Verweise wurden verwendet, um bereits zurückgegebene Entitäten nachzuverfolgen. Wenn also ein Resultset dieselbe Entität mehrfach enthielt, erhielten Sie für jedes Vorkommen dieselbe Instanz. Auch wenn ein vorheriges Ergebnis mit derselben Identität den Gültigkeitsbereich verließ und eine Garbage Collection durchgeführt wurde, gab EF Core eine neue Instanz zurück.