EF Core 6,0 ' deki yenilikler

Makale
12/05/2021
Okumak için 67 dakika

EF Core 6,0 NuGetgönderildi. Bu sayfa, bu yayında sunulan ilginç değişikliklere genel bakış içerir.

İpucu

GitHub örnek kodu indirerekaşağıda gösterilen örneklere çalıştırabilir ve hata ayıklaması yapabilirsiniz.

SQL Server zamana bağlı tablolar

GitHub sorunu: #4693.

SQL Server zamana bağlı tablolar, veriler güncelleştirildikten veya silindikten sonra bile, bir tabloda depolanan tüm verileri otomatik olarak takip edin. Bu, ana tabloya her değişiklik yapıldığında, zaman damgası alınan geçmiş verilerinin depolandığı paralel bir "geçmiş tablosu" oluşturarak elde edilir. Bu, denetim veya geri yükleme gibi geçmiş verilerin sorgulanmasını (örneğin, yanlışlıkla ya da silinmeden sonra kurtarma için) sağlar.

EF Core Şu anda şunları destekler:

Geçişler kullanılarak zamana bağlı tabloların oluşturulması
Mevcut tabloların, geçiş kullanarak yeniden zamana bağlı tablolara dönüştürülmesi
Geçmiş verileri sorgulama
Geçmişteki bir noktadan verileri geri yükleme

Zamana bağlı bir tablo yapılandırma

Model Oluşturucu, bir tabloyu zamana bağlı olarak yapılandırmak için kullanılabilir. Örnek:

modelBuilder
    .Entity<Employee>()
    .ToTable("Employees", b => b.IsTemporal());

veritabanını oluşturmak için EF Core kullanırken, yeni tablo zaman damgaları ve geçmiş tablosu için SQL Server varsayılan değerleri ile bir zamana bağlı tablo olarak yapılandırılır. Örneğin, bir varlık türünü göz önünde bulundurun Employee :

public class Employee
{
    public Guid EmployeeId { get; set; }
    public string Name { get; set; }
    public string Position { get; set; }
    public string Department { get; set; }
    public string Address { get; set; }
    public decimal AnnualSalary { get; set; }
}

Oluşturulan zamana bağlı tablo şöyle görünür:

DECLARE @historyTableSchema sysname = SCHEMA_NAME()
EXEC(N'CREATE TABLE [Employees] (
    [EmployeeId] uniqueidentifier NOT NULL,
    [Name] nvarchar(100) NULL,
    [Position] nvarchar(100) NULL,
    [Department] nvarchar(100) NULL,
    [Address] nvarchar(1024) NULL,
    [AnnualSalary] decimal(10,2) NOT NULL,
    [PeriodEnd] datetime2 GENERATED ALWAYS AS ROW END NOT NULL,
    [PeriodStart] datetime2 GENERATED ALWAYS AS ROW START NOT NULL,
    CONSTRAINT [PK_Employees] PRIMARY KEY ([EmployeeId]),
    PERIOD FOR SYSTEM_TIME([PeriodStart], [PeriodEnd])
) WITH (SYSTEM_VERSIONING = ON (HISTORY_TABLE = [' + @historyTableSchema + N'].[EmployeeHistory]))');

SQL Server datetime2 , ve adlı iki gizli sütun oluşturduğunu PeriodEnd unutmayın PeriodStart . Bu "dönem sütunları", satırdaki verilerin varolduğu zaman aralığını temsil eder. Bu sütunlar EF Core modelinde Gölge özelliklerle eşlenir ve bu, daha sonra gösterildiği gibi sorgularda kullanılmasına izin verir.

Önemli

Bu sütunlardaki süreler her zaman SQL Server tarafından üretilen UTC zamanlardır. UTC zamanları, aşağıda gösterilen sorgularda olduğu gibi, zamana bağlı tablolar içeren tüm işlemler için kullanılır.

Ayrıca, adlı ilişkili bir geçmiş tablosunun EmployeeHistory otomatik olarak oluşturulduğunu fark edebilirsiniz. Süre sütunları ve geçmiş tablosunun adları, model oluşturucunun ek yapılandırmasıyla değiştirilebilir. Örnek:

modelBuilder
    .Entity<Employee>()
    .ToTable(
        "Employees",
        b => b.IsTemporal(
            b =>
            {
                b.HasPeriodStart("ValidFrom");
                b.HasPeriodEnd("ValidTo");
                b.UseHistoryTable("EmployeeHistoricalData");
            }));

Bu, SQL Server tarafından oluşturulan tabloda yansıtılır:

DECLARE @historyTableSchema sysname = SCHEMA_NAME()
EXEC(N'CREATE TABLE [Employees] (
    [EmployeeId] uniqueidentifier NOT NULL,
    [Name] nvarchar(100) NULL,
    [Position] nvarchar(100) NULL,
    [Department] nvarchar(100) NULL,
    [Address] nvarchar(1024) NULL,
    [AnnualSalary] decimal(10,2) NOT NULL,
    [ValidFrom] datetime2 GENERATED ALWAYS AS ROW START NOT NULL,
    [ValidTo] datetime2 GENERATED ALWAYS AS ROW END NOT NULL,
    CONSTRAINT [PK_Employees] PRIMARY KEY ([EmployeeId]),
    PERIOD FOR SYSTEM_TIME([ValidFrom], [ValidTo])
) WITH (SYSTEM_VERSIONING = ON (HISTORY_TABLE = [' + @historyTableSchema + N'].[EmployeeHistoricalData]))');

Zamana bağlı tabloları kullanma

Çoğu zaman zamana bağlı tablolar tıpkı diğer tüm tablolar gibi kullanılır. diğer bir deyişle, dönem sütunları ve geçmiş verileri, uygulamanın onları yoksayması için SQL Server tarafından saydam olarak işlenir. Örneğin, yeni varlıklar veritabanına normal şekilde kaydedilebilir:

