Entity Framework Core: Advanced Topics

This section delves into more complex scenarios and techniques for leveraging Entity Framework Core (EF Core) in your .NET applications. Understanding these advanced concepts can significantly improve performance, maintainability, and robustness.

Advanced Change Tracking

EF Core provides sophisticated change tracking capabilities. Understanding how EF Core tracks changes to entities is crucial for efficient data manipulation.

Entity States

Each entity in EF Core can be in one of several states:

• Detached: The entity is not being tracked by the context.
• Unchanged: The entity has been retrieved from the database and its state has not changed.
• Added: The entity is new and will be inserted into the database.
• Deleted: The entity has been marked for deletion from the database.
• Modified: The entity has been retrieved from the database, and some of its properties have been changed.

Manual State Management

You can manually set the state of an entity using the Entry method:

using (var context = new MyDbContext())
{
    var blog = new Blog { Id = 1, Name = "New Name" };
    context.Entry(blog).State = EntityState.Modified; // Or EntityState.Added, EntityState.Deleted, etc.
    context.SaveChanges();
}
            

Advanced Querying

Beyond basic LINQ queries, EF Core offers powerful ways to fetch and manipulate data efficiently.

Projection

Selecting only the data you need can dramatically improve performance. This is achieved by projecting entities into anonymous types or DTOs (Data Transfer Objects).

var blogNames = context.Blogs
    .Select(b => new { b.Id, b.Name })
    .ToList();
            

AsNoTracking()

When you don't need to modify entities returned from a query, using AsNoTracking() bypasses change tracking, resulting in faster query execution and reduced memory overhead.

var allBlogs = context.Blogs.AsNoTracking().ToList();
            

Executing Raw SQL Queries

For scenarios where LINQ is not sufficient or for performance tuning, you can execute raw SQL queries.

var blogsFromSql = context.Blogs.FromSqlRaw("SELECT * FROM Blogs WHERE Url LIKE {0}", "%dotnet.microsoft.com%");
            

Performance Optimization

Optimizing EF Core performance is key to building scalable applications.

Batching Operations

EF Core 7 and later versions offer improved batching capabilities for inserts, updates, and deletes, reducing the number of round trips to the database.

Efficient Loading Strategies

Choose the appropriate loading strategy:

• Eager Loading: Use Include() and ThenInclude() to load related data in a single query.
• Explicit Loading: Load related data on demand using context.Entry(entity).Collection(e => e.Navigation).Load().
• Lazy Loading: Requires configuration and virtual navigation properties.

// Eager Loading
var blogsWithPosts = context.Blogs
    .Include(b => b.Posts)
    .ToList();

// Explicit Loading
var blog = context.Blogs.Find(1);
if (blog != null)
{
    context.Entry(blog).Collection(b => b.Posts).Load();
}
            

Migrations Deep Dive

EF Core Migrations allow you to evolve your database schema over time. Understanding advanced migration features can help manage complex schema changes.

Customizing Migrations

You can execute custom SQL or perform complex operations within a migration by inheriting from Migration and overriding Up and Down methods.

// Example of a custom migration step
public override void Up()
{
    migrationBuilder.Sql("INSERT INTO SomeTable (Column) VALUES ('Value')");
}
            

Conditional Migrations

Use --script option to generate SQL scripts and manually review or modify them before applying them to production environments.

Transactions

EF Core allows you to manage database transactions to ensure data consistency.

Explicit Transactions

You can explicitly start and commit transactions:

using (var transaction = context.Database.BeginTransaction())
{
    try
    {
        // Perform multiple operations
        context.Blogs.Add(new Blog { Name = "New Blog" });
        context.SaveChanges();

        var post = context.Posts.Find(1);
        if (post != null) post.Title = "Updated Title";
        context.SaveChanges();

        transaction.Commit();
    }
    catch
    {
        transaction.Rollback();
        throw;
    }
}
            

Automatic Transactions

By default, SaveChanges() within a single DbContext instance runs within a single transaction. However, if you call SaveChanges() multiple times on the same context for different operations, each call is treated as a separate transaction.

Concurrency Control

Concurrency issues arise when multiple users or processes try to modify the same data simultaneously. EF Core offers various strategies to handle this.

Optimistic Concurrency

This is the most common approach. You add a concurrency token (e.g., a version number or timestamp) to your entity.

public class Blog
{
    public int Id { get; set; }
    public string Name { get; set; }
    public byte[] RowVersion { get; set; } // Concurrency token
}
            

When SaveChanges() is called, EF Core checks if the concurrency token in the database matches the token in the entity being saved. If they don't match, an DbUpdateConcurrencyException is thrown.

Handling Concurrency Conflicts

You can catch the DbUpdateConcurrencyException and implement strategies like:

• Refreshing the entity from the database and retrying the operation.
• Merging changes.
• Discarding the changes.

Spatial Data

EF Core supports spatial data types (e.g., Point, Polygon) for applications dealing with geographical information.

Using Spatial Types

Define properties using EF Core's spatial types and ensure your database provider supports them (e.g., SQL Server, PostgreSQL).

using NetTopologySuite.Geometries;

public class Location
{
    public int Id { get; set; }
    public string Name { get; set; }
    public Point Coordinates { get; set; }
}
            

You'll typically need to install a NuGet package like Microsoft.EntityFrameworkCore.SqlServer.NetTopologySuite for SQL Server or similar for other providers.