Neuerungen in EF Core 5.0What's New in EF Core 5.0

Die folgende Liste enthält die wichtigsten neuen Features in EF Core 5.0.The following list includes the major new features in EF Core 5.0. Eine vollständige Liste der Probleme in diesem Release finden Sie im Issue-Tracker.For the full list of issues in the release, see our issue tracker.

Da es sich um ein Hauptrelease handelt, umfasst EF Core 5.0 auch zahlreiche Breaking Changes, bei denen es sich um API-Verbesserungen oder Behavior Changes handelt, die sich negativ auf vorhandene Anwendungen auswirken können.As a major release, EF Core 5.0 also contains several breaking changes, which are API improvements or behavioral changes that may have negative impact on existing applications.

M:nMany-to-many

EF Core 5.0 unterstützt m:n-Beziehungen ohne explizite Zuordnung der Jointabelle.EF Core 5.0 supports many-to-many relationships without explicitly mapping the join table.

Betrachten Sie beispielsweise die folgenden Entitätstypen:For example, consider these entity types:

public class Post
{
    public int Id { get; set; }
    public string Name { get; set; }
    public ICollection<Tag> Tags { get; set; }
}

public class Tag
{
    public int Id { get; set; }
    public string Text { get; set; }
    public ICollection<Post> Posts { get; set; }
}

EF Core 5.0 erkennt dies gemäß der Konvention als m:n-Beziehung an und erstellt automatisch eine PostTag-Jointabelle in der Datenbank.EF Core 5.0 recognizes this as a many-to-many relationship by convention, and automatically creates a PostTag join table in the database. Die Daten können ohne explizite Referenz der Jointabelle abgefragt und geändert werden, was den Code deutlich vereinfacht.Data can be queried and updated without explicitly referencing the join table, considerably simplifying code. Die Jointabelle kann weiterhin bei Bedarf angepasst und abgefragt werden.The join table can still be customized and queried explicitly if needed.

Weitere Informationen finden Sie in der Dokumentation zu m:n-Beziehungen.For further information, see the full documentation on many-to-many.

Geteilte AbfragenSplit queries

Ab EF Core 3.0 generiert EF Core für jede LINQ-Abfrage eine einzelne SQL-Abfrage.Starting with EF Core 3.0, EF Core always generates a single SQL query for each LINQ query. Dadurch wird sichergestellt, dass die zurückgegebenen Daten im Rahmen der Einschränkungen des verwendeten Transaktionsmodus konsistent sind.This ensures consistency of the data returned within the constraints of the transaction mode in use. Wenn die Abfrage Include oder eine Projektion verwendet, um mehrere ähnliche Sammlungen zurückzugeben, kann die Ausführung jedoch sehr lange dauern.However, this can become very slow when the query uses Include or a projection to bring back multiple related collections.

In EF Core 5.0 ist es jetzt möglich, eine einzelne LINQ-Abfrage und die zugehörigen Sammlungen auf mehrere SQL-Abfragen aufzuteilen.EF Core 5.0 now allows a single LINQ query including related collections to be split into multiple SQL queries. Die Leistung kann dadurch zwar erheblich verbessert werden, doch bei den zurückgegebenen Ergebnissen kann es zu Inkonsistenzen kommen, wenn die Daten sich zwischen den beiden Abfragen ändern.This can significantly improve performance, but can result in inconsistency in the results returned if the data changes between the two queries. Serialisierbare Transaktionen oder Momentaufnahmentransaktionen können verwendet werden, um das zu verhindern und Konsistenz bei aufgeteilten Abfragen zu erzielen. Dadurch kann jedoch die Leistung beeinträchtigt werden, und das Verhalten kann sich unterscheiden.Serializable or snapshot transactions can be used to mitigate this and achieve consistency with split queries, but that may bring other performance costs and behavioral difference.

Gehen Sie von einer Abfrage aus, die mithilfe von Include zwei Ebenen ähnlicher Sammlungen einschließt:For example, consider a query that pulls in two levels of related collections using Include:

var artists = context.Artists
    .Include(e => e.Albums)
    .ToList();

Standardmäßig generiert EF Core den folgenden SQL-Wert, wenn der SQLite-Anbieter verwendet wird:By default, EF Core will generate the following SQL when using the SQLite provider:

SELECT a."Id", a."Name", a0."Id", a0."ArtistId", a0."Title"
FROM "Artists" AS a
LEFT JOIN "Album" AS a0 ON a."Id" = a0."ArtistId"
ORDER BY a."Id", a0."Id"

Mit geteilten Abfragen wird stattdessen der folgende SQL-Code generiert:With split queries, the following SQL is generated instead:

SELECT a."Id", a."Name"
FROM "Artists" AS a
ORDER BY a."Id"

SELECT a0."Id", a0."ArtistId", a0."Title", a."Id"
FROM "Artists" AS a
INNER JOIN "Album" AS a0 ON a."Id" = a0."ArtistId"
ORDER BY a."Id"

Geteilte Abfragen können durch Platzieren des neuen AsSplitQuery-Operators an einer beliebigen Stelle in Ihrer LINQ-Abfrage oder global in der OnConfiguring-Methode Ihres Modells.Split queries can be enabled by placing the new AsSplitQuery operator anywhere in your LINQ query, or globally in your model's OnConfiguring. Weitere Informationen finden Sie in der Dokumentation zu Geteilten Abfragen.For further information, see the full documentation on split queries.

Einfache Protokollierung und verbesserte DiagnoseSimple logging and improved diagnostics

Mit EF Core 5.0 wird eine einfache Möglichkeit zum Einrichten der Protokollierung über die neue LogTo-Methode eingeführt.EF Core 5.0 introduces a simple way to set up logging via the new LogTo method. Der folgende Code führt dazu, dass Protokollierungsmeldungen, einschließlich des gesamten von EF Core generierten SQL-Codes, in die Konsole geschrieben werden:The following will cause logging messages to be written to the console, including all SQL generated by EF Core:

protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    => optionsBuilder.LogTo(Console.WriteLine);

Außerdem ist es jetzt möglich, ToQueryString für beliebige LINQ-Abfragen aufzurufen, um den SQL-Code abzurufen, den die Abfrage ausführen würde:In addition, it is now possible to call ToQueryString on any LINQ query, retrieving the SQL that the query would execute:

Console.WriteLine(
    ctx.Artists
    .Where(a => a.Name == "Pink Floyd")
    .ToQueryString());

Letztlich wurden verschiedene EF Core-Typen mit einer erweiterten DebugView-Eigenschaft ausgestattet, die eine ausführliche Ansicht über interne Informationen bietet.Finally, various EF Core types have been fitted with an enhanced DebugView property which provides a detailed view into the internals. Beispielsweise können Sie mit ChangeTracker.DebugView überprüfen, welche Entitäten zu einem bestimmten Zeitpunkt nachverfolgt werden.For example, ChangeTracker.DebugView can be consulted to see exactly which entities are being tracked in a given moment.

Weitere Informationen finden Sie in der Dokumentation zu Protokollierung und Abfangfunktionen.For further information, see the documentation on logging and interception.

Gefilterte Include-FunktionFiltered include

Die Include-Methode unterstützt nun das Filtern der enthaltenen Entitäten:The Include method now supports filtering of the entities included:

var blogs = context.Blogs
    .Include(e => e.Posts.Where(p => p.Title.Contains("Cheese")))
    .ToList();

Mit dieser Abfrage werden Blogs zusammen mit den jeweiligen Beiträgen zurückgegeben, jedoch nur, wenn der Titel „Cheese“ enthält.This query will return blogs together with each associated post, but only when the post title contains "Cheese".

Weitere Informationen finden Sie in der Dokumentation zu Geteilten Abfragen.For further information, see the full documentation on split queries.

TPT-Zuordnung (Tabelle pro Typ)Table-per-type (TPT) mapping

EF Core ordnet standardmäßig eine Vererbungshierarchie von .NET-Typen einer einzelnen Datenbanktabelle zu.By default, EF Core maps an inheritance hierarchy of .NET types to a single database table. Dies wird als TPH-Zuordnung (Tabelle pro Hierarchie) bezeichnet.This is known as table-per-hierarchy (TPH) mapping. EF Core 5.0 ermöglicht außerdem das Zuordnen der einzelnen .NET-Typen in einer Vererbungshierarchie zu einer anderen Datenbanktabelle. Dies wird als TPT-Zuordnung (Tabelle pro Typ) bezeichnet.EF Core 5.0 also allows mapping each .NET type in an inheritance hierarchy to a different database table; known as table-per-type (TPT) mapping.

