Neuigkeiten in Entity Framework Core 8.0

Entity Framework Core 8.0 ist als Nachfolger von Entity Framework Core 7.0 zusammen mit .NET 8.0 erschienen.

Termine

• Erscheinungstermin: 14. November 2023
• Support: 3 Jahre, also bis November 2026

Hinweise

• Entity Framework Core 8.0 läuft nur auf .NET 8.0! (bis Preview 6 lief es noch auf .NET 6.0, .NET 7.0 und .NET 8.0)
• Microsoft kürzt Entity Framework Core 8.0 mit "EF8" ab.

Liste der wesentlichen Neuerungen in Entity Framework Core 8.0

• Mapping für die in .NET 6.0 eingeführten elementaren Typen System.DateOnly und System.TimeOnly auch im Microsoft SQL Server
• Datentypen long und ulong für Timestamp-Spalten als Alternative zu Byte-Arrays (nur im Microsoft SQL Server)
• Mapping von Arrays und Listen elementarer Typen auf nvarchar-Spalten mit JSON-Zeichenketten
• JSON-Mapping von Klassen mit ToJson() auch für SQLite-Datenbanken (das war seit Entity Framework Core 7.0 nur im SQL Server möglich)
• Table Splitting mit Complex Types als Alternative zu den bisher verfügbaren Owned Types via Annotation [ComplexType] oder Fluent-API per Methodenaufruf ComplexProperty()
• Hierarchische Daten im SQL Server mit dem SQL Server-Spaltentyp "hierarchyid" via NuGet-Paket Microsoft.EntityFrameworkCore.SqlServer.HierarchyId
• Mapping von SQL-Abfragen auf beliebige, nicht in der Kontextklasse registrierte Typen mit ctx.Database.SqlQuery() und ctx.Database.SqlQueryRaw()
• Das Lazy Loading funktioniert auch bei No-Tracking-Abfragen
• Abschalten des Lazy Loading für einzelne Beziehungen mit EnableLazyLoading(false)
• Asynchrones explizites Nachladen mit Reference().LoadAsync() bzw. Collection().LoadAsync() zusätzlich zum synchronen Load()
• Automatisch begrenzte Länge der Diskriminatorspalten bei Table-per-Hierarchy-Vererbung
• Bessere SQL-Übersetzung des LINQ-Operators Contains(): es entstehen parametrisierte Abfragen statt Ad-hoc-Abfragen und bei Unterabfragen kommt WHERE…IN zum Einsatz.
• Übersichtlichere SQL-Generierung aus LINQ-Abfragen ohne überflüssige Klammern
• Abfrage der Objekte im lokalen Zwischenspeicher mit Local.FindEntry() und Local.GetEntries()
• Statusabfrage, ob es Änderungen im Objektmodell gibt, für die es noch keine Datenbankschemamigration gibt: Via Kommandozeile dotnet ef migrations has-pending-model-changes
• Festlegung des von Entity Framework Core intern verwendeten Wächterwertes, um festzustellen, dass ein Wert nicht der im Datenbankmanagementsystem hinterlegte Standardwert ist: HasSentinel()
• Die in Entity Framework Core 7.0 eingeführten Methoden ExecuteUpdate() and ExecuteDelete() funktionieren in Version 8.0 auch in Fällen, bei denen mehrere Entitätsklassen auf eine einzige Tabelle (z.B. bei der TPH-Vererbung) abgebildet sind

Verbessertes Datentypmapping in Entity Framework Core 8.0

Der Objekt-Relationale Mapper Entity Framework Core in Version 8.0 erlaubt nun die Abbildung der bereits in .NET 6.0 eingeführten Klassen DateOnly und TimeOnly auf die SQL-Server-Datentypen date und time. Das ging bisher (schon seit .NET 6.0) nur bei SQLite-Datenbanken.

Umgekehrt konnte zuvor nur der Microsoft SQL Server-Treiber für Entity Framework Core mit einem JSON-Mapping umgehen (seit Entity Framework Core 7.0). Seit Preview 2 von Entity Framework Core 8.0 können Entwickler nun die in eingeführten JSON-Spalten auch in Verbindung mit SQLite-Datenbanken nutzen, indem man im Fluent-API der Kontextklasse bei einem Owned Type ToJson() aufruft. Dadurch werden verbundene Objekte auf einzelne Datenbankspalten mit JSON-Inhalt abgebildet. Abfragen mit Filtern und Sortieren sind dennoch möglich.

Mapping von Arrays und einfachen Listen