context.AddRange(
    new Employee
    {
        Name = "Pinky Pie",
        Address = "Sugarcube Corner, Ponyville, Equestria",
        Department = "DevDiv",
        Position = "Party Organizer",
        AnnualSalary = 100.0m
    },
    new Employee
    {
        Name = "Rainbow Dash",
        Address = "Cloudominium, Ponyville, Equestria",
        Department = "DevDiv",
        Position = "Ponyville weather patrol",
        AnnualSalary = 900.0m
    },
    new Employee
    {
        Name = "Fluttershy",
        Address = "Everfree Forest, Equestria",
        Department = "DevDiv",
        Position = "Animal caretaker",
        AnnualSalary = 30.0m
    });

context.SaveChanges();

Bu veriler daha sonra normal şekilde sorgulanabilir, güncelleştirilir ve silinebilir. Örnek:

var employee = context.Employees.Single(e => e.Name == "Rainbow Dash");
context.Remove(employee);
context.SaveChanges();

Ayrıca, normal bir izleme sorgusundansonra, geçerli verilerin dönem sütunlarındaki değerlere izlenen varlıklardan erişilebilir. Örnek:

var employees = context.Employees.ToList();
foreach (var employee in employees)
{
    var employeeEntry = context.Entry(employee);
    var validFrom = employeeEntry.Property<DateTime>("ValidFrom").CurrentValue;
    var validTo = employeeEntry.Property<DateTime>("ValidTo").CurrentValue;

    Console.WriteLine($"  Employee {employee.Name} valid from {validFrom} to {validTo}");
}

Bu baskı:

Starting data:
  Employee Pinky Pie valid from 8/26/2021 4:38:58 PM to 12/31/9999 11:59:59 PM
  Employee Rainbow Dash valid from 8/26/2021 4:38:58 PM to 12/31/9999 11:59:59 PM
  Employee Fluttershy valid from 8/26/2021 4:38:58 PM to 12/31/9999 11:59:59 PM

ValidToSütunun (varsayılan olarak çağrılan PeriodEnd ) datetime2 en büyük değeri içerdiğini unutmayın. Bu, tablodaki geçerli satırlar için her zaman durumdur. ValidFromSütunlar (varsayılan olarak çağrılır PeriodStart ) SATıRıN eklendiği UTC saatini içerir.

Geçmiş verileri sorgulama

EF Core, tablodaki geçmiş verilerin bir çok yeni sorgu işleçleriyle sorgulanmasını destekler:

TemporalAsOf: Belirtilen UTC saatinde etkin (geçerli) satırları döndürür. Bu, belirli bir birincil anahtarın geçmiş tablosundan tek bir satırdır.
TemporalAll: Geçmiş verilerdeki tüm satırları döndürür. Bu, genellikle belirli bir birincil anahtarın geçmiş tablosundaki çok sayıda satırdır.
TemporalFromTo: Belirtilen iki UTC saati arasında etkin olan tüm satırları döndürür. Bu, belirli bir birincil anahtar için geçmiş tablosundan çok sayıda satır olabilir.
TemporalBetween: TemporalFromTo Üst sınır üzerinde etkin hale gelen satırların dahil olması dışında, ile aynıdır.
TemporalContainedIn: Etkin olan ve belirtilen iki UTC saati arasında etkin olan tüm satırları döndürür. Bu, belirli bir birincil anahtar için geçmiş tablosundan çok sayıda satır olabilir.

Not

bu işleçlerin her biri için tam olarak hangi satırların dahil edildiğini öğrenmek için SQL Server zamana bağlı tabloları belgelerine bakın.

Örneğin, verilerimizde bazı güncelleştirmeler yaptıktan sonra, TemporalAll geçmiş verileri görmek için kullanarak bir sorgu çalıştırabiliriz:

var history = context
    .Employees
    .TemporalAll()
    .Where(e => e.Name == "Rainbow Dash")
    .OrderBy(e => EF.Property<DateTime>(e, "ValidFrom"))
    .Select(
        e => new
        {
            Employee = e,
            ValidFrom = EF.Property<DateTime>(e, "ValidFrom"),
            ValidTo = EF.Property<DateTime>(e, "ValidTo")
        })
    .ToList();

foreach (var pointInTime in history)
{
    Console.WriteLine(
        $"  Employee {pointInTime.Employee.Name} was '{pointInTime.Employee.Position}' from {pointInTime.ValidFrom} to {pointInTime.ValidTo}");
}

EF 'in nasıl olduğunu fark edin . Özellik yöntemi , dönem sütunlarından değerlere erişmek için kullanılabilir. Bu, OrderBy yan tümcelerde verileri sıralamak için kullanılır ve sonra bu değerleri döndürülen verilere dahil eder.

Bu sorgu aşağıdaki verileri geri getirir:

Historical data for Rainbow Dash:
  Employee Rainbow Dash was 'Ponyville weather patrol' from 8/26/2021 4:38:58 PM to 8/26/2021 4:40:29 PM
  Employee Rainbow Dash was 'Wonderbolt Trainee' from 8/26/2021 4:40:29 PM to 8/26/2021 4:41:59 PM
  Employee Rainbow Dash was 'Wonderbolt Reservist' from 8/26/2021 4:41:59 PM to 8/26/2021 4:43:29 PM
  Employee Rainbow Dash was 'Wonderbolt' from 8/26/2021 4:43:29 PM to 8/26/2021 4:44:59 PM

Döndürülen son satırın 8/26/2021 4:44:59 PM 'de etkin durduğuna dikkat edin. Bunun nedeni, gökkuşağı Dash satırının o anda ana tablodan silindiği içindir. Bu verilerin nasıl geri yüklenebildiğinden daha sonra görülecektir.

Benzer sorgular,, veya kullanılarak TemporalFromTo yazılabilir TemporalBetweenTemporalContainedIn . Örnek:

