Entity Framework Core features in 2023
EF Core 2023 has rolled out some pretty cool stuff, and I’m excited to share it with you. So, grab a cup of coffee, and let’s get started!
1. Cosmos DB Provider Improvements
Azure Cosmos DB and EF Core are like two peas in a pod, but with EF Core 8.0, they’re even cozier. Enhanced support means tighter integration and smoother operations.
Code Example:
var cosmosOptionsBuilder = new DbContextOptionsBuilder<MyContext>()
.UseCosmos("https://mycosmosaccount.documents.azure.com:443/", "myPrimaryKey", "myDatabaseName");
This is a significant leap for cloud developers. The tighter integration reduces boilerplate code, making our cloud-based apps more efficient and maintainable.
2. Temporal Tables
Time-travel isn’t just for sci-fi movies. With SQL Server temporal tables support, EF Core 8.0 lets us revisit our data’s past states.
Code Example:
modelBuilder.Entity<Order>().ToTable("Orders", t => t.IsTemporal());
This feature is a lifesaver for debugging and auditing. Being able to track data changes directly from EF Core simplifies many tasks that previously required complex solutions.
3. Table-per-Type (TPT) Mapping
Data modeling debates have a new contender. TPT mapping in EF Core 8.0 offers a fresh approach to organizing our data, especially when inheritance is in play.
Code Example:
modelBuilder.Entity<Contractor>().ToTable("Contractors");
modelBuilder.Entity<Employee>().ToTable("Employees");
For projects where data separation is crucial, TPT is a breath of fresh air. It provides clarity in the database schema, making it easier to manage and understand.
4. Migrations Bundles
Deployment headaches, be gone! Migrations Bundles in EF Core 8.0 encapsulate all migration-related elements, streamlining the deployment process.
Code Example:
var bundle = context.Database.CreateMigrationBundle();
File.WriteAllBytes("MigrationsBundle.zip", bundle);
This is a game-changer for CI/CD pipelines. Simplifying migrations means fewer deployment issues and faster release cycles.
5. Compiled Models
Speed is the name of the game. With Compiled Models, EF Core 8.0 boosts startup performance, especially for models with a large number of entities.
Code Example:
var options = new DbContextOptionsBuilder<MyContext>()
.UseModel(CompiledModel.Default)
.Options;
In today’s fast-paced world, every millisecond counts. Improving startup times enhances user experience, especially in microservices architectures.
6. HierarchyID Mapping
Organizing data in a hierarchical manner has always been a challenge. With the introduction of hierarchyid type support in EF Core 8.0, representing data like organizational charts or file systems becomes more intuitive.
Code Example:
modelBuilder.Entity<Organization>().Property(e => e.HierarchyId).HasConversion<string>();
This feature simplifies the representation of tree structures in our databases. It’s a step forward in making complex data structures more manageable and queryable.
7. Raw SQL Queries for Unmapped Types
Sometimes, ORM can feel restrictive, especially when we need to execute raw SQL. EF Core 8.0 expands its raw SQL capabilities, allowing us to return any mappable CLR type, even if it’s not part of our EF model.
Code Example:
var blogs = context.Set<Blog>().FromSqlRaw("SELECT * FROM dbo.Blogs").ToList();
This feature provides the flexibility many developers crave. It bridges the gap between raw SQL and ORM, offering the best of both worlds.
8. Updating Hierarchies
Hierarchical data structures are common, but updating them? That’s a different ball game. EF Core 8.0 introduces mechanisms to update hierarchyid columns seamlessly, making changes to hierarchical data structures a breeze.
Code Example:
var node = new HierarchyNode("/1/3/");
node = node.GetReparentedValue(oldRoot: new HierarchyNode("/1/"), newRoot: new HierarchyNode("/2/"));
This feature is a testament to EF Core’s commitment to simplifying complex operations. Being able to reparent a node or a sub-hierarchy without manual SQL scripting is a huge time-saver.
9. Configuration of and Complex Types
With flexibility at its core, EF Core 8.0 offers multiple ways to configure complex types. Whether you prefer mapping attributes or love diving deep into the OnModelCreating method, EF Core has got you covered.
Code Example:
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
modelBuilder.Entity<Customer>()
.ComplexProperty(e => e.Address);
}
The flexibility in configuration ensures that developers can mold the framework to their preferred coding style, making it adaptable to various project structures.
Complex Types for Value Objects
In the past, handling objects that held multiple values but lacked a unique identifier was a challenge. Now, objects like Address can be used across different entities without needing a separate table. This not only streamlines our database schema but also brings our models closer to the domain-driven design principles.
Code Example:
[ComplexType]
public class Address
{
public required string Line1 { get; set; }
public string? Line2 { get; set; }
public required string City { get; set; }
public required string Country { get; set; }
public required string PostCode { get; set; }
}
This feature simplifies the representation of value objects, making our code cleaner and more maintainable.
