NPv.DataAccess.Ef 2.3.0

NPv.DataAccess.Ef

Pluggable EF Core infrastructure for a generic repository and a single explicit unit of work.
Read-side queries are expected to go through Dapper, completely bypassing this library.

📌 Breaking changes

v2.1.0

Breaking change planned for v2.1.0: CancellationToken is now required in repository async methods.
Pass the boundary token from controllers/workers so EF Core receives cancellation signals.
If no token is available, pass CancellationToken.None explicitly at the call site.

v2.0.0

• Target framework updated to net10.0 (dropped net9.0 support).

This is a personal library that focuses on the latest .NET runtime to keep maintenance simple and enjoyable.

📦 Version 1.3.x — Explicit Commit & Safe UoW

Overview

This library provides:

• A reusable EfCoreGenericRepository for standard CRUD operations (write path only)
• A scoped IDbContextProvider with explicit commit semantics
  • No auto-commit on dispose
  • No transaction management exposed to callers
  • One unit of work = one SaveChangesAsync() wrapped in a transaction
• Enhanced mapping conventions for entities and string fields
• Value generation using GuidV7ValueGenerator for sequential GUIDs
• [LongText] attribute and default nvarchar(256) string mappings

Designed as a drop-in infrastructure layer for services, APIs, and background workers that rely on EF Core.

🚀 Getting Started

1. Add a reference to the package.
2. Register your DbContext, IDbContextProvider, and repository in your DI container.
3. Use the repository inside command handlers.
4. Call CommitAsync() once per unit of work.

✅ Example Setup

Define your application DbContext:

public class ApplicationContext(DbContextOptions<ApplicationContext> options) : DbContext(options)
{
    protected override void OnModelCreating(ModelBuilder builder)
    {
        base.OnModelCreating(builder);

        foreach (var entityType in builder.Model.GetEntityTypes()
                     .Where(t => t.ClrType.IsSubclassOf(typeof(Entity))))
        {
            var entity = builder.Entity(entityType.ClrType);
            entity.Property("Id")
                  .ValueGeneratedOnAdd()
                  .HasValueGenerator<GuidV7ValueGenerator>();
        }

        // Applies default mapping for strings to nvarchar(256)
        DefaultString256MaxLengthMapping.ApplyMapping(builder);
    }
}

🛠 Usage Notes

• All string columns default to nvarchar(256) unless [MaxLength] or [LongText] is applied.
• Entity Id uses a sequential GuidV7 for better index locality.
• DbContextProvider only commits via CommitAsync(); never on dispose.
• For commands (writes), wrap execution in a unit of work and call CommitAsync() only once at the end.
• For queries (reads), use Dapper directly — EF Core is bypassed.

Example Command Handler

public sealed class CreateOrderHandler(IGenericRepository repo)
{
    public async Task ExecuteAsync(CreateOrder cmd, CancellationToken ct)
    {
        var order = new Order { /* ... */ };
        await repo.AddAsync(order, ct);
        // No SaveChanges here!
    }
}

// Somewhere in your pipeline:
await using var uow = scope.Resolve<IDbContextProvider>();
await handler.ExecuteAsync(command, ct);
await uow.CommitAsync(ct); // wraps SaveChanges in a transaction

⏹️ CancellationToken

All async repository methods now require a CancellationToken ct (no default) and propagate it to EF Core operations. Pass the request token from the application layer so cancellation is honored end-to-end. If no token is available, pass CancellationToken.None explicitly at the call site.

Cancellation is not suppressed: OperationCanceledException is allowed to propagate.

Author's Note

This library grew out of my long-standing personal interest in structuring and publishing open source packages. Over time, I’ve revisited and refined earlier internal utilities and ideas, giving them a more consistent shape and preparing them for wider reuse. Along the way, I’ve also taken the opportunity to explore how open source distribution and licensing work in the .NET ecosystem.

It’s a small step toward something I’ve always wanted to try — sharing practical, minimal tools that reflect years of learning, experimentation, and refinement.

Hopefully, someone finds it useful.

Nikolai 😛

⚖️ License

MIT — you are free to use this in commercial and open-source software.