var history = context
    .Employees
    .TemporalBetween(timeStamp2, timeStamp3)
    .Where(e => e.Name == "Rainbow Dash")
    .OrderBy(e => EF.Property<DateTime>(e, "ValidFrom"))
    .Select(
        e => new
        {
            Employee = e,
            ValidFrom = EF.Property<DateTime>(e, "ValidFrom"),
            ValidTo = EF.Property<DateTime>(e, "ValidTo")
        })
    .ToList();

Bu sorgu aşağıdaki satırları döndürür:

Historical data for Rainbow Dash between 8/26/2021 4:41:14 PM and 8/26/2021 4:42:44 PM:
  Employee Rainbow Dash was 'Wonderbolt Trainee' from 8/26/2021 4:40:29 PM to 8/26/2021 4:41:59 PM
  Employee Rainbow Dash was 'Wonderbolt Reservist' from 8/26/2021 4:41:59 PM to 8/26/2021 4:43:29 PM

Geçmiş verileri geri yükleme

Yukarıda belirtildiği gibi, gökkuşağı Dash Employees tablodan silindi. Bu çok açık bir hata olduğundan, bir zaman noktasına geri dönüp eksik satırı bu süreden geri yükleyebilir.

var employee = context
    .Employees
    .TemporalAsOf(timeStamp2)
    .Single(e => e.Name == "Rainbow Dash");

context.Add(employee);
context.SaveChanges();

Bu sorgu, belirtilen UTC saatinde olduğu gibi gökkuşağı Dash için tek bir satır döndürür. Zamana bağlı işleçleri kullanan tüm sorgular varsayılan olarak izlenmez ve burada döndürülen varlık izlenmez. Bu, şu anda ana tabloda mevcut olmadığından anlamlı hale gelir. Varlığı ana tabloya yeniden eklemek için, bunu olarak işaretliyoruz Added ve sonra çağrıyoruz SaveChanges .

Satır gökkuşağı Dash satırını yeniden ekledikten sonra, geçmiş verileri sorgulamak satırın belirtilen UTC saatinde olduğu şekilde geri yüklendiğini gösterir:

Historical data for Rainbow Dash:
  Employee Rainbow Dash was 'Ponyville weather patrol' from 8/26/2021 4:38:58 PM to 8/26/2021 4:40:29 PM
  Employee Rainbow Dash was 'Wonderbolt Trainee' from 8/26/2021 4:40:29 PM to 8/26/2021 4:41:59 PM
  Employee Rainbow Dash was 'Wonderbolt Reservist' from 8/26/2021 4:41:59 PM to 8/26/2021 4:43:29 PM
  Employee Rainbow Dash was 'Wonderbolt' from 8/26/2021 4:43:29 PM to 8/26/2021 4:44:59 PM
  Employee Rainbow Dash was 'Wonderbolt Trainee' from 8/26/2021 4:44:59 PM to 12/31/9999 11:59:59 PM

Geçiş demeti

GitHub sorunu: #19693.

EF Core geçişleri, EF modelindeki değişikliklere dayalı olarak veritabanı şema güncelleştirmeleri oluşturmak için kullanılır. Bu şema güncelleştirmeleri, genellikle sürekli tümleştirme/sürekli dağıtımın (C.I./C.exe) bir parçası olarak uygulama dağıtım zamanına uygulanmalıdır. sistemin.

EF Core şimdi bu şema güncelleştirmelerini uygulamak için yeni bir yol içermektedir: geçiş paketleri. Geçiş paketi, geçişleri ve bu geçişleri veritabanına uygulamak için gereken kodu içeren küçük bir yürütülebilir dosyadır.

Not

geçişler, paketler ve dağıtıma yönelik daha ayrıntılı bir tartışma için .net bloguna yönelik DevOps kullanımı kolay EF Core geçiş demeti tanıtma konusuna bakın.

Geçiş paketleri dotnet ef komut satırı aracı kullanılarak oluşturulur. Devam etmeden önce aracın en son sürümünü yüklediğinizden emin olun.

Bir paketin dahil etmek için geçişlere ihtiyacı vardır. Bunlar dotnet ef migrations add , dotnet ef migrations addaçıklandığı gibi kullanılarak oluşturulur. Dağıtıma hazırladıktan sonra, kullanarak bir paket oluşturun dotnet ef migrations bundle . Örnek:

PS C:\local\AllTogetherNow\SixOh> dotnet ef migrations bundle
Build started...
Build succeeded.
Building bundle...
Done. Migrations Bundle: C:\local\AllTogetherNow\SixOh\efbundle.exe
PS C:\local\AllTogetherNow\SixOh>

Çıktı, hedef işletim sisteminiz için uygun bir yürütülebilir dosyadır. bu durumda Windows x64 olduğundan, efbundle.exe yerel klasörümdeki bir bırakıldım. Bu yürütülebilir dosyayı çalıştırmak, içinde yer alan geçişleri uygular:

PS C:\local\AllTogetherNow\SixOh> .\efbundle.exe
Applying migration '20210903083845_MyMigration'.
Done.
PS C:\local\AllTogetherNow\SixOh>

Geçişler veritabanına yalnızca henüz uygulanmamış olmaları durumunda uygulanır. Örneğin, uygulanacak yeni geçişler bulunmadığından aynı paketi yeniden çalıştırmak hiçbir şey yapmaz:

PS C:\local\AllTogetherNow\SixOh> .\efbundle.exe
No migrations were applied. The database is already up to date.
Done.
PS C:\local\AllTogetherNow\SixOh>

Ancak, modelde değişiklik yapılırsa ve ile daha fazla geçiş oluşturulursa dotnet ef migrations add , bunlar uygulamaya uygun yeni bir yürütülebilir dosya halinde paketlenmiştir. Örnek:

PS C:\local\AllTogetherNow\SixOh> dotnet ef migrations add SecondMigration
Build started...
Build succeeded.
Done. To undo this action, use 'ef migrations remove'
PS C:\local\AllTogetherNow\SixOh> dotnet ef migrations add Number3
Build started...
Build succeeded.
Done. To undo this action, use 'ef migrations remove'
PS C:\local\AllTogetherNow\SixOh> dotnet ef migrations bundle --force
Build started...
Build succeeded.
Building bundle...
Done. Migrations Bundle: C:\local\AllTogetherNow\SixOh\efbundle.exe
PS C:\local\AllTogetherNow\SixOh>