Stellen Sie sich beispielsweise das folgende Modell mit einer zugeordneten Hierarchie vor:For example, consider this model with a mapped hierarchy:

public class Animal
{
    public int Id { get; set; }
    public string Name { get; set; }
}

public class Cat : Animal
{
    public string EducationLevel { get; set; }
}

public class Dog : Animal
{
    public string FavoriteToy { get; set; }
}

Bei TPT wird eine Datenbanktabelle für jeden Typ in der Hierarchie erstellt:With TPT, a database table is created for each type in the hierarchy:

CREATE TABLE [Animals] (
    [Id] int NOT NULL IDENTITY,
    [Name] nvarchar(max) NULL,
    CONSTRAINT [PK_Animals] PRIMARY KEY ([Id])
);

CREATE TABLE [Cats] (
    [Id] int NOT NULL,
    [EdcuationLevel] nvarchar(max) NULL,
    CONSTRAINT [PK_Cats] PRIMARY KEY ([Id]),
    CONSTRAINT [FK_Cats_Animals_Id] FOREIGN KEY ([Id]) REFERENCES [Animals] ([Id]) ON DELETE NO ACTION,
);

CREATE TABLE [Dogs] (
    [Id] int NOT NULL,
    [FavoriteToy] nvarchar(max) NULL,
    CONSTRAINT [PK_Dogs] PRIMARY KEY ([Id]),
    CONSTRAINT [FK_Dogs_Animals_Id] FOREIGN KEY ([Id]) REFERENCES [Animals] ([Id]) ON DELETE NO ACTION,
);

Weitere Informationen finden Sie in der Dokumentation zu TPT.For further information, see the full documentation on TPT.

Flexible EntitätszuordnungFlexible entity mapping

Entitätstypen werden häufig Tabellen oder Sichten zugeordnet, sodass EF Core den Inhalt der Tabelle oder der Sicht zurückgibt, wenn dieser Typ abgefragt wird.Entity types are commonly mapped to tables or views such that EF Core will pull back the contents of the table or view when querying for that type. Mit EF Core 5.0 wurden zusätzliche Zuordnungsoptionen hinzugefügt, mit denen eine Entität beispielsweise einer SQL-Abfrage (eine sogenannte „definierende Abfrage“) oder einer Tabellenwertfunktion (TVF) zugeordnet werden kann:EF Core 5.0 adds additional mapping options, where an entity can be mapped to a SQL query (called a "defining query"), or to a table-valued function (TVF):

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Post>().ToSqlQuery(
        @"SELECT Id, Name, Category, BlogId FROM posts
          UNION ALL
          SELECT Id, Name, ""Legacy"", BlogId from legacy_posts");

    modelBuilder.Entity<Blog>().ToFunction("BlogsReturningFunction");
}

Tabellenwertfunktionen können auch einer .NET-Methode anstelle einer DbSet-Klasse zugeordnet werden, sodass Parameter übergeben werden können. Die Zuordnung kann mithilfe von HasDbFunction eingerichtet werden.Table-valued functions can also be mapped to a .NET method rather than to a DbSet, allowing parameters to be passed; the mapping can be set up with HasDbFunction.

Außerdem ist es nun möglich, eine Entität bei Abfragen einer Ansicht (oder einer Funktion oder definierenden Abfrage) zuzuordnen, jedoch ist die Zuordnung zu einer Tabelle beim Vornehmen von Änderungen nicht möglich:Finally, it is now possible to map an entity to a view when querying (or to a function or defining query), but to a table when updating:

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder
        .Entity<Blog>()
        .ToTable("Blogs")
        .ToView("BlogsView");
}

Freigegebene Entitätstypen und EigenschaftenbehälterShared-type entity types and property bags

