Tolitech.Infrastructure.Persistence.EntityFrameworkCore 1.0.0-preview.9

Tolitech.Infrastructure.Persistence.EntityFrameworkCore

A robust .NET library that provides foundational infrastructure for implementing the Repository and Unit of Work patterns with Entity Framework Core. It enables transactional consistency, domain event publishing, and integration event outbox support for modern, scalable applications.

Features

• Generic Repository Base: Abstract base for repositories, simplifying CRUD operations.
• Unit of Work Pattern: Transaction management with support for nested transactions.
• Domain Events: Automatic collection and publishing of domain events after persistence.
• Integration Events (Outbox Pattern): Reliable persistence of integration events for eventual consistency.
• Exception Handling: Centralized constraint violation handling.
• Logging: Transaction and event lifecycle logging.

Installation

Add the NuGet package to your project:

dotnet add package Tolitech.Infrastructure.Persistence.EntityFrameworkCore

Getting Started

1. Implement a Repository

Create a repository by inheriting from Repository<TEntity>:

using Tolitech.Infrastructure.Persistence.EntityFrameworkCore;

public class CustomerRepository : Repository<Customer>
{
    public CustomerRepository(MyDbContext dbContext) : base(dbContext) { }
}

2. Implement a Unit of Work

Create a Unit of Work by inheriting from UnitOfWorkBase:

using Tolitech.Infrastructure.Persistence.EntityFrameworkCore;
using MediatR;
using Microsoft.Extensions.Logging;

public class MyUnitOfWork : UnitOfWorkBase
{
    public MyUnitOfWork(MyDbContext dbContext, IPublisher publisher, ILogger<MyUnitOfWork> logger)
        : base(dbContext, publisher, logger) { }
}

3. Using Transactions and Saving Changes

using (var uow = new MyUnitOfWork(dbContext, publisher, logger))
{
    await uow.BeginTransactionAsync(cancellationToken);
    // ... perform repository operations ...
    await uow.SaveChangesAsync(cancellationToken);
    await uow.CommitAsync(cancellationToken);
}

Or atomically:

await uow.SaveChangesInTransactionAsync(cancellationToken);

4. Domain Events

Entities implementing IAggregate can raise domain events. These are automatically published after SaveChangesAsync if a transaction is open.

5. Integration Events (Outbox)

If using the outbox pattern, pass an IOutbox to the Unit of Work. Integration events are persisted and can be processed later for reliable messaging.

Exception Handling

Constraint violations are handled and wrapped using the ConstraintValidatorManager for consistent error management.

Example: Custom Exception

try
{
    await uow.SaveChangesAsync(cancellationToken);
}
catch (MissingOpenTransactionException ex)
{
    // Handle missing transaction scenario
}

Advanced

• Isolation Levels: Use BeginTransactionAsync(IsolationLevel, CancellationToken) for custom isolation.
• Commit or Rollback by Result: Use CommitOrRollbackAsync(Result, CancellationToken) to commit or rollback based on operation result.

Tolitech.Infrastructure.Persistence.EntityFrameworkCore brings transactional consistency, event-driven architecture, and repository abstraction to your .NET applications with Entity Framework Core.