--forceSeçeneğinin, mevcut paketin üzerine yazmak için yeni bir paket ile kullanılabileceğini unutmayın.

Bu yeni paketin yürütülmesi, bu iki yeni geçişi veritabanına uygular:

PS C:\local\AllTogetherNow\SixOh> .\efbundle.exe
Applying migration '20210903084526_SecondMigration'.
Applying migration '20210903084538_Number3'.
Done.
PS C:\local\AllTogetherNow\SixOh>

Varsayılan olarak, paket uygulamanızın yapılandırmasından veritabanı bağlantı dizesini kullanır. Ancak, komut satırına bağlantı dizesi geçirerek farklı bir veritabanı geçirilebilir. Örnek:

PS C:\local\AllTogetherNow\SixOh> .\efbundle.exe --connection "Data Source=(LocalDb)\MSSQLLocalDB;Database=SixOhProduction"
Applying migration '20210903083845_MyMigration'.
Applying migration '20210903084526_SecondMigration'.
Applying migration '20210903084538_Number3'.
Done.
PS C:\local\AllTogetherNow\SixOh>

Bu zamanın, hiçbir zaman üretim veritabanına uygulanmadığından, üç geçişin uygulandığını unutmayın.

Diğer seçenekler komut satırına geçirilebilir. Bazı yaygın seçenekler şunlardır:

--output oluşturulacak yürütülebilir dosyanın yolunu belirtmek için.
--context proje birden çok bağlam türü içerdiğinde kullanılacak DbContext türünü belirtmek için.
--project kullanılacak projeyi belirtmek için. Geçerli çalışma dizinini varsayılan olarak belirler.
--startup-project kullanılacak başlangıç projesini belirtmek için. Geçerli çalışma dizinini varsayılan olarak belirler.
--no-build projeyi komutunu çalıştırmadan önce oluşturulmasını engellemek için. Bu, yalnızca projenin güncel olduğu bilindiğinde kullanılmalıdır.
--verbose komutun yaptığına ilişkin ayrıntılı bilgileri görmek için. Hata raporlarına bilgi eklerken bu seçeneği kullanın.

dotnet ef migrations bundle --helpTüm kullanılabilir seçenekleri görmek için kullanın.

Varsayılan olarak, her geçişin kendi işleminde uygulandığını unutmayın. bu alandaki olası gelecekteki geliştirmelerin tartışılması için GitHub sorun #22616 bakın.

Kural öncesi model yapılandırması

GitHub sorunu: #12229.

Önceki EF Core sürümleri, belirli bir türün her özelliği için eşlemenin, eşleme varsayılanından farklı olduğunda açık şekilde yapılandırılmasını gerektirir. Bu, en fazla dize uzunluğu ve ondalık duyarlık gibi özellik türü için de değer dönüştürme gibi "modeller" içerir.

Bu, aşağıdakilerden biri olabilir:

Her özellik için model Oluşturucu yapılandırması
Her özellikte bir eşleme özniteliği
Model oluşturulurken tüm varlık türlerinin tüm özellikleri ve alt düzey meta veri API 'Lerinin kullanımı üzerinde açık yineleme.

Varlık türleri ve eşlenmiş özellikler listesi bu yineleme gerçekleştiğinde son olarak gerçekleşmediğinden açık yineleme hata ile açıktır ve robustly zor olduğunu unutmayın.

EF Core 6,0, belirli bir tür için bu eşleme yapılandırmasının bir kez belirtilmesini sağlar. Daha sonra, bu türün modeldeki tüm özelliklerine uygulanır. Bu, modelin model oluşturma kuralları tarafından kullanılan yönlerini yapılandırdığından "kural öncesi model yapılandırması" olarak adlandırılır. Bu yapılandırma, şu şekilde geçersiz kılınarak uygulanır ConfigureConventionsDbContext :

public class SomeDbContext : DbContext
{
    protected override void ConfigureConventions(
        ModelConfigurationBuilder configurationBuilder)
    {
        // Pre-convention model configuration goes here
    }
}

Örneğin, aşağıdaki varlık türlerini göz önünde bulundurun:

public class Customer
{
    public int Id { get; set; }
    public string Name { get; set; }
    public bool IsActive { get; set; }
    public Money AccountValue { get; set; }

    public Session CurrentSession { get; set; }

    public ICollection<Order> Orders { get; } = new List<Order>();
}

public class Order
{
    public int Id { get; set; }
    public string SpecialInstructions { get; set; }
    public DateTime OrderDate { get; set; }
    public bool IsComplete { get; set; }
    public Money Price { get; set; }
    public Money? Discount { get; set; }

    public Customer Customer { get; set; }
}

Tüm dize özellikleri ANSI olacak şekilde yapılandırılabilir (Unicode yerine) ve en fazla 1024 uzunluğunda olmalıdır:

configurationBuilder
    .Properties<string>()
    .AreUnicode(false)
    .HaveMaxLength(1024);

Tüm tarih saat özellikleri veritabanındaki 64 bitlik tamsayıya dönüştürülebilir ve varsayılan olarak DateTimes 'den Long 'ye dönüştürülebilir:

configurationBuilder
    .Properties<DateTime>()
    .HaveConversion<long>();

Tüm bool özellikleri tamsayılara dönüştürülebilir 0 veya 1 yerleşik değer dönüştürücülerinin biri kullanılarak kullanılabilir:

configurationBuilder
    .Properties<bool>()
    .HaveConversion<BoolToZeroOneConverter<int>>();

SessionVarlığının geçici bir özelliği olduğu ve kalıcı olmaması gereken varsayılarak, modelde her yerde yoksayılabilir:

configurationBuilder
    .IgnoreAny<Session>();