EF Core 5.0 ermöglicht die Zuordnung desselben CLR-Typs zu mehreren verschiedenen Entitätstypen. Diese Typen werden als freigegebene Entitätstypen bezeichnet.EF Core 5.0 allows the same CLR type to be mapped to multiple different entity types; such types are known as shared-type entity types. Während beliebige CLR-Typen mit diesem Feature verwendet werden können, bietet die .NET-Klasse Dictionary einen besonders überzeugenden Anwendungsfall, der als „Eigenschaftenbehälter“ bezeichnet wird.While any CLR type can be used with this feature, .NET Dictionary offers a particularly compelling use-case which we call "property bags":

public class ProductsContext : DbContext
{
    public DbSet<Dictionary<string, object>> Products => Set<Dictionary<string, object>>("Product");

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.SharedTypeEntity<Dictionary<string, object>>("Product", b =>
        {
            b.IndexerProperty<int>("Id");
            b.IndexerProperty<string>("Name").IsRequired();
            b.IndexerProperty<decimal>("Price");
        });
    }
}

Diese Entitäten können dann wie normale Entitätstypen mit ihrem eigenen dedizierten CLR-Typ abgefragt und geändert werden.These entities can then be queried and updated just like normal entity types with their own, dedicated CLR type. Weitere Informationen finden Sie in der Dokumentation zu Eigenschaftenbehältern.More information can be found in the documentation on property bags.

Erforderliche 1:1-AbhängigkeitenRequired 1:1 dependents

Bei EF Core 3.1 war das abhängige Ende einer 1:1-Beziehung immer optional.In EF Core 3.1, the dependent end of a one-to-one relationship was always considered optional. Dies war insbesondere bei Verwendung von nicht eigenständigen Entitäten offensichtlich, da alle Spalten der nicht eigenständigen Entität in der Datenbank als NULL-Werte zulassend erstellt wurden, obwohl sie im Modell als erforderlich konfiguriert waren.This was most apparent when using owned entities, as all the owned entity's column were created as nullable in the database, even if they were configured as required in the model.

In EF Core 5.0 kann eine Navigation zu einer nicht eigenständigen Entität als erforderliche Abhängigkeit konfiguriert werden.In EF Core 5.0, a navigation to an owned entity can be configured as as a required dependent. Beispiel:For example:

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Person>(b =>
    {
        b.OwnsOne(e => e.HomeAddress,
            b =>
            {
                b.Property(e => e.City).IsRequired();
                b.Property(e => e.Postcode).IsRequired();
            });
        b.Navigation(e => e.HomeAddress).IsRequired();
    });
}

DbContextFactoryDbContextFactory

Mit EF Core 5.0 wurden AddDbContextFactory und AddPooledDbContextFactory zum Registrieren einer Factory zum Erstellen von DbContext-Instanzen im Dependency Injection-Container der Anwendung eingeführt. Dies kann sich als hilfreich erweisen, wenn Anwendungscode Kontextinstanzen manuell erstellen und löschen muss.EF Core 5.0 introduces AddDbContextFactory and AddPooledDbContextFactory to register a factory for creating DbContext instances in the application's dependency injection (D.I.) container; this can be useful when application code needs to create and dispose context instances manually.

services.AddDbContextFactory<SomeDbContext>(b =>
    b.UseSqlServer(@"Server=(localdb)\mssqllocaldb;Database=Test"));

Zu diesem Zeitpunkt kann IDbContextFactory<TContext> in Anwendungsdienste wie ASP.NET Core-Controller eingefügt werden, was dann zum Instanziieren von Kontextinstanzen verwendet wird:At this point, application services such as ASP.NET Core controllers can then be injected with IDbContextFactory<TContext>, and use it to instantiate context instances:

public class MyController
{
    private readonly IDbContextFactory<SomeDbContext> _contextFactory;

    public MyController(IDbContextFactory<SomeDbContext> contextFactory)
        => _contextFactory = contextFactory;

    public void DoSomeThing()
    {
        using (var context = _contextFactory.CreateDbContext())
        {
            // ...
        }
    }
}

Weitere Informationen finden Sie in der Dokumentation zu DbContextFactory.For further information, see the full documentation on DbContextFactory.

Neuerstellung von SQLite-TabellenSQLite table rebuilds

