In this article, you will see ten new features in EF Core 6, including new feature annotation, support for temporal tables, sparse columns, and other new features.
1 Unicode properties
In EF Core 6.0, the new Unicode attribute allows you to map a string attribute to a non Unicode column without directly specifying the database type. When the database system only supports the Unicode type, the Unicode attribute is ignored.
public class Book
{
public int Id { get; set; }
public string Title { get; set; }
[Unicode(false)]
[MaxLength(22)]
public string Isbn { get; set; }
}Corresponding migration Code:
protected override void Up(MigrationBuilder migrationBuilder)
{
migrationBuilder.CreateTable(
name: "Books",
columns: table => new
{
Id = table.Column<int>(type: "int", nullable: false)
.Annotation("SqlServer:Identity", "1, 1"),
Title = table.Column<string>(type: "nvarchar(max)", nullable: true),
Isbn = table.Column<string>(type: "varchar(22)", unicode: false, maxLength: 22, nullable: true)
},
constraints: table =>
{
table.PrimaryKey("PK_Books", x => x.Id);
});
}2Precision properties
Before EF Core 6.0, you can configure accuracy with Fluent API. Now, you can also do this with data annotation and a new "PrecisionAttribute".
public class Product
{
public int Id { get; set; }
[Precision(precision: 10, scale: 2)]
public decimal Price { get; set; }
}Corresponding migration Code:
protected override void Up(MigrationBuilder migrationBuilder)
{
migrationBuilder.CreateTable(
name: "Products",
columns: table => new
{
Id = table.Column<int>(type: "int", nullable: false)
.Annotation("SqlServer:Identity", "1, 1"),
Price = table.Column<decimal>(type: "decimal(10,2)", precision: 10, scale: 2, nullable: false)
},
constraints: table =>
{
table.PrimaryKey("PK_Products", x => x.Id);
});
}3EntityTypeConfiguration attribute
Starting with EF Core 6.0, you can put a new "EntityTypeConfiguration" feature on the entity type, so that EF Core can find and use the appropriate configuration. Before that, the configuration of the class must be instantiated and invoked from the OnModelCreating method.
public class ProductConfiguration : IEntityTypeConfiguration<Product>
{
public void Configure(EntityTypeBuilder<Product> builder)
{
builder.Property(p => p.Name).HasMaxLength(250);
builder.Property(p => p.Price).HasPrecision(10, 2);
}
}
[EntityTypeConfiguration(typeof(ProductConfiguration))]
public class Product
{
public int Id { get; set; }
public decimal Price { get; set; }
public string Name { get; set; }
}4Column property
When you use inheritance in the model, you may not be satisfied with the default EF Core column order in the created table. In EF Core 6.0, you can use 'ColumnAttribute' to specify the order of columns.
In addition, you can also use the new Fluent API--HasColumnOrder().
public class EntityBase
{
[Column(Order = 1)]
public int Id { get; set; }
[Column(Order = 99)]
public DateTime UpdatedOn { get; set; }
[Column(Order = 98)]
public DateTime CreatedOn { get; set; }
}
public class Person : EntityBase
{
[Column(Order = 2)]
public string FirstName { get; set; }
[Column(Order = 3)]
public string LastName { get; set; }
public ContactInfo ContactInfo { get; set; }
}
public class Employee : Person
{
[Column(Order = 4)]
public string Position { get; set; }
[Column(Order = 5)]
public string Department { get; set; }
}
[Owned]
public class ContactInfo
{
[Column(Order = 10)]
public string Email { get; set; }
[Column(Order = 11)]
public string Phone { get; set; }
}Corresponding migration Code:
protected override void Up(MigrationBuilder migrationBuilder)
{
migrationBuilder.CreateTable(
name: "Employees",
columns: table => new
{
Id = table.Column<int>(type: "int", nullable: false)
.Annotation("SqlServer:Identity", "1, 1"),
FirstName = table.Column<string>(type: "nvarchar(max)", nullable: true),
LastName = table.Column<string>(type: "nvarchar(max)", nullable: true),
Position = table.Column<string>(type: "nvarchar(max)", nullable: true),
Department = table.Column<string>(type: "nvarchar(max)", nullable: true),
ContactInfo_Email = table.Column<string>(type: "nvarchar(max)", nullable: true),
ContactInfo_Phone = table.Column<string>(type: "nvarchar(max)", nullable: true),
CreatedOn = table.Column<DateTime>(type: "datetime2", nullable: false),
UpdatedOn = table.Column<DateTime>(type: "datetime2", nullable: false)
},
constraints: table =>
{
table.PrimaryKey("PK_Employees", x => x.Id);
});
}5 tense table
EF Core 6.0 supports temporal tables of SQL server. A table can be configured as a temporal table with SQL Server default timestamp and history table.
public class ExampleContext : DbContext
{
public DbSet<Person> People { get; set; }
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
modelBuilder
.Entity<Person>()
.ToTable("People", b => b.IsTemporal());
}
protected override void OnConfiguring(DbContextOptionsBuilder options)
=> options.UseSqlServer("Server=(localdb)\\mssqllocaldb;Database=TemporalTables;Trusted_Connection=True;");
}
public class Person
{
public int Id { get; set; }
public string Name { get; set; }
}Corresponding migration Code:
protected override void Up(MigrationBuilder migrationBuilder)
{
migrationBuilder.CreateTable(
name: "People",
columns: table => new
{
Id = table.Column<int>(type: "int", nullable: false)
.Annotation("SqlServer:Identity", "1, 1"),
Name = table.Column<string>(type: "nvarchar(max)", nullable: true),
PeriodEnd = table.Column<DateTime>(type: "datetime2", nullable: false)
.Annotation("SqlServer:IsTemporal", true)
.Annotation("SqlServer:TemporalPeriodEndColumnName", "PeriodEnd")
.Annotation("SqlServer:TemporalPeriodStartColumnName", "PeriodStart"),
PeriodStart = table.Column<DateTime>(type: "datetime2", nullable: false)
.Annotation("SqlServer:IsTemporal", true)
.Annotation("SqlServer:TemporalPeriodEndColumnName", "PeriodEnd")
.Annotation("SqlServer:TemporalPeriodStartColumnName", "PeriodStart")
},
constraints: table =>
{
table.PrimaryKey("PK_People", x => x.Id);
})
.Annotation("SqlServer:IsTemporal", true)
.Annotation("SqlServer:TemporalHistoryTableName", "PersonHistory")
.Annotation("SqlServer:TemporalHistoryTableSchema", null)
.Annotation("SqlServer:TemporalPeriodEndColumnName", "PeriodEnd")
.Annotation("SqlServer:TemporalPeriodStartColumnName", "PeriodStart");
}You can query and retrieve historical data in the following ways:
-
TemporalAsOf
-
TemporalAll
-
TemporalFromTo
-
TemporalBetween
-
TemporalContainedIn
Use tense table:
using ExampleContext context = new();
context.People.Add(new() { Name = "Oleg" });
context.People.Add(new() { Name = "Steve" });
context.People.Add(new() { Name = "John" });
await context.SaveChangesAsync();
var people = await context.People.ToListAsync();
foreach (var person in people)
{
var personEntry = context.Entry(person);
var validFrom = personEntry.Property<DateTime>("PeriodStart").CurrentValue;
var validTo = personEntry.Property<DateTime>("PeriodEnd").CurrentValue;
Console.WriteLine($"Person {person.Name} valid from {validFrom} to {validTo}");
}
// Output:
// Person Oleg valid from 06-Nov-21 17:50:39 PM to 31-Dec-99 23:59:59 PM
// Person Steve valid from 06-Nov-21 17:50:39 PM to 31-Dec-99 23:59:59 PM
// Person John valid from 06-Nov-21 17:50:39 PM to 31-Dec-99 23:59:59 PMQuery historical data:
var oleg = await context.People.FirstAsync(x => x.Name == "Oleg");
context.People.Remove(oleg);
await context.SaveChangesAsync();
var history = context
.People
.TemporalAll()
.Where(e => e.Name == "Oleg")
.OrderBy(e => EF.Property<DateTime>(e, "PeriodStart"))
.Select(
p => new
{
Person = p,
PeriodStart = EF.Property<DateTime>(p, "PeriodStart"),
PeriodEnd = EF.Property<DateTime>(p, "PeriodEnd")
})
.ToList();
foreach (var pointInTime in history)
{
Console.WriteLine(
$"Person {pointInTime.Person.Name} existed from {pointInTime.PeriodStart} to {pointInTime.PeriodEnd}");
}
// Output:
// Person Oleg existed from 06-Nov-21 17:50:39 PM to 06-Nov-21 18:11:29 PMRetrieve historical data:
var removedOleg = await context
.People
.TemporalAsOf(history.First().PeriodStart)
.SingleAsync(e => e.Name == "Oleg");
Console.WriteLine($"Id = {removedOleg.Id}; Name = {removedOleg.Name}");
// Output:
// Id = 1; Name = OlegLearn more about tense tables:
https://devblogs.microsoft.com/dotnet/prime-your-flux-capacitor-sql-server-temporal-tables-in-ef-core-6-0/
6 sparse columns
EF Core 6.0 supports SQL Server sparse columns. It can be useful when using TPH (table per hierarchy) inheritance mapping.
public class ExampleContext : DbContext
{
public DbSet<Person> People { get; set; }
public DbSet<Employee> Employees { get; set; }
public DbSet<User> Users { get; set; }
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
modelBuilder
.Entity<User>()
.Property(e => e.Login)
.IsSparse();
modelBuilder
.Entity<Employee>()
.Property(e => e.Position)
.IsSparse();
}
protected override void OnConfiguring(DbContextOptionsBuilder options)
=> options.UseSqlServer("Server=(localdb)\\mssqllocaldb;Database=SparseColumns;Trusted_Connection=True;");
}
public class Person
{
public int Id { get; set; }
public string Name { get; set; }
}
public class User : Person
{
public string Login { get; set; }
}
public class Employee : Person
{
public string Position { get; set; }
}Corresponding migration Code:
protected override void Up(MigrationBuilder migrationBuilder)
{
migrationBuilder.CreateTable(
name: "People",
columns: table => new
{
Id = table.Column<int>(type: "int", nullable: false)
.Annotation("SqlServer:Identity", "1, 1"),
Name = table.Column<string>(type: "nvarchar(max)", nullable: false),
Discriminator = table.Column<string>(type: "nvarchar(max)", nullable: false),
Position = table.Column<string>(type: "nvarchar(max)", nullable: true)
.Annotation("SqlServer:Sparse", true),
Login = table.Column<string>(type: "nvarchar(max)", nullable: true)
.Annotation("SqlServer:Sparse", true)
},
constraints: table =>
{
table.PrimaryKey("PK_People", x => x.Id);
});
}Sparse columns are limited. Please refer to the document for details:
https://docs.microsoft.com/en-us/sql/relational-databases/tables/use-sparse-columns?view=sql-server-ver15
Minimum API in 7EF Core
EF Core 6.0 has its own minimal API. The new extension method can register a DbContext type in the same line of code and provide the configuration of a database Provider.
const string AccountKey = "[CosmosKey]";
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddSqlServer<MyDbContext>(@"Server = (localdb)\mssqllocaldb; Database = MyDatabase");
// OR
builder.Services.AddSqlite<MyDbContext>("Data Source=mydatabase.db");
// OR
builder.Services.AddCosmos<MyDbContext>($"AccountEndpoint=https://localhost:8081/;AccountKey={AccountKey}", "MyDatabase");
var app = builder.Build();
app.Run();
class MyDbContext : DbContext
{ }8 migration package
In EF Core 6.0, there is a new function in favor of DevOps - migration package. It allows you to create a small executable program that includes migration. You can use it on a CD. There is no need to copy source code or install NET SDK (runtime only).
CLI:
dotnet ef migrations bundle --project MigrationBundles
Package Manager Console:
Bundle-Migration
More information:
https://devblogs.microsoft.com/dotnet/introducing-devops-friendly-ef-core-migration-bundles/
9 preset model configuration
EF Core 6.0 introduces a preset model configuration. It allows you to specify a mapping configuration for a given type. For example, it can be helpful when working with value objects.
public class ExampleContext : DbContext
{
public DbSet<Person> People { get; set; }
public DbSet<Product> Products { get; set; }
protected override void ConfigureConventions(ModelConfigurationBuilder configurationBuilder)
{
configurationBuilder
.Properties<string>()
.HaveMaxLength(500);
configurationBuilder
.Properties<DateTime>()
.HaveConversion<long>();
configurationBuilder
.Properties<decimal>()
.HavePrecision(12, 2);
configurationBuilder
.Properties<Address>()
.HaveConversion<AddressConverter>();
}
}
public class Product
{
public int Id { get; set; }
public decimal Price { get; set; }
}
public class Person
{
public int Id { get; set; }
public string FirstName { get; set; }
public string LastName { get; set; }
public DateTime BirthDate { get; set; }
public Address Address { get; set; }
}
public class Address
{
public string Country { get; set; }
public string Street { get; set; }
public string ZipCode { get; set; }
}
public class AddressConverter : ValueConverter<Address, string>
{
public AddressConverter()
: base(
v => JsonSerializer.Serialize(v, (JsonSerializerOptions)null),
v => JsonSerializer.Deserialize<Address>(v, (JsonSerializerOptions)null))
{
}
}10 compiled model
In EF Core 6.0, you can generate compiled models. When you have a large model and your EF Core starts slowly, this function makes sense. You can do this using the CLI or the package manager console.
public class ExampleContext : DbContext
{
public DbSet<Person> People { get; set; }
protected override void OnConfiguring(DbContextOptionsBuilder options)
{
options.UseModel(CompiledModelsExample.ExampleContextModel.Instance)
options.UseSqlServer("Server=(localdb)\\mssqllocaldb;Database=SparseColumns;Trusted_Connection=True;");
}
}
public class Person
{
public int Id { get; set; }
public string FirstName { get; set; }
public string LastName { get; set; }
}CLI:
dotnet ef dbcontext optimize -c ExampleContext -o CompliledModels -n CompiledModelsExample
Package Manager Console:
Optimize-DbContext -Context ExampleContext -OutputDir CompiledModels -Namespace CompiledModelsExample
More about compiled models and their limitations:
https://devblogs.microsoft.com/dotnet/announcing-entity-framework-core-6-0-preview-5-compiled-models/ https://docs.microsoft.com/en-us/ef/core/what-is-new/ef-core-6.0/whatsnew#limitations
11 end
You can find all the sample code for this article in my GitHub:
https://github.com/okyrylchuk/dotnet6_features/tree/main/EF%20Core%206#miscellaneous-enhancements