Değer nesneleriyle çalışırken kural öncesi model yapılandırması çok yararlı olur. Örneğin, Money Yukarıdaki modeldeki tür salt okunurdur struct ile temsil edilir:

public readonly struct Money
{
    [JsonConstructor]
    public Money(decimal amount, Currency currency)
    {
        Amount = amount;
        Currency = currency;
    }

    public override string ToString()
        => (Currency == Currency.UsDollars ? "$" : "£") + Amount;

    public decimal Amount { get; }
    public Currency Currency { get; }
}

public enum Currency
{
    UsDollars,
    PoundsSterling
}

Bu daha sonra özel bir değer dönüştürücüsü kullanılarak JSON öğesine ve öğesinden seri hale getirilebilir:

public class MoneyConverter : ValueConverter<Money, string>
{
    public MoneyConverter()
        : base(
            v => JsonSerializer.Serialize(v, (JsonSerializerOptions)null),
            v => JsonSerializer.Deserialize<Money>(v, (JsonSerializerOptions)null))
    {
    }
}

Bu değer Dönüştürücüsü, tüm para kullanımları için bir kez yapılandırılabilir:

configurationBuilder
    .Properties<Money>()
    .HaveConversion<MoneyConverter>()
    .HaveMaxLength(64);

Ayrıca, seri hale getirilen JSON 'un depolandığı dize sütunu için ek modeller belirtilebildiğine dikkat edin. Bu durumda, sütun en fazla 64 uzunlukla sınırlıdır.

geçişler kullanılarak SQL Server için oluşturulan tablolar yapılandırmanın eşlenen tüm sütunlara nasıl uygulandığını gösterir:

CREATE TABLE [Customers] (
    [Id] int NOT NULL IDENTITY,
    [Name] varchar(1024) NULL,
    [IsActive] int NOT NULL,
    [AccountValue] nvarchar(64) NOT NULL,
    CONSTRAINT [PK_Customers] PRIMARY KEY ([Id])
);
CREATE TABLE [Order] (
    [Id] int NOT NULL IDENTITY,
    [SpecialInstructions] varchar(1024) NULL,
    [OrderDate] bigint NOT NULL,
    [IsComplete] int NOT NULL,
    [Price] nvarchar(64) NOT NULL,
    [Discount] nvarchar(64) NULL,
    [CustomerId] int NULL,
    CONSTRAINT [PK_Order] PRIMARY KEY ([Id]),
    CONSTRAINT [FK_Order_Customers_CustomerId] FOREIGN KEY ([CustomerId]) REFERENCES [Customers] ([Id])
);

Ayrıca, belirli bir tür için varsayılan bir tür eşlemesi belirtmek mümkündür. Örnek:

configurationBuilder
    .DefaultTypeMapping<string>()
    .IsUnicode(false);

Bu nadiren gereklidir, ancak bir tür sorguda, modelin eşlenmiş özelliğiyle bağıntılı bir şekilde kullanılırsa yararlı olabilir.

Not

Bkz. duyurusu Entity Framework Core 6,0 Preview 6: .net blogda daha fazla tartışma ve kural öncesi model yapılandırması örnekleri Için kuralları yapılandırma.

Derlenen modeller

GitHub sorunu: #1906.

Derlenen modeller, büyük modellerdeki uygulamalar için EF Core başlangıç süresini iyileştirebilir. Büyük bir model tipik olarak, varlık türlerinin ve ilişkilerin bir Yüs-1000 olması anlamına gelir.

Başlangıç zamanı, bu DbContext türü uygulamada ilk kez kullanıldığında bir DbContext üzerinde ilk işlemin gerçekleştirileceği zaman anlamına gelir. Yalnızca DbContext örneği oluşturmanın EF modelinin başlatılmasına neden olmadığına unutmayın. Bunun yerine, modelin başlatılmasına neden olan tipik ilk işlemler, DbContext.Add ilk sorgunun çağrılmasını veya yürütülmesini içerir.

Derlenen modeller dotnet ef komut satırı aracı kullanılarak oluşturulur. Devam etmeden önce aracın en son sürümünü yüklediğinizden emin olun.

dbcontext optimizeDerlenmiş modeli oluşturmak için yeni bir komut kullanılır. Örnek:

dotnet ef dbcontext optimize

--output-dirVe --namespace seçenekleri, derlenmiş modelin üretilecektir dizin ve ad alanını belirtmek için kullanılabilir. Örnek:

PS C:\dotnet\efdocs\samples\core\Miscellaneous\CompiledModels> dotnet ef dbcontext optimize --output-dir MyCompiledModels --namespace MyCompiledModels
Build started...
Build succeeded.
Successfully generated a compiled model, to use it call 'options.UseModel(MyCompiledModels.BlogsContextModel.Instance)'. Run this command again when the model is modified.
PS C:\dotnet\efdocs\samples\core\Miscellaneous\CompiledModels>

Bu komutu çalıştırmanın çıktısı, derlenmiş modeli EF Core sağlamak üzere DbContext yapılandırmanıza kopyalamak ve yapıştırmak için bir kod parçası içerir. Örnek:

protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    => optionsBuilder
        .UseModel(MyCompiledModels.BlogsContextModel.Instance)
        .UseSqlite(@"Data Source=test.db");

Derlenen model önyüklemesi

Genellikle oluşturulan önyükleme koduna bakmak gerekmez. Ancak, bazen modeli veya yüklemeyi özelleştirmek yararlı olabilir. Önyükleme kodu şuna benzer:

[DbContext(typeof(BlogsContext))]
partial class BlogsContextModel : RuntimeModel
{
    private static BlogsContextModel _instance;
    public static IModel Instance
    {
        get
        {
            if (_instance == null)
            {
                _instance = new BlogsContextModel();
                _instance.Initialize();
                _instance.Customize();
            }

            return _instance;
        }
    }

    partial void Initialize();

    partial void Customize();
}

