90% of all developers who use EF Core use only official NuGet packages.

Today I want to show you 5 EF Core packages that provide features that save time, reduce boilerplate, and improve performance.

They are hidden gems that can level up your projects if you know about them.

In this post, we will explore how to:

• Handle database exceptions in a clean way
• Automatically align your schema with naming conventions
• Speed up bulk operations with massive performance gains
• Execute dynamic queries at runtime
• Track entity changes with Auditing

Let's dive in!

EF Core throws general DbUpdateException and DbUpdateConcurrencyException. They are hard to act on. You need to look into inner exceptions to determine what happened.

EntityFramework.Exceptions turns low-level database errors into clear, typed exceptions like UniqueConstraintException. This makes bugs easier to see and handle in code, logs, and APIs.

List of available exceptions:

• UniqueConstraintException - for unique constraint violations
• CannotInsertNullException - for null values in insert statements
• MaxLengthExceededException - for string length violations
• NumericOverflowException - for numeric overflows
• ReferenceConstraintException - for reference constraint violations

To get started, install the package from NuGet based on the Database provider you use:

bash
1dotnet add package EntityFrameworkCore.Exceptions.SqlServer
2dotnet add package EntityFrameworkCore.Exceptions.MySql
3dotnet add package EntityFrameworkCore.Exceptions.MySql.Pomelo
4dotnet add package EntityFrameworkCore.Exceptions.PostgreSQL
5dotnet add package EntityFrameworkCore.Exceptions.Sqlite
6dotnet add package EntityFrameworkCore.Exceptions.Oracle

You can configure and add typed exceptions with the UseExceptionProcessor method in the OnConfiguring method of your DbContext.

csharp
1public class UserDbContext : DbContext
2{
3    public DbSet<User> Users { get; set; }
4
5    protected override void OnModelCreating(ModelBuilder builder)
6    {
7        builder.Entity<User>().HasIndex(user => user.EmailAddress).IsUnique();
8    }
9
10    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
11    {
12        optionsBuilder.UseExceptionProcessor();
13    }
14}

You can also use it in the AddDbContext method:

csharp
1builder.Services.AddDbContext<UserDbContext>(options =>
2{
3    options
4        .UseNpgsql(builder.Configuration.GetConnectionString("Postgres"))
5        .UseExceptionProcessor();
6});

DbContextFactory and Pooled DbContext are also supported.

Let's explore an example of how to handle a typed EF Core exception.

When a user registers with an email that already exists, return 409 Conflict with a clear message:

csharp
1// UniqueConstraintException
2using EntityFramework.Exceptions.Common;
3
4app.MapPost("/api/users", async (CreateUserRequest request, UserDbContext db) =>
5{
6    var user = new User { EmailAddress = request.Email, Name = request.Name };
7    db.Users.Add(user);
8
9    try
10    {
11        await db.SaveChangesAsync();
12        
13        return Results.Created($"/api/users/{user.Id}",
14            new { user.Id, user.EmailAddress, user.Name });
15    }
16    catch (UniqueConstraintException)
17    {
18        // e.ConstraintName - contains the name of the violated associated constraint
19        // e.ConstraintProperties - contains the properties that are part of the constraint.
20        
21        return Results.Conflict(new ProblemDetails
22        {
23            Title = "Email already exists",
24            Detail = "Please use a different email address.",
25            Status = StatusCodes.Status409Conflict
26        });
27    }
28});

You can use e.ConstraintName and e.ConstraintProperties to log a more detailed error message.

Note: ConstraintName and ConstraintProperties will not be populated when using SQLite.

Recap:
EntityFramework.Exceptions gives you clear, actionable exceptions for common database errors. It reduces boilerplate, improves API responses, and makes failures easy to understand for both developers and clients.

When creating mapping in EF Core, developers usually divide into two groups:

• Who specifies column names and table names in the correct database casing
• Who doesn't care about database casing, and EF Core generates these names automatically

By default, EF Core maps to tables and columns named exactly as your .NET classes and properties.

For example, mapping a typical User class to PostgreSQL will result in SQL such as the following:

sql
1CREATE TABLE "Users" (
2    "Id" integer NOT NULL GENERATED BY DEFAULT AS IDENTITY,
3    "EmailAddress" text NULL,
4    CONSTRAINT "PK_Users" PRIMARY KEY ("Id")
5);
6
7SELECT "Id", "EmailAddress"
8    FROM "Users" AS
9    WHERE "EmailAddress" = '[email protected]';

But is this really an issue?

Yes, it is!

This is a problem with PostgreSQL that uses lower snake_case for table and column names. The database needs double-quotes around names. Without quotes, PostgreSQL changes all names to lowercase. All those quotes make the code look messy and hard to read.

Another example: if you're using an Oracle database, it uses all uppercase letters in the UPPER_SNAKE_CASE casing.

Hand-writing table and column names is really tiresome.

You add HasColumnName() here and there, and can still miss a few:

csharp
1builder.ToTable("users");
2
3builder.Property(x => x.EmailAddress)
4    .HasColumnName("email_address")
5    .IsRequired();

The wrong column name can easily sneak into a database migration. You need to delete the migration, regenerate it, or even rollback it in the database to fix the column name.

EntityFramework.NamingConventions package comes to the rescue.

This package applies a global naming convention to all tables, columns, keys, and indexes that EF Core creates.

You can switch to snake_case, lowercase, UPPER_SNAKE_CASE, UPPERCASE, or keep PascalCase — without manually specifying it for each entity.

To get started, install the package from NuGet:

bash
1dotnet add package EFCore.NamingConventions

Enable a convention when registering your DbContext:

csharp
1using Microsoft.EntityFrameworkCore;
2
3builder.Services.AddDbContext<AppDbContext>(options =>
4{
5    options
6        .UseNpgsql(builder.Configuration.GetConnectionString("Postgres"))
7        .UseSnakeCaseNamingConvention(); // or .UseUpperCaseNamingConvention()
8                                         // or .UseUpperSnakeCaseNamingConvention()
9                                         // or .UseCamelCaseNamingConvention()
10                                         // or .UseLowerCaseNamingConvention()
11});

This will automatically make all your table and column names have lower snake_case naming:

csharp
1public class User
2{
3    public int Id { get; set; }
4    public DateTime CreatedAt { get; set; }
5    public string EmailAddress { get; set; } = default!;
6    public ICollection<UserLogin> Logins { get; set; } = new List<UserLogin>();
7}
8
9public class UserLogin
10{
11    public int Id { get; set; }
12    public int UserAccountId { get; set; }
13    public DateTime SignedInAt { get; set; }
14    public UserAccount User { get; set; } = default!;
15}

With .UseSnakeCaseNamingConvention(), EF Core will create names like:

• Tables: user_account, user_login
• Columns: created_at, email_address, user_account_id, signed_in_at
• Indexes/keys: e.g., IX_user_login_user_account_id

sql
1CREATE TABLE users (
2    id integer NOT NULL GENERATED BY DEFAULT AS IDENTITY,
3    email_address text NULL,
4    CONSTRAINT "pk_users" PRIMARY KEY ("Id")
5);
6
7SELECT id, email_address
8FROM users AS
9WHERE email_address = '[email protected]';

Supported naming conventions:

• UseSnakeCaseNamingConvention: FullName becomes full_name
• UseLowerCaseNamingConvention: FullName becomes fullname
• UseCamelCaseNamingConvention: FullName becomes fullName
• UseUpperCaseNamingConvention: FullName becomes FULLNAME
• UseUpperSnakeCaseNamingConvention: FullName becomes FULL_NAME

Recap:
EntityFramework.NamingConventions gives you a simple way to apply a naming convention to all tables, columns, keys, and indexes that EF Core creates. Without manually specifying it for each entity.

When working with large datasets in Entity Framework Core, developers often hit performance bottlenecks using SaveChanges().

Each entity insertion triggers a separate database round-trip and increases memory usage because of entity tracking overhead. This becomes even more noticeable as the number of rows grows into the thousands or millions.

What can we do to improve insert performance?

• Using Dapper? No, as it also sends each insert as a separate round-trip to the database.
• Maybe using SqlBulkCopy? That's not ideal because you need a lot of custom code, especially if you want to insert child entities or return identity values.