Der OR-Mapper konnte bisher (außer bei PostgreSQL) keine Mengen elementarer Datentypen auf die Datenbank abbilden. Bei der Verwendung von Mengen-Typen wie Arrays, List, Queue, Stack und HashSet (z.B. int[], List<DateTime> und HashSet<Guid>) verweigerte Entity Framework Core das Mapping mit der Fehlermeldung "The property 'DataTypeTest.xy' could not be mapped because it is of type 'xy[]', which is not a supported primitive type or a valid entity type. Either explicitly map this property, or ignore it using the '[NotMapped]' attribute or by using 'EntityTypeBuilder.Ignore' in 'OnModelCreating'." Nur im PostgreSQL-Treiber für Entity Framework Core [https://www.npgsql.org/efcore] war dies möglich, denn dieses Datenbankmanagementsystem unterstützt von Hause aus Arrays als Spaltentypen.

In Entity Framework Core 8.0 hat Microsoft nun für Microsoft SQL Server und SQLite eine andere Lösung implementiert: Dort werden alle im Listing gezeigten Mengentypen auf eine JSON-Spalte abgebildet. Für alle Mengentypen im nächsten Listing entsteht jeweils eine Spalte vom Typ nvarchar(max) in SQL Server bzw. TEXT in SQLite, welche dann die Elemente der String-Menge als JSON-Array abspeichert.

Listing: Entitätsklasse mit Array-Typen

---

public class DataTypeTest
{
public Int32 ID { get; set; }

public byte[] ByteArray { get; set; }

[Timestamp]
public byte[] Timestamp { get; set; }

public short[] ShortArray { get; set; }

public int[] IntArray { get; set; }

public long[] LongArray { get; set; }

public string[] StringArray { get; set; }

public DateTime[] DateTimeArray { get; set; }

public bool[] BoolArray { get; set; }

public Guid[] GuidArray { get; set; }

public ABC[] EnumArray { get; set; }

public List<int> IntList { get; set; }

// analog auch alle o.g. Array-Typen als List<T>
}

Hierarchische Daten im SQL Server mit Entity Framework Core 8.0

Beim Microsoft SQL Server werden seit Entity Framework Core 8.0 Preview 2 auch Tabellen mit hierarchischen Daten mit dem SQL Server-Spaltentyp Hierarchy-ID unterstützt. Dazu gab es bisher ein NuGet-Paket aus der Community "EntityFrameworkCore.SqlServer.HierarchyId" [https://www.nuget.org/packages/EntityFrameworkCore.SqlServer.HierarchyId]. Nun hat Microsoft diese Funktionen in den Kern von Entity Framework Core aufgenommen. Man benötigt dafür zwei Pakete:

• Das Paket Microsoft.EntityFrameworkCore.SqlServer.Abstractions stellt die Klasse Microsoft.EntityFrameworkCore.HierarchyId bereit, die man auf der Ebene der Geschäftsobjekte braucht, um eine Hierarchie zu definieren (siehe Klasse "Mitarbeiter" in Listing 1). Ebenso braucht man das Paket dort, wo man LINQ-Befehle auf der HierarchyId absetzen will, z.B. mit den Operationen GetAncestor(), GetDescendant(), IsDescendantOf() und GetLevel(), siehe Listing 3.
• Das Paket Microsoft.EntityFrameworkCore.SqlServer.HierarchyId benötigt man in der Kontextklasse für die Erweiterungsmethode UseHierarchyId(), siehe Listing 2.

Listing 1 bis 3 zeigen ein zusammenhängendes, aussagekräftiges Beispiel für hierarchische Daten mit Entity Framework Core 8.0. Die Geschäftsobjektklasse Mitarbeiter in Listing 7 besitzt eine Eigenschaft Ebene vom Typ HierarchyId. Listing 2 realisiert eine Entity Framework Core-Kontextklasse für diese Geschäftsobjektklasse.

In Listing 3 findet man einen Client, der zunächst eine Mitarbeiterhierarchie und dann verschiedene Abfragen ausführt. Am Ende wird auch noch ein Mitarbeiter befördert, d.h. seine Ebene wird geändert.

Listing 1: Klasse Mitarbeiter mit HierarchyId

---

public class Mitarbeiter
{
public Mitarbeiter(HierarchyId ebene, string name, int? eintrittsjahr = null)
{
Ebene = ebene;
Name = name;
Eintrittsjahr = eintrittsjahr;
}

public int ID { get; private set; }
public HierarchyId Ebene { get; set; }
public string Name { get; set; }
public int? Eintrittsjahr { get; set; }

public override string ToString()
{
return $"Mitarbeiter {ID} Ebene {Ebene}: {Name}";
}
}

Listing 2: Entity Framework Core-Kontextklasse für die Geschäftsobjektklasse Mitarbeiter

---

class Context : DbContext
{
public DbSet<Mitarbeiter> MitarbeiterSet { get; set; }
protected override void OnConfiguring(DbContextOptionsBuilder builder)
{
builder.EnableSensitiveDataLogging(true);
builder.UseSqlServer(@$"Server=D120;Database=Entity Framework CoreMappingScenarios_" + nameof(EFC80_HierarchicalData) + ";TrustedConnection=True;MultipleActiveResultSets=True;encrypt=false", x => x.UseHierarchyId());
}

protected override void OnModelCreating(ModelBuilder modelBuilder)
{

}
}

Listing 3: Aufbau und Auslesen einer Mitarbeiterhierarchie

---

class Client
{
public void Run()
{
using (var ctx = new Context())
{
CUI.H2("Mitarbeiterhierarchie erzeugen");
Randomizer.Seed = new Random(42);
var f = new Faker();

var startEbene = "/";
var bosmang = new Mitarbeiter(HierarchyId.Parse(startEbene), f.Name.FullName(), f.Random.Number(1970, 2023));
Console.WriteLine(bosmang);
ctx.Add(bosmang);

for (int I = 1; I < 5; i++)
{
var ebene1 = startEbene + I + "/";

var m = new Mitarbeiter(HierarchyId.Parse(ebene1), f.Name.FullName(), f.Random.Number(1970, 2023));
Console.WriteLine(" " + m);
ctx.Add(m);

for (int j = 1; j < 5; j++)
{
var ebene2 = startEbene + I + "/" + j + "/"; ;
var n = new Mitarbeiter(HierarchyId.Parse(ebene2), f.Name.FullName(), f.Random.Number(1970, 2023));
Console.WriteLine(" " + n);
ctx.Add(n);
}
}

var c = ctx.SaveChanges();
Console.WriteLine©;

CUI.H2("Daten auslesen mit GetLevel()");
for (int ebene = 0; ebene <= 3; ebene++)
{
var mitarbeiterAufEinerEbene = ctx.MitarbeiterSet.Where(x => x.Ebene.GetLevel() == ebene).ToList();
CUI.H3($"Mitarbeiter auf Ebene {ebene}:");
foreach (var m in mitarbeiterAufEinerEbene)
{
Console.WriteLine(m);
}
}

CUI.H2("Daten auslesen mit GetAncestor ()");
var irgendEinMitarbeiter = ctx.MitarbeiterSet.ToList().ElementAt(15);
var vorgesetzter = ctx.MitarbeiterSet.SingleOrDefault(
ancestor => ancestor.Ebene == irgendEinMitarbeiter.Ebene.GetAncestor(1));

Console.WriteLine($"Der Vorgesetzte von {irgendEinMitarbeiter.Name} ist: {vorgesetzter.Name}");

CUI.H2("Daten auslesen mit IsDescendantOf()");
var mitarbeiterEinerFuehrungskraft = ctx.MitarbeiterSet.Where(x => x.Ebene.IsDescendantOf(vorgesetzter.Ebene) && x.ID != vorgesetzter.ID).ToList();
Console.WriteLine($"Alle Mitarbeiter von {vorgesetzter.Name}:");
foreach (var m in mitarbeiterEinerFuehrungskraft)
{
Console.WriteLine(m);
}

CUI.H2("Daten ändern: Ein Mitarbeiter wird befördert und steigt auf die Ebene direkt unter dem Bosmang auf");
Console.WriteLine($"{irgendEinMitarbeiter.Name} Alte Ebene: {irgendEinMitarbeiter.Ebene}");
irgendEinMitarbeiter.Ebene = irgendEinMitarbeiter.Ebene.GetReparentedValue(vorgesetzter.Ebene, bosmang.Ebene);
Console.WriteLine($"{irgendEinMitarbeiter.Name} Neue Ebene: {irgendEinMitarbeiter.Ebene}");
ctx.SaveChanges();

CUI.H2("Daten auslesen mit IsDescendantOf()");
var alleUnterDemBosmang = ctx.MitarbeiterSet.Where(x => x.Ebene.IsDescendantOf(bosmang.Ebene) && x.Ebene.GetLevel() == 1).ToList();
Console.WriteLine($"Alle Mitarbeiter unter dem Bosmang:");
foreach (var m in alleUnterDemBosmang)
{
Console.WriteLine(m);
}
}
}
}

Weitere Informationen finden Sie in diesen Beiträgen:

.NET 8.0
Entity Framework Core 9.0