Bu, modeli gerektiği gibi özelleştirmek için uygulanabilecek kısmi yöntemlere sahip kısmi bir sınıftır.

Ayrıca, bazı çalışma zamanı yapılandırmasına bağlı olarak farklı modeller kullanan DbContext türleri için birden çok derlenmiş model oluşturulabilir. Bunlar yukarıda gösterildiği gibi farklı klasörlere ve ad alanlarına yerleştirilmelidir. Bağlantı dizesi gibi çalışma zamanı bilgileri daha sonra incelenmek ve gerektiği şekilde geri döndürülen doğru modellenebilir. Örnek:

public static class RuntimeModelCache
{
    private static readonly ConcurrentDictionary<string, IModel> _runtimeModels
        = new();

    public static IModel GetOrCreateModel(string connectionString)
        => _runtimeModels.GetOrAdd(
            connectionString, cs =>
                {
                    if (cs.Contains("X"))
                    {
                        return BlogsContextModel1.Instance;
                    }

                    if (cs.Contains("Y"))
                    {
                        return BlogsContextModel2.Instance;
                    }

                    throw new InvalidOperationException("No appropriate compiled model found.");
                });
}

Sınırlamalar

Derlenen modeller bazı sınırlamalara sahiptir:

Genel sorgu filtreleri desteklenmiyor.
Yavaş yükleme ve değişiklik izleme proxy 'leri desteklenmez.
Özel IModelCacheKeyFactory uygulamaları desteklenmez. Ancak, birden çok modeli derleyebilir ve gerektiğinde uygun olanı yükleyebilirsiniz.
Model tanımı veya yapılandırma değişikliği her seferinde yeniden oluşturuluyor, modelin el ile eşitlenmesi gerekir.

Bu sınırlamalar nedeniyle, yalnızca EF Core başlangıç zamanı çok yavaşsa derlenen modeller kullanmanız gerekir. Küçük modellerin derlenmesi genellikle buna değer vermez.

Bu özelliklerden herhangi birini desteklemek, başarınız için kritik öneme sahip olursa, lütfen yukarıda bağlantılı olan ilgili sorunları oylayın.

Karşılaştırmalar

İpucu

GitHub ' den örnek kodu indirerek, büyük bir modeli derlemeyi ve üzerinde bir kıyaslama çalıştırmayı deneyebilirsiniz.

yukarıda başvurulan GitHub depo, 449 varlık türünü, 6390 özelliklerini ve 720 ilişkilerini içerir. Bu, oldukça büyük bir modeldir. Ölçmek için Benchmarkdotnet kullanarak, ortalama sorgu süresi, makul bir şekilde güçlü bir dizüstü bilgisayarda 1,02 saniyedir. Derlenmiş modelleri kullanmak, bunu aynı donanımda 117 milisaniyeye getirir. Bu şekilde bir 8X-10 kat geliştirmesi, model boyutu arttıkça görece sabit kalır.

Derlenen model performansı iyileştirmesi

Not

EF Core başlangıç performansı ve derlenmiş modellerin daha ayrıntılı bir açıklaması için bkz. Entity Framework Core 6,0 Preview 5: derlenmiş modeller

TechEmpower Fortunes üzerinde geliştirilmiş performans

GitHub sorunu: #23611.

EF Core 6,0 ' de sorgu performansı için önemli geliştirmeler yaptık. Özellikle:

EF Core 6,0 performansı artık sektör standardı TechEmpower Fortunes kıyaslaması üzerinde 70 ' e kıyasla daha hızlı bir 5,0 şekilde.
- Bu, kıyaslama kodundaki geliştirmeler, .NET çalışma zamanı vb. dahil olmak üzere tam yığın performans iyileştirmedir.
EF Core 6.0'ın kendisi izlenmeyen sorguların yürütülmesini %31 daha hızlı yürütür.
Sorgu yürüten yığın ayırmaları %43 azaltıldı.

Bu geliştirmelerden sonra TechEmpower Fortunes karşılaştırması kapsamındaki popüler "mikro ORM" Dapper ile EF Core arasındaki fark %55'in altında kaldı ve %5'in biraz altında kaldı.

Not

Entity Framework Core 6.0'daki sorgu performansı geliştirmeleri hakkında ayrıntılı bilgi için .NET Blog'da Entity Framework Core 6.0 Preview 4: Performance Edition EF Core bakın.

Cosmos sağlayıcı geliştirmeleri

EF Core 6.0, Azure Cosmos DB veritabanı sağlayıcısında birçok geliştirme içerir.

İpucu

GitHub'den örnek kodu indirerek Cosmos örneklere özel tüm örneklerde çalıştırabilir ve hata GitHub.

Varsayılan olarak örtülü sahiplik

GitHub Sorun: #24803.

Cosmos sağlayıcısı için bir model EF Core 6.0, alt varlık türlerini varsayılan olarak üst varlığa ait olarak işaret eder. Bu, modelde ve OwnsManyOwnsOne çağrılarının büyük bir Cosmos ortadan kaldırır. Bu, üst tür için alt türleri belgeye eklemeyi kolaylaştırır. Bu, genellikle bir belge veritabanında üst ve alt öğe modellemenin uygun yolu olur.

Örneğin, şu varlık türlerini göz önünde bulundurabilirsiniz:

public class Family
{
    [JsonPropertyName("id")]
    public string Id { get; set; }
    
    public string LastName { get; set; }
    public bool IsRegistered { get; set; }
    
    public Address Address { get; set; }

    public IList<Parent> Parents { get; } = new List<Parent>();
    public IList<Child> Children { get; } = new List<Child>();
}

public class Parent
{
    public string FamilyName { get; set; }
    public string FirstName { get; set; }
}

public class Child
{
    public string FamilyName { get; set; }
    public string FirstName { get; set; }
    public int Grade { get; set; }

    public string Gender { get; set; }

    public IList<Pet> Pets { get; } = new List<Pet>();
}

5 EF Core 5.0'da bu türler aşağıdaki yapılandırmayla Cosmos için modele alındı:

modelBuilder.Entity<Family>()
    .HasPartitionKey(e => e.LastName)
    .OwnsMany(f => f.Parents);

modelBuilder.Entity<Family>()
    .OwnsMany(f => f.Children)
    .OwnsMany(c => c.Pets);

modelBuilder.Entity<Family>()
    .OwnsOne(f => f.Address);

6 EF Core 6.0'da sahiplik örtülü olur ve model yapılandırması şu şekilde azalt olur:

modelBuilder.Entity<Family>().HasPartitionKey(e => e.LastName);

Sonuçta elde Cosmos aile belgesine aile ebeveynleri, çocukların, evcil hayvanlar ve adreslerinin ekli olduğu belgelerde yer almaktadır. Örnek:

{
  "Id": "Wakefield.7",
  "LastName": "Wakefield",
  "Discriminator": "Family",
  "IsRegistered": true,
  "id": "Family|Wakefield.7",
  "Address": {
    "City": "NY",
    "County": "Manhattan",
    "State": "NY"
  },
  "Children": [
    {
      "FamilyName": "Merriam",
      "FirstName": "Jesse",
      "Gender": "female",
      "Grade": 8,
      "Pets": [
        {
          "GivenName": "Goofy"
        },
        {
          "GivenName": "Shadow"
        }
      ]
    },
    {
      "FamilyName": "Miller",
      "FirstName": "Lisa",
      "Gender": "female",
      "Grade": 1,
      "Pets": []
    }
  ],
  "Parents": [
    {
      "FamilyName": "Wakefield",
      "FirstName": "Robin"
    },
    {
      "FamilyName": "Miller",
      "FirstName": "Ben"
    }
  ],
  "_rid": "x918AKh6p20CAAAAAAAAAA==",
  "_self": "dbs/x918AA==/colls/x918AKh6p20=/docs/x918AKh6p20CAAAAAAAAAA==/",
  "_etag": "\"00000000-0000-0000-adee-87f30c8c01d7\"",
  "_attachments": "attachments/",
  "_ts": 1632121802
}

Not

Bu sahip olunan türleri daha OwnsOne/OwnsMany fazla yapılandırmanız gerekirse yapılandırmanın kullan gerektiğini unutmayın.

Temel tür koleksiyonları

GitHub Sorun: #14762.

EF Core 6.0, veritabanı sağlayıcısını kullanırken ilkel tür koleksiyonlarını Cosmos eşler. Örneğin, şu varlık türünü göz önünde bulundurabilirsiniz:

public class Book
{
    public Guid Id { get; set; }
    public string Title { get; set; }
    public IList<string> Quotes { get; set; }
    public IDictionary<string, string> Notes { get; set; }
}

Hem liste hem de sözlük normal şekilde doldurularak veritabanına eklenebilir:

using var context = new BooksContext();

var book = new Book
{
    Title = "How It Works: Incredible History",
    Quotes = new List<string>
    {
        "Thomas (Tommy) Flowers was the British engineer behind the design of the Colossus computer.",
        "Invented originally for Guinness, plastic widgets are nitrogen-filled spheres.",
        "For 20 years after its introduction in 1979, the Walkman dominated the personal stereo market."
    },
    Notes = new Dictionary<string, string>
    {
        { "121", "Fridges" },
        { "144", "Peter Higgs" },
        { "48", "Saint Mark's Basilica" },
        { "36", "The Terracotta Army" }
    }
};

context.Add(book);
context.SaveChanges();

Bu, aşağıdaki JSON belgesiyle sonuç verir:

{
    "Id": "0b32283e-22a8-4103-bb4f-6052604868bd",
    "Discriminator": "Book",
    "Notes": {
        "36": "The Terracotta Army",
        "48": "Saint Mark's Basilica",
        "121": "Fridges",
        "144": "Peter Higgs"
    },
    "Quotes": [
        "Thomas (Tommy) Flowers was the British engineer behind the design of the Colossus computer.",
        "Invented originally for Guinness, plastic widgets are nitrogen-filled spheres.",
        "For 20 years after its introduction in 1979, the Walkman dominated the personal stereo market."
    ],
    "Title": "How It Works: Incredible History",
    "id": "Book|0b32283e-22a8-4103-bb4f-6052604868bd",
    "_rid": "t-E3AIxaencBAAAAAAAAAA==",
    "_self": "dbs/t-E3AA==/colls/t-E3AIxaenc=/docs/t-E3AIxaencBAAAAAAAAAA==/",
    "_etag": "\"00000000-0000-0000-9b50-fc769dc901d7\"",
    "_attachments": "attachments/",
    "_ts": 1630075016
}

Bu koleksiyonlar daha sonra normal şekilde yeniden güncelleştirilebilir:

book.Quotes.Add("Pressing the emergency button lowered the rods again.");
book.Notes["48"] = "Chiesa d'Oro";

context.SaveChanges();

Sınırlamalar:

Yalnızca dize anahtarlı sözlükler de destekle
Temel koleksiyonların içeriğini sorgulamak şu anda desteklenmiyor. Bu özellikler sizin için önemli ise #16926, #25700ve #25701 için oy verme.

Yerleşik işlevlere çeviriler

GitHub Sorun: #16143.

Cosmos sağlayıcısı artık daha fazla Temel Sınıf Kitaplığı (BCL) yöntemini Cosmos işlevlerine çevirir. Aşağıdaki tablolarda, EF Core 6.0'da yeni olan çeviriler yer almaktadır.

Dize çevirileri

BCL yöntemi	Yerleşik işlev	Notlar
`String.Length`	`LENGTH`
`String.ToLower`	`LOWER`
`String.TrimStart`	`LTRIM`
`String.TrimEnd`	`RTRIM`
`String.Trim`	`TRIM`
`String.ToUpper`	`UPPER`
`String.Substring`	`SUBSTRING`
`+` Işleç	`CONCAT`
`String.IndexOf`	`INDEX_OF`
`String.Replace`	`REPLACE`
`String.Equals`	`STRINGEQUAL`	Yalnızca büyük/büyük/büyük harfe duyarlı olmayan çağrılar