And it only works with SQL Server, so it's not suitable if you need to support other providers.

There is a better solution: Entity Framework Extensions library.

This library offers simpler, more elegant and configurable options for bulk inserts.

To get started with Entity Framework Extensions, install the following NuGet package:

bash
1dotnet add package Z.EntityFramework.Extensions.EFCore

Entity Framework Extensions allows you to bulk insert thousands of entities with a single line of code:

csharp
1using Z.EntityFramework.Extensions;
2
3var products = GenerateProducts(10_000);
4await dbContext.BulkInsertAsync(products);

Both BulkInsert and BulkInsertAsync methods are available.

Let's compare the performance of bulk insert methods with SaveChanges:

• Insert: 14x faster, reducing time by 93% Online Benchmark
• Update: 4x faster, reducing time by 75% Online Benchmark
• Delete: 3x faster, reducing time by 65% Online Benchmark

I have tested the following database queries via Web API:

csharp
1using Z.EntityFramework.Extensions;
2
3app.MapPost("/products/efcore-insert", async (ProductDbContext dbContext) =>
4{
5    var products = GenerateProducts(10_000);
6    dbContext.Products.AddRange(products);
7
8    await dbContext.SaveChangesAsync();
9
10    return Results.Ok("10,000 products inserted using EF Core SaveChanges.");
11});
12
13app.MapPost("/products/efcore-bulk-insert", async (ProductDbContext dbContext) =>
14{
15    var products = GenerateProducts(10_000);
16    await dbContext.BulkInsertAsync(products);
17
18    return Results.Ok("10,000 products inserted using Bulk Insert of EF Core Extensions.");
19});
20
21app.MapPost("/products/efcore-bulk-insert-optimized", async (ProductDbContext dbContext) =>
22{
23    var products = GenerateProducts(10_000);
24    var result = await dbContext.BulkInsertOptimizedAsync(products);
25
26    return Results.Ok(result);
27});

I have tested these queries on a Postgres database, and here are the results for inserting 10_000 products via Web API requests:

• SaveChanges - 2,011 ms
• BulkInsert - 560 ms
• BulkInsertOptimized - 270 ms

Note: benchmarks can vary depending on your hardware and database provider.

Entity Framework Extensions support the following bulk write methods:

• BulkInsert, BulkInsertAsync
• BulkInsertOptimized, BulkInsertOptimizedAsync
• BulkUpdate, BulkUpdateAsync
• BulkDelete, BulkDeleteAsync
• BulkMerge, BulkMergeAsync
• BulkSynchronize, BulkSynchronizeAsync

Entity Framework Extensions support the following database providers:

• SQL Server
• MySQL
• MariaDB
• Oracle
• PostgreSQL
• SQLite

Learn more about Entity Framework Extensions here.

Sometimes you can't write LINQ at compile time. You need to build filters, sorts, and projections at runtime based on user input (such as grids, search pages, and reporting).

Microsoft.EntityFrameworkCore.DynamicLinq adds string-based LINQ to EF Core so you can call Where, OrderBy, Select, and more with expressions like Price > 100 && Category == @0.

To get started, install the package from NuGet:

bash
1dotnet add package Microsoft.EntityFrameworkCore.DynamicLinq

When querying data using Dynamic LINQ, everything can be expressed using strings. This includes predicates, selectors, and sorting.

Strongly typed LINQ looks like:

csharp
1var result = context.Users
2    .Where(c => c.EmailAddress == "[email protected]")
3    .ToList();

Dynamic LINQ looks like:

csharp
1var resultDynamic = context.Users
2    .Where("EmailAddress == \"[email protected]\"")
3    .ToList();

It's not required to specify the value as a hard-coded value; you can use a parameter:

csharp
1var email = "[email protected]";
2
3var resultDynamic = context.Users
4    .Where("EmailAddress == @0", email)
5    .ToList();

Here is a more complex query. You can get data from a user in the Web API request:

csharp
1using Microsoft.EntityFrameworkCore;
2using Microsoft.EntityFrameworkCore.DynamicLinq;
3
4// Runtime values from UI / query string
5string filter = "Price >= @0 && Category == @1";
6object[] args = { 100m, "Books" };
7string orderBy = "Price desc, Title";
8string selector = "new (Id, Title, Price)";
9
10var query = db.Products
11    .Where(filter, args)          // dynamic predicate
12    .OrderBy(orderBy)             // dynamic sort
13    .Select(selector);            // dynamic projection
14
15var items = await query.ToListAsync(); // async with EF Core

Explore more examples here.

Learn more about this Dynamic LINQ for EF Core here.

Knowing who changed what and when is tiresome to do by hand. Writing change logs, including old/new values and user information, takes time and is easy to miss.

Audit.EntityFramework.Core plugs into EF Core and records entity changes automatically (inserts, updates, deletes). You receive a complete audit trail that can be stored or shipped anywhere.

To get started, install the package from NuGet:

bash
1dotnet add package Audit.EntityFramework.Core

To audit Insert, Delete and Update operations, you can use any of the three SaveChanges interception mechanisms provided:

1. Inherit from AuditDbContext:

csharp
1// Inherit from Audit.EntityFramework.AuditDbContext
2public class UserDbContext : AuditDbContext
3{
4    public DbSet<User> Users { get; set; }
5
6    protected override void OnModelCreating(ModelBuilder builder)
7    {
8        builder.Entity<User>().HasIndex(user => user.EmailAddress).IsUnique();
9    }
10}

Note: If you're using IdentityDbContext instead of DbContext, you can install the package Audit.EntityFramework.Identity.Core and inherit from the class AuditIdentityDbContext instead of AuditDbContext.

2. Override SaveChanges:

You can use the library without changing the inheritance of your DbContext. You can override SaveChanges and SaveChangesAsync:

csharp
1public class UserDbContext : DbContext
2{
3    private readonly DbContextHelper _helper = new DbContextHelper();
4    private readonly IAuditDbContext _auditContext;
5
6    public UserDbContext(DbContextOptions<UserDbContext> options) : base(options)
7    {
8        _auditContext = new DefaultAuditContext(this);
9        _helper.SetConfig(_auditContext);
10    }
11
12    public override int SaveChanges(bool acceptAllChangesOnSuccess)
13    {
14        return _helper.SaveChanges(_auditContext, () => base.SaveChanges(acceptAllChangesOnSuccess));
15    }
16
17    public override async Task<int> SaveChangesAsync(bool acceptAllChangesOnSuccess,
18        CancellationToken cancellationToken = default(CancellationToken))
19    {
20        return await _helper.SaveChangesAsync(_auditContext,
21            () => base.SaveChangesAsync(acceptAllChangesOnSuccess, cancellationToken), cancellationToken);
22    }
23}

3. Create save changes interceptor:

Alternatively, you can create a save changes interceptor and register it with EF Core:

csharp
1public class UserDbContext : DbContext
2{
3    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
4    {
5        optionsBuilder.AddInterceptors(new AuditSaveChangesInterceptor());
6    }
7}

Or you can add the AuditSaveChangesInterceptor when registering your DbContext:

csharp
1builder.Services.AddDbContext<UserDbContext>(options =>
2{
3    options
4        .UseNpgsql(builder.Configuration.GetConnectionString("Postgres"))
5        .AddInterceptors(new AuditSaveChangesInterceptor())
6});

To store audit events, you need to configure a Data Provider within EF Core:

csharp
1Audit.Core.Configuration.Setup()
2    .UseEntityFramework(ef => ef
3        .UseDbContext<OrderDbContext>()
4        .AuditTypeExplicitMapper(m => m
5            .Map<Order, OrderAudit>()
6            .Map<Orderline, OrderlineAudit>()
7            .AuditEntityAction<IAudit>((evt, entry, auditEntity) =>
8            {
9                auditEntity.AuditDate = DateTime.UtcNow;
10                auditEntity.UserName = evt.Environment.UserName;
11                auditEntity.AuditAction = entry.Action; // Insert, Update, Delete
12            })
13        )
14    );

It's recommended to use a separate DbContext for Auditing.

As a result, you will get the following database schema in the database:

Learn more about this Auditing package in the documentation here.

Thanks to ZZZ Projects for sponsoring this blog post.

Hope you find this newsletter useful. See you next time.