Im Vergleich zu anderen Datenbanken ist SQLite hinsichtlich der Schemamanipulationsfunktionen relativ eingeschränkt, beispielsweise wird das Löschen einer vorhandenen Tabelle nicht unterstützt.Compared to other databases, SQLite is relatively limited in its schema manipulation capabilities; for example, dropping a column from an existing table is not supported. EF Core 5.0 umgeht diese Einschränkungen, indem automatisch eine neue Tabelle erstellt wird, die Daten aus der alten Tabelle kopiert werden, die alte Tabelle gelöscht wird und die neue Tabelle umbenannt wird.EF Core 5.0 works around these limitations by automatically creating a new table, copying the data from the old table, dropping the old table and renaming the new one. Dadurch wird die Tabelle „neu erstellt“, und zuvor nicht unterstützte Migrationsvorgänge können dann sicher angewendet werden.This "rebuilds" the table, and allows previously unsupported migration operations to be safely applied.

Ausführliche Informationen dazu, welche Migrationsvorgänge nun über Neuerstellungen von Tabellen unterstützt werden, finden Sie in dieser Dokumentation.For details on which migration operations are now supported via table rebuilds, see this documentation page.

DatenbanksortierungenDatabase collations

Mit EF Core 5.0 wird Unterstützung für das Festlegen von Textsortierungen auf Datenbank-, Spalten- oder Abfrageebene eingeführt.EF Core 5.0 introduces support for specifying text collations at the database, column or query level. Dies ermöglicht die Konfiguration der Unterscheidung nach Groß-/Kleinschreibung und anderen Textaspekten, die flexibel ist und die Abfrageleistung nicht beeinträchtigt.This allows case sensitivity and other textual aspects to be configured in a way that is both flexible and does not compromise query performance.

Mit dem folgenden Code wird die Name-Spalte so konfiguriert, dass sie die Groß-/Kleinschreibung bei SQL Server beachtet, und alle für die Spalten erstellten Indizes funktionieren entsprechend:For example, the following will configure the Name column to be case-sensitive on SQL Server, and any indexes created on the column will function accordingly:

modelBuilder
    .Entity<User>()
    .Property(e => e.Name)
    .UseCollation("SQL_Latin1_General_CP1_CS_AS");

Weitere Informationen finden Sie in der Dokumentation zu Sortierungen und die Beachtung der Groß-/Kleinschreibung.For further information, see the full documentation on collations and case sensitivity.

EreignisindikatorenEvent counters

EF Core 5.0 stellt Ereignisindikatoren zur Verfügung, die dazu verwendet werden können, die Leistung und verschiedene Anomalien Ihrer Anwendung zu überwachen.EF Core 5.0 exposes event counters which can be used to track your application's performance and spot various anomalies. Fügen Sie einfach einen Prozess an, der Entity Framework mit dem Tool dotnet-counters ausführt:Simply attach to a process running EF with the dotnet-counters tool:

> dotnet counters monitor Microsoft.EntityFrameworkCore -p 49496

[Microsoft.EntityFrameworkCore]
    Active DbContexts                                               1
    Execution Strategy Operation Failures (Count / 1 sec)           0
    Execution Strategy Operation Failures (Total)                   0
    Optimistic Concurrency Failures (Count / 1 sec)                 0
    Optimistic Concurrency Failures (Total)                         0
    Queries (Count / 1 sec)                                     1,755
    Queries (Total)                                            98,402
    Query Cache Hit Rate (%)                                      100
    SaveChanges (Count / 1 sec)                                     0
    SaveChanges (Total)                                             1

Weitere Informationen finden Sie in der Dokumentation zu Ereignisindikatoren.For further information, see the full documentation on event counters.

Weitere FeaturesOther features

ModellerstellungModel building

  • Es wurden APIs für die Modellerstellung eingeführt, um die Konfiguration von Wertvergleichen zu vereinfachen.Model building APIs have been introduced for easier configuration of value comparers.
  • Berechnete Spalten können nun als gespeichert oder virtuell konfiguriert werden.Computed columns can now be configured as stored or virtual.
  • Die Präzision und Skalierung kann nun über die Fluent-API konfiguriert werden.Precision and scale can now be configured via the Fluent API.
  • Für Navigationseigenschaften wurden neue APIs für die Modellerstellung eingeführt.New model building APIs have been introduced for navigation properties.
  • Für Felder wurden ähnlich wie für Eigenschaften neue APIs für die Modellerstellung eingeführt.New model building APIs have been introduced for fields, similar to properties.
  • Die .NET-Typen PhysicalAddress und IPAddress können nun zu Zeichenfolgenspalten der Datenbank zugeordnet werden.The .NET PhysicalAddress and IPAddress types can now be mapped to database string columns.
  • Über das neue [BackingField]-Attribut kann nun eine Unterstützungsvariable konfiguriert werden.A backing field can now be configured via the new [BackingField] attribute.
  • Unterstützungsvariablen, die NULL-Werte zulassen, sind nun zulässig, wodurch bessere Unterstützung für vom Speicher generierte Standardwerte bereitgestellt wird, wenn CLR-Standardwerte sich nicht als guter Sentinelwert eignen (insbesondere bool).Nullable backing fields are now allowed, providing better support for store-generated defaults where the CLR default isn't a good sentinel value (notable bool).
  • Anstelle der Fluent-API kann nun ein neues [Index]-Attribut für einen Entitätstyp verwendet werden, um einen Index anzugeben.A new [Index] attribute can be used on an entity type to specify an index, instead of using the Fluent API.
  • Ein neues [Keyless]-Attribut kann verwendet werden, um einen Entitätstyp so zu konfigurieren, dass er über keinen Schlüssel verfügt.A new [Keyless] attribute can be used to configure an entity type as having no key.
  • Standardmäßig betrachtet EF Core Diskriminatoren nun als vollständig, d. h., es wird davon ausgegangen, dass nie Diskriminatorwerte vorliegen, die nicht von der Anwendung im Modell konfiguriert wurden.By default, EF Core now regards discriminators as complete, meaning that it expects to never see discriminator values not configured by the application in the model. Dies ermöglicht einige Leistungsverbesserungen und kann deaktiviert werden, wenn Ihre Diskriminatorspalte unbekannte Werte enthalten kann.This allows for some performance improvements, and can be disabled if your discriminator column might hold unknown values.

AbfrageQuery

  • Ausnahmen für Fehler bei der Abfrageübersetzung enthalten nun explizitere Grüne für Fehler, um die Ermittlung des Problems zu vereinfachen.Query translation failure exceptions now contain more explicit reasons about the reasons for the failure, to help pinpoint the issue.
  • Abfragen ohne Nachverfolgung können nun die Identitätsauflösung durchführen, um zu vermeiden, dass mehrere Entitätsinstanzen für dasselbe Datenbankobjekt zurückgegeben werden.No-tracking queries can now perform identity resolution, avoiding multiple entity instances being returned for the same database object.
  • Es wurde Unterstützung für GroupBy mit bedingten Aggregaten hinzugefügt (z. B. GroupBy(o => o.OrderDate).Select(g => g.Count(i => i.OrderDate != null))).Added support for GroupBy with conditional aggregates (e.g. GroupBy(o => o.OrderDate).Select(g => g.Count(i => i.OrderDate != null))).
  • Es wurde Unterstützung für die Übersetzung des Distinct-Operators über Gruppenelemente vor der Aggregation hinzugefügt.Added support for translating the Distinct operator over group elements before aggregate.
  • Die Übersetzung von Reverse wurde hinzugefügt.Translation of Reverse.
  • Die Übersetzung bezüglich DateTime wurde für SQL Server verbessert (z. B. DateDiffWeek, DateFromParts).Improved translation around DateTime for SQL Server (e.g. DateDiffWeek, DateFromParts).
  • Die Übersetzung neuer Methoden in Bytearrays wurde hinzugefügt (z. B. Contains, Length, SequenceEqual).Translation of new methods on byte arrays (e.g. Contains, Length, SequenceEqual).
  • Die Übersetzung von einigen zusätzlichen bitweisen Operatoren wurde hinzugefügt (z. B. das Zweierkomplement).Translation of some additional bitwise operators, such as two's complement.
  • Die Übersetzung von FirstOrDefault über Zeichenfolgen wurde hinzugefügt.Translation of FirstOrDefault over strings.
  • Die Abfrageübersetzung bezüglich der NULL-Semantik wurde verbessert, wodurch effizientere Abfragen ermöglicht werden.Improved query translation around null semantics, resulting in tighter, more efficient queries.
  • Von Benutzern zugeordnete Funktionen können nun mit Anmerkungen versehen werden, um die NULL-Weitergabe zu steuern, was ebenfalls zu effizienteren Abfragen führt.User-mapped functions can now be annotated to control null propagation, again resulting in tighter, more efficient queries.
  • SQL-Code mit CASE-Blöcken ist nun deutlich kürzer.SQL containing CASE blocks is now considerably more concise.
  • Die SQL Server-Funktion DATELENGTH kann nun über die neue Methode EF.Functions.DataLength in Abfragen aufgerufen werden.The SQL Server DATELENGTH function can now be called in queries via the new EF.Functions.DataLength method.
  • EnableDetailedErrors fügt zusätzliche Informationen zu Ausnahmen hinzu.EnableDetailedErrors adds additional details to exceptions.

SpeichernSaving

  • Abfangen und Ereignisse von SaveChangesSaveChanges interception and events.
  • Es wurden APIs zum Steuern von Transaktionssicherungspunkten eingeführt.APIs have been introduced for controlling transaction savepoints. Außerdem erstellt EF Core automatisch einen Sicherungspunkt, wenn SaveChanges aufgerufen wird und bereits eine Transaktion ausgeführt wird. Im Falle eines Fehlers wird ein Rollback ausgeführt.In addition, EF Core will automatically create a savepoint when SaveChanges is called and a transaction is already in progress, and roll back to it in case of failure.
  • Eine Transaktions-ID kann explizit von der Anwendung festgelegt werden, was eine einfachere Korrelation von Transaktionsereignissen bei der Protokollierung und in anderen Szenarios ermöglicht.A transaction ID can be explicitly set by the application, allowing for easier correlation of transaction events in logging and elsewhere.
  • Die standardmäßige maximale Batchgröße für SQL Server wurde basierend auf einer Analyse der Batchverarbeitungsleistung in „42“ geändert.The default maximum batch size for SQL Server has been changed to 42 based on an analysis of batching performance.

Migrationen und GerüstbauMigrations and scaffolding

  • Tabellen können nun aus Migrationen ausgeschlossen werden.Tables can now be excluded from migrations.
  • Ein neuer dotnet ef migrations list-Befehl zeigt an, welche Migrationen noch nicht auf die Datenbank angewendet wurden (Get-Migration erzielt dasselbe in der Paketverwaltungskonsole).A new dotnet ef migrations list command now shows which migrations have not yet been applied to the database (Get-Migration does the same in the Package Management Console).
  • Migrationsskripts enthalten nun ggf.Transaktionsanweisungen, um die Verarbeitung von Fällen zu verbessern, in denen die Migrationsanwendung nicht erfolgreich ausgeführt wurde.Migrations scripts now contain transaction statements where appropriate to improve handling cases where migration application fails.
  • Die Spalten für nicht zugeordnete Basisklassen sind nun nach anderen Spalten für zugeordnete Entitätstypen angeordnet.The columns for unmapped base classes are now ordered after other columns for mapped entity types. Beachten Sie, dass sich dies nur auf neu erstellte Tabellen auswirkt. Die Spaltenreihenfolge für vorhandene Tabellen bleibt unverändert.Note this only impacts newly created tables; the column order for existing tables remains unchanged.
  • Die Migrationsgeneration kann nun erkennen, wenn die Migration als idempotent generiert wird und ob die Ausgabe sofort ausgeführt oder als Skript generiert wird.Migration generation can now be aware if the migration being generated is idempotent, and whether the output will be executed immediately or generated as a script.
  • Es wurden neue Befehlszeilenparameter zum Festlegen von Namespaces in Migrationen und im Gerüstbau hinzugefügt.New command-line parameters have been added for specifying namespaces in Migrations and scaffolding.
  • Der Befehl dotnet ef database update akzeptiert nun einen neuen --connection-Parameter zum Festlegen der Verbindungszeichenfolge.The dotnet ef database update command now accepts a new --connection parameter for specifying the connection string.
  • Der Gerüstbau für vorhandene Datenbanken formuliert Tabellennamen nun im Singular. Für Tabellen mit den Namen People und Addresses werden nun beispielsweise Entitätstypen namens Person und Address erstellt.Scaffolding existing databases now singularizes table names, so tables named People and Addresses will be scaffolded to entity types called Person and Address. Die ursprünglichen Datenbanknamen können weiterhin beibehalten werden.Original database names can still be preserved.
  • Die neue Option --no-onconfiguring kann EF Core dazu anweisen, OnModelConfiguring beim Gerüstbau eines Modells auszuschließen.The new --no-onconfiguring option can instruct EF Core to exclude OnModelConfiguring when scaffolding a model.