, LOWER , LTRIM , , , RTRIM ve TRIMUPPERSUBSTRING çevirileri, @Marusyk. LOWER Çok teşekkürler!

Örneğin:

var stringResults
    = context.Triangles.Where(
            e => e.Name.Length > 4
                 && e.Name.Trim().ToLower() != "obtuse"
                 && e.Name.TrimStart().Substring(2, 2).Equals("uT", StringComparison.OrdinalIgnoreCase))
        .ToList();

Bunu şöyle gösterebiliriz:

SELECT c
FROM root c
WHERE ((c["Discriminator"] = "Triangle") AND (((LENGTH(c["Name"]) > 4) AND (LOWER(TRIM(c["Name"])) != "obtuse")) AND STRINGEQUALS(SUBSTRING(LTRIM(c["Name"]), 2, 2), "uT", true)))

Matematik çevirileri

BCL yöntemi	Yerleşik işlev
`Math.Abs` veya `MathF.Abs`	`ABS`
`Math.Acos` veya `MathF.Acos`	`ACOS`
`Math.Asin` veya `MathF.Asin`	`ASIN`
`Math.Atan` veya `MathF.Atan`	`ATAN`
`Math.Atan2` veya `MathF.Atan2`	`ATN2`
`Math.Ceiling` veya `MathF.Ceiling`	`CEILING`
`Math.Cos` veya `MathF.Cos`	`COS`
`Math.Exp` veya `MathF.Exp`	`EXP`
`Math.Floor` veya `MathF.Floor`	`FLOOR`
`Math.Log` veya `MathF.Log`	`LOG`
`Math.Log10` veya `MathF.Log10`	`LOG10`
`Math.Pow` veya `MathF.Pow`	`POWER`
`Math.Round` veya `MathF.Round`	`ROUND`
`Math.Sign` veya `MathF.Sign`	`SIGN`
`Math.Sin` veya `MathF.Sin`	`SIN`
`Math.Sqrt` veya `MathF.Sqrt`	`SQRT`
`Math.Tan` veya `MathF.Tan`	`TAN`
`Math.Truncate` veya `MathF.Truncate`	`TRUNC`
`DbFunctions.Random`	`RAND`

Bu çeviriler, @Marusyk. Çok teşekkürler!

Örneğin:

var hypotenuse = 42.42;
var mathResults
    = context.Triangles.Where(
            e => (Math.Round(e.Angle1) == 90.0
                  || Math.Round(e.Angle2) == 90.0)
                 && (hypotenuse * Math.Sin(e.Angle1) > 30.0
                     || hypotenuse * Math.Cos(e.Angle2) > 30.0))
        .ToList();

Bunu şöyle gösterebiliriz:

SELECT c
FROM root c
WHERE ((c["Discriminator"] = "Triangle") AND (((ROUND(c["Angle1"]) = 90.0) OR (ROUND(c["Angle2"]) = 90.0)) AND (((@__hypotenuse_0 * SIN(c["Angle1"])) > 30.0) OR ((@__hypotenuse_0 * COS(c["Angle2"])) > 30.0))))

DateTime çevirileri

BCL yöntemi	Yerleşik işlev
`DateTime.UtcNow`	`GetCurrentDateTime`

Bu çeviriler, @Marusyk. Çok teşekkürler!

Örneğin:

var timeResults
    = context.Triangles.Where(
            e => e.InsertedOn <= DateTime.UtcNow)
        .ToList();

Bunu şöyle gösterebiliriz:

SELECT c
FROM root c
WHERE ((c["Discriminator"] = "Triangle") AND (c["InsertedOn"] <= GetCurrentDateTime()))

FromSql SQL ham sorgular

GitHub Sorun: #17311.

Bazen LINQ kullanmak yerine ham SQL sorgusunu yürütmek gerekir. Bu artık yöntemi aracılığıyla Cosmos sağlayıcıda FromSql de destekleni. Bu, ilişkisel sağlayıcılarla her zaman olduğu gibi çalışır. Örnek:

var maxAngle = 60;
var rawResults
    = context.Triangles.FromSqlRaw(
            @"SELECT * FROM root c WHERE c[""Angle1""] <= {0} OR c[""Angle2""] <= {0}",
            maxAngle)
        .ToList();

Şu şekilde yürütülür:

SELECT c
FROM (
         SELECT * FROM root c WHERE c["Angle1"] <= @p0 OR c["Angle2"] <= @p0
     ) c
WHERE (c["Discriminator"] = "Triangle")

Ayrı sorgular

GitHub Sorun: #16144.

kullanan basit Distinct sorgular artık çevrilmiştir. Örnek:

var distinctResults
    = context.Triangles
        .Select(e => e.Angle1).OrderBy(e => e).Distinct()
        .ToList();

Bunu şöyle gösterebiliriz:

SELECT DISTINCT c["Angle1"]
FROM root c
WHERE (c["Discriminator"] = "Triangle")
ORDER BY c["Angle1"]

Tanılama

GitHub Sorun: #17298.

Veri Cosmos artık veritabanından veri ekleme, sorgulama, güncelleştirme ve silme olayları da dahil olmak üzere daha fazla tanılama bilgisini günlüğe kaydeder. İstek birimleri (RU) uygun olduğunda bu olaylara dahil edilir.

Not

Günlükler burada kimlik EnableSensitiveDataLogging() değerlerinin gösterildiği şekilde kullanır.

Veritabanına bir öğe Cosmos olayı CosmosEventId.ExecutedCreateItem oluşturur. Örneğin, bu kod:

var triangle = new Triangle
{
    Name = "Impossible",
    PartitionKey = "TrianglesPartition",
    Angle1 = 90,
    Angle2 = 90,
    InsertedOn = DateTime.UtcNow
};
context.Add(triangle);
context.SaveChanges();