Entity Framework  

Entity Framework Core 10 – What’s New

Introduction

Entity Framework Core 10 (EF Core 10) is released alongside .NET 10 and is an LTS version. It focuses on modern database capabilities, including vector search, JSON improvements, improved LINQ translation, bulk updates, and enterprise-grade features for SQL Server, Azure SQL, and Cosmos DB.

EF Core 10 requires .NET 10 and does not support older runtimes.

Platform and Runtime Requirements

EF Core 10 runs only on .NET 10
It is an LTS release suitable for long-term enterprise projects
Older EF Core versions should be upgraded carefully due to breaking changes

SQL Server and Azure SQL Enhancements

Vector Search Support

EF Core 10 introduces first-class support for the SQL Server vector data type and distance functions. This enables AI-driven similarity search scenarios directly from LINQ.

var query = await context.Documents
    .OrderBy(d => EF.Functions.VectorDistance(
        "cosine",
        d.Embedding,
        inputVector))
    .Take(5)
    .ToListAsync();

Use cases include semantic search, recommendations, and embeddings-based ranking.

Native JSON Column Support

JSON is now treated as a first-class data type in SQL Server (Azure SQL / SQL Server 2025).

EF Core 10 can:

  • Map JSON columns automatically

  • Query inside JSON using LINQ

  • Update JSON fields using bulk operations

public class Blog
{
    public int Id { get; set; }
    public BlogMetadata Metadata { get; set; }
}

modelBuilder.Entity<Blog>()
    .ComplexProperty(b => b.Metadata, c => c.ToJson());

Named Default Constraints

You can now control default constraint naming to improve schema readability and DevOps consistency.

modelBuilder.Entity<Post>()
    .Property(p => p.CreatedAt)
    .HasDefaultValueSql("GETDATE()", "DF_Post_CreatedAt");

Or enable naming globally:

modelBuilder.UseNamedDefaultConstraints();

Cosmos DB Provider Improvements

Full-Text Search

EF Core 10 supports Cosmos DB full-text search using LINQ-friendly APIs.

modelBuilder.Entity<Article>()
    .Property(a => a.Content)
    .EnableFullTextSearch();

This allows efficient search without manual query strings.

Vector Search Stabilization

Vector search in Cosmos DB is no longer experimental.

New improvements include:

  • Owned entity support

  • Better indexing configuration

  • Stable APIs for production use

Safer Model Evolution

When new required properties are added, existing Cosmos documents are now materialized using default values instead of throwing runtime exceptions.

This makes schema evolution safer in NoSQL systems.

Complex Types Improvements

Complex types represent value objects without identity.

Table Mapping

modelBuilder.Entity<Customer>()
    .ComplexProperty(c => c.Address);

All address fields are stored in the same table as the parent entity.

JSON Mapping for Complex Types

modelBuilder.Entity<Customer>()
    .ComplexProperty(c => c.Address, c => c.ToJson());

Structs are also supported as complex types in EF Core 10.

LINQ and Query Translation Improvements

LeftJoin and RightJoin Operators

EF Core 10 adds direct support for outer joins without workarounds.

var result = context.Orders
    .LeftJoin(
        context.Customers,
        o => o.CustomerId,
        c => c.Id,
        (o, c) => new
        {
            OrderId = o.Id,
            CustomerName = c.Name
        });

This maps directly to SQL LEFT JOIN.

Improved Collection Parameter Translation

Large IN queries now generate more efficient SQL with better query plan reuse.

You can also configure translation strategy globally or per query.

Bulk Updates and ExecuteUpdate Enhancements

JSON Column Updates

EF Core 10 allows bulk updates inside JSON documents.

await context.Blogs.ExecuteUpdateAsync(setters =>
    setters.SetProperty(
        b => b.Metadata.ViewCount,
        b => b.Metadata.ViewCount + 1));

Non-Expression Lambda Support

You can now write conditional update logic more naturally.

await context.Users.ExecuteUpdateAsync(s =>
{
    s.SetProperty(u => u.IsActive, true);
    if (updateRole)
        s.SetProperty(u => u.Role, "Admin");
});

Named Global Query Filters

Multiple named filters can be applied to the same entity.

modelBuilder.Entity<Order>()
    .HasQueryFilter("SoftDelete", o => !o.IsDeleted)
    .HasQueryFilter("Tenant", o => o.TenantId == tenantId);

Disable selectively at query time:

context.Orders
    .IgnoreQueryFilters(new[] { "SoftDelete" })
    .ToListAsync();

Security and Logging Improvements

SQL Parameter Redaction

EF Core 10 redacts inline SQL parameter values in logs by default.

This prevents sensitive data leakage in logs while keeping SQL readable.

Migration and Tooling Changes

  • Migrations no longer run inside a single global transaction

  • Improved SQL Server scaffolding

  • Better performance in async context handling

Breaking Changes

Requires .NET 10
Some ExecuteUpdate APIs have signature changes
Behavioral changes in migrations and logging may affect existing pipelines

Conclusion

EF Core 10 is a strong step forward for:

  • AI-driven database workloads

  • JSON-heavy schemas

  • High-performance bulk operations

  • Enterprise-grade query control

It is best suited for new projects or planned upgrades targeting .NET 10 LTS.

Membership not found