CosmosCosmos

SQLiteSqlite

  • Berechnete Spalten werden nun unterstützt.Computed columns are now supported.
  • Das Abrufen von Binär- und Zeichenfolgendaten mit GetBytes, GetChars und GetTextReader ist nun effizienter durch die Verwendung von SqliteBlob und Datenströmen.Retrieving binary and string data with GetBytes, GetChars, and GetTextReader is now more efficient by making use of SqliteBlob and streams.
  • Die Initialisierung von SqliteConnection ist nun verzögert.Initialization of SqliteConnection is now lazy.

AndereOther

  • Nun können Proxys für die Änderungsnachverfolgung generiert werden, die automatisch INotifyPropertyChanging und INotifyPropertyChanged implementieren.Change-tracking proxies can be generated that automatically implement INotifyPropertyChanging and INotifyPropertyChanged. Dies bietet einen alternativen Ansatz für die Änderungsnachverfolgung, die nicht nach Änderungen sucht, wenn SaveChanges aufgerufen wird.This provides an alternative approach to change-tracking that doesn't scan for changes when SaveChanges is called.
  • Eine DbConnection-Klasse oder Verbindungszeichenfolge kann nun für eine bereits initialisierte DbContext-Instanz geändert werden.A DbConnection or connection string can now be changed on an already-initialized DbContext.
  • Die neue Methode ChangeTracker.Clear.(#Microsoft_EntityFrameworkCore_ChangeTracking_ChangeTracker_Clear) löscht die DbContext-Instanzen aller überwachten Entitäten.The new ChangeTracker.Clear.0#Microsoft_EntityFrameworkCore_ChangeTracking_ChangeTracker_Clear) method clears the DbContext of all tracked entities. Dies sollte normalerweise nicht erforderlich sein, wenn die bewährte Methode zum Erstellen einer neuen kurzlebigen Kontextinstanz für jede Arbeitseinheit angewandt wird.This should usually not be needed when using the best practice of creating a new, short-lived context instance for each unit-of-work. Wenn der Zustand einer DbContext-Instanz jedoch zurückgesetzt werden muss, ist die Verwendung der neuen Clear()-Methode effizienter und robuster als ein Vorgang zum Trennen aller Entitäten.However, if there is a need to reset the state of a DbContext instance, then using the new Clear() method is more efficient and robust than mass-detaching all entities.
  • Die Befehlszeilentools von EF Core konfigurieren nun die ASPNETCORE_ENVIRONMENT- und DOTNET_ENVIRONMENT-Umgebungsvariablen automatisch als „Entwicklung“.The EF Core command line tools now automatically configure the ASPNETCORE_ENVIRONMENT and DOTNET_ENVIRONMENT environment variables to "Development". Dadurch wird die Benutzeroberfläche bei der Verwendung des generischen Hosts mit der Benutzeroberfläche für die Entwicklung von ASP.NET Core in Einklang gebracht.This brings the experience when using the generic host in line with the experience for ASP.NET Core during development.
  • Benutzerdefinierte Befehlszeilenargumente können nun an IDesignTimeDbContextFactory<TContext> übertragen werden, sodass Anwendungen steuern können, wie der Kontext erstellt und initialisiert wird.Custom command-line arguments can be flowed into IDesignTimeDbContextFactory<TContext>, allowing applications to control how the context is created and initialized.
  • Der Füllfaktor für den Index kann nun in SQL Server konfiguriert werden.The index fill factor can now be configured on SQL Server.
  • Die neue Eigenschaft IsRelational kann dazu verwendet werden, zu unterscheiden, ob ein relationaler oder nicht relationaler Anbieter verwendet wird (z. B. InMemory).The new IsRelational property can be used to distinguish when using a relational provider and a non-relation provider (such as InMemory).