If you’ve built a .NET app with a database, you’ve likely used Entity Framework, Dapper, or ADO.NET. They’re useful tools; still, when they live inside your business logic or controllers, the code can become harder to keep tidy and to test.

That’s where the Repository Pattern comes in.

At its core, the Repository Pattern acts as a middle layer between your domain and data access logic. It abstracts the way you store and retrieve data, giving your application a clean separation of concerns:

• Separation of Concerns: Business logic doesn’t depend on the database.
• Easier Testing: You can replace the repository with a fake or mock during unit tests.
• Flexibility: You can switch data sources (e.g., from SQL to MongoDB) without touching business logic.

Let’s see how this works with a simple example.

A Simple Example with Product Repository

Imagine we’re building a small e-commerce app. We’ll start by defining a repository interface for managing products.

You can find the complete sample code in this GitHub repository:

https://github.com/m-aliozkaya/RepositoryPattern

Domain model and context

We start with a single entity and a matching DbContext.

Product.cs

using System.ComponentModel.DataAnnotations;

namespace RepositoryPattern.Web.Models;

public class Product
{
    public int Id { get; set; }

    [Required, StringLength(64)]
    public string Name { get; set; } = string.Empty;

    [Range(0, double.MaxValue)]
    public decimal Price { get; set; }

    [StringLength(256)]
    public string? Description { get; set; }

    public int Stock { get; set; }
}

"AppDbContext.cs

using Microsoft.EntityFrameworkCore;
using RepositoryPattern.Web.Models;

namespace RepositoryPattern.Web.Data;

public class AppDbContext(DbContextOptions<AppDbContext> options) : DbContext(options)
{
    public DbSet<Product> Products => Set<Product>();
}

Generic repository contract and base class

All entities share the same CRUD needs, so we define a generic interface and an EF Core implementation.

Repositories/IRepository.cs

using System.Linq.Expressions;

namespace RepositoryPattern.Web.Repositories;

public interface IRepository<TEntity> where TEntity : class
{
    Task<TEntity?> GetByIdAsync(int id, CancellationToken cancellationToken = default);
    Task<List<TEntity>> GetAllAsync(CancellationToken cancellationToken = default);
    Task<List<TEntity>> GetListAsync(Expression<Func<TEntity, bool>> predicate, CancellationToken cancellationToken = default);
    Task AddAsync(TEntity entity, CancellationToken cancellationToken = default);
    Task UpdateAsync(TEntity entity, CancellationToken cancellationToken = default);
    Task DeleteAsync(int id, CancellationToken cancellationToken = default);
}

Repositories/EfRepository.cs

using Microsoft.EntityFrameworkCore;
using RepositoryPattern.Web.Data;

namespace RepositoryPattern.Web.Repositories;

public class EfRepository<TEntity>(AppDbContext context) : IRepository<TEntity>
    where TEntity : class
{
    protected readonly AppDbContext Context = context;

    public virtual async Task<TEntity?> GetByIdAsync(int id, CancellationToken cancellationToken = default)
        => await Context.Set<TEntity>().FindAsync([id], cancellationToken);

    public virtual async Task<List<TEntity>> GetAllAsync(CancellationToken cancellationToken = default)
        => await Context.Set<TEntity>().AsNoTracking().ToListAsync(cancellationToken);

    public virtual async Task<List<TEntity>> GetListAsync(
        System.Linq.Expressions.Expression<Func<TEntity, bool>> predicate,
        CancellationToken cancellationToken = default)
        => await Context.Set<TEntity>()
            .AsNoTracking()
            .Where(predicate)
            .ToListAsync(cancellationToken);

    public virtual async Task AddAsync(TEntity entity, CancellationToken cancellationToken = default)
    {
        await Context.Set<TEntity>().AddAsync(entity, cancellationToken);
        await Context.SaveChangesAsync(cancellationToken);
    }

    public virtual async Task UpdateAsync(TEntity entity, CancellationToken cancellationToken = default)
    {
        Context.Set<TEntity>().Update(entity);
        await Context.SaveChangesAsync(cancellationToken);
    }

    public virtual async Task DeleteAsync(int id, CancellationToken cancellationToken = default)
    {
        var entity = await GetByIdAsync(id, cancellationToken);
        if (entity is null)
        {
            return;
        }

        Context.Set<TEntity>().Remove(entity);
        await Context.SaveChangesAsync(cancellationToken);
    }
}

Reads use AsNoTracking() to avoid tracking overhead, while write methods call SaveChangesAsync to keep the sample straightforward.

Product-specific repository

Products need one extra query: list the items that are almost out of stock. We extend the generic repository with a dedicated interface and implementation.

Repositories/IProductRepository.cs

using RepositoryPattern.Web.Models;

namespace RepositoryPattern.Web.Repositories;

public interface IProductRepository : IRepository<Product>
{
    Task<List<Product>> GetLowStockProductsAsync(int threshold, CancellationToken cancellationToken = default);
}

Repositories/ProductRepository.cs

using Microsoft.EntityFrameworkCore;
using RepositoryPattern.Web.Data;
using RepositoryPattern.Web.Models;

namespace RepositoryPattern.Web.Repositories;

public class ProductRepository(AppDbContext context) : EfRepository<Product>(context), IProductRepository
{
    public Task<List<Product>> GetLowStockProductsAsync(int threshold, CancellationToken cancellationToken = default) =>
        Context.Products
            .AsNoTracking()
            .Where(product => product.Stock <= threshold)
            .OrderBy(product => product.Stock)
            .ToListAsync(cancellationToken);
}

🧩 A Note on Unit of Work

The Repository Pattern is often used together with the Unit of Work pattern to manage transactions efficiently.

💡 *If you want to dive deeper into the Unit of Work pattern, check out our separate blog post dedicated to that topic. https://abp.io/community/articles/lv4v2tyf

Service layer and controller

Controllers depend on a service, and the service depends on the repository. That keeps HTTP logic and data logic separate.

Services/ProductService.cs

using RepositoryPattern.Web.Models;
using RepositoryPattern.Web.Repositories;

namespace RepositoryPattern.Web.Services;

public class ProductService(IProductRepository productRepository)
{
    private readonly IProductRepository _productRepository = productRepository;

    public Task<List<Product>> GetProductsAsync(CancellationToken cancellationToken = default) =>
        _productRepository.GetAllAsync(cancellationToken);

    public Task<List<Product>> GetLowStockAsync(int threshold, CancellationToken cancellationToken = default) =>
        _productRepository.GetLowStockProductsAsync(threshold, cancellationToken);

    public Task<Product?> GetByIdAsync(int id, CancellationToken cancellationToken = default) =>
        _productRepository.GetByIdAsync(id, cancellationToken);

    public Task CreateAsync(Product product, CancellationToken cancellationToken = default) =>
        _productRepository.AddAsync(product, cancellationToken);

    public Task UpdateAsync(Product product, CancellationToken cancellationToken = default) =>
        _productRepository.UpdateAsync(product, cancellationToken);

    public Task DeleteAsync(int id, CancellationToken cancellationToken = default) =>
        _productRepository.DeleteAsync(id, cancellationToken);
}

Controllers/ProductsController.cs

using Microsoft.AspNetCore.Mvc;
using RepositoryPattern.Web.Models;
using RepositoryPattern.Web.Services;

namespace RepositoryPattern.Web.Controllers;

public class ProductsController(ProductService productService) : Controller
{
    private readonly ProductService _productService = productService;

    public async Task<IActionResult> Index(CancellationToken cancellationToken)
    {
        const int lowStockThreshold = 5;
        var products = await _productService.GetProductsAsync(cancellationToken);
        var lowStock = await _productService.GetLowStockAsync(lowStockThreshold, cancellationToken);

        return View(new ProductListViewModel(products, lowStock, lowStockThreshold));
    }

    // remaining CRUD actions call through ProductService in the same way
}

The controller never reaches for AppDbContext. Every operation travels through the service, which keeps tests simple and makes future refactors easier.

Dependency registration and seeding

The last step is wiring everything up in Program.cs.

builder.Services.AddDbContext<AppDbContext>(options =>
    options.UseInMemoryDatabase("ProductsDb"));
builder.Services.AddScoped(typeof(IRepository<>), typeof(EfRepository<>));
builder.Services.AddScoped<IProductRepository, ProductRepository>();
builder.Services.AddScoped<ProductService>();

The sample also seeds three products so the list page shows data on first run.

Run the site with:

dotnet run --project RepositoryPattern.Web

How ABP approaches the same idea

ABP includes generic repositories by default (IRepository<TEntity, TKey>), so you often skip writing the implementation layer shown above. You inject the interface into an application service, call methods like InsertAsync or CountAsync, and ABP’s Unit of Work handles the transaction. When you need custom queries, you can still derive from EfCoreRepository<TEntity, TKey> and add them.

For more details, check out the official ABP documentation on repositories: https://abp.io/docs/latest/framework/architecture/domain-driven-design/repositories

Closing note

This setup keeps data access tidy without being heavy. Start with the generic repository, add small extensions per entity, pass everything through services, and register the dependencies once. Whether you hand-code it or let ABP supply the repository, the structure stays the same and your controllers remain clean.

Picture this: You're building an e-commerce system and a customer places an order. You need to create the order record, update inventory, charge payment, and send a confirmation email. What happens if the payment succeeds but the inventory update fails? You're left with inconsistent data and an angry customer.

This is exactly where the Unit of Work pattern becomes invaluable. Instead of managing transactions manually across multiple repositories, this pattern coordinates all your data changes as a single, atomic operation.

Understanding the Unit of Work Pattern

The Unit of Work pattern maintains a list of objects affected by a business transaction and coordinates writing out changes while resolving concurrency problems. Think of it as your transaction coordinator that ensures all-or-nothing operations.

The Problem: Scattered Transaction Management

Without proper coordination, you often end up with code like this:

// Each repository manages its own context - risky!
await _productRepository.CreateAsync(product);
await _inventoryRepository.UpdateStockAsync(productId, -quantity);
await _orderRepository.CreateAsync(order);

This approach has several problems:

• Each operation might use a different database context
• No automatic rollback if one operation fails
• Manual transaction management becomes complex
• Data consistency isn't guaranteed

The Solution: Coordinated Operations

With Unit of Work, the same scenario becomes much cleaner:

await _unitOfWork.BeginTransactionAsync();

try
{
    var productRepo = _unitOfWork.Repository<Product>();
    var inventoryRepo = _unitOfWork.Repository<Inventory>();
    var orderRepo = _unitOfWork.Repository<Order>();

    await productRepo.AddAsync(product);
    await inventoryRepo.UpdateStockAsync(productId, -quantity);
    await orderRepo.AddAsync(order);

    await _unitOfWork.SaveChangesAsync();
    await _unitOfWork.CommitTransactionAsync();
}
catch
{
    await _unitOfWork.RollbackTransactionAsync();
    throw;
}

Now all operations either succeed together or fail together, guaranteeing data consistency.

Sample Implementation

To keep the example short, I will only show the Product entity along with the implementation of the Generic Repository and Unit of Work. In this example, I will use Blazor and .NET 9.

You can access the sample project here https://github.com/m-aliozkaya/UnitOfWorkDemo.

1. Generic Repository Implementation

The repository interface defines the contract for data operations. Here's what we're working with:

IRepository.cs at ~/Data/Repositories

using System.Linq.Expressions;

namespace UOWDemo.Repositories;

public interface IRepository<T> where T : class
{
    Task<T?> GetByIdAsync(int id);
    Task<IEnumerable<T>> GetAllAsync();
    Task<IEnumerable<T>> FindAsync(Expression<Func<T, bool>> predicate);
    Task<T?> SingleOrDefaultAsync(Expression<Func<T, bool>> predicate);

    Task AddAsync(T entity);
    void Update(T entity);
    void Remove(T entity);
    void RemoveRange(IEnumerable<T> entities);

    Task<bool> ExistsAsync(int id);
    Task<int> CountAsync();
    Task<int> CountAsync(Expression<Func<T, bool>> predicate);
}

Repository.cs at ~/Data/Repositories

using Microsoft.EntityFrameworkCore;
using System.Linq.Expressions;
using UOWDemo.Data;

namespace UOWDemo.Repositories;

public class Repository<T> : IRepository<T> where T : class
{
    protected readonly ApplicationDbContext _context;
    protected readonly DbSet<T> _dbSet;

    public Repository(ApplicationDbContext context)
    {
        _context = context;
        _dbSet = context.Set<T>();
    }

    public virtual async Task<T?> GetByIdAsync(int id)
    {
        return await _dbSet.FindAsync(id);
    }

    public virtual async Task<IEnumerable<T>> GetAllAsync()
    {
        return await _dbSet.ToListAsync();
    }

    public virtual async Task<IEnumerable<T>> FindAsync(Expression<Func<T, bool>> predicate)
    {
        return await _dbSet.Where(predicate).ToListAsync();
    }

    public virtual async Task<T?> SingleOrDefaultAsync(Expression<Func<T, bool>> predicate)
    {
        return await _dbSet.SingleOrDefaultAsync(predicate);
    }

    public virtual async Task AddAsync(T entity)
    {
        await _dbSet.AddAsync(entity);
    }

    public virtual void Update(T entity)
    {
        _dbSet.Update(entity);
    }

    public virtual void Remove(T entity)
    {
        _dbSet.Remove(entity);
    }

    public virtual void RemoveRange(IEnumerable<T> entities)
    {
        _dbSet.RemoveRange(entities);
    }

    public virtual async Task<bool> ExistsAsync(int id)
    {
        var entity = await _dbSet.FindAsync(id);
        return entity != null;
    }

    public virtual async Task<int> CountAsync()
    {
        return await _dbSet.CountAsync();
    }

    public virtual async Task<int> CountAsync(Expression<Func<T, bool>> predicate)
    {
        return await _dbSet.CountAsync(predicate);
    }
}

2. Unit of Work Implementation

IUnitOfWork.cs at ~/Data/UnitOfWork

public interface IUnitOfWork : IDisposable, IAsyncDisposable
{
    IRepository<T> Repository<T>() where T : class;
    Task<int> SaveChangesAsync(); 
    Task BeginTransactionAsync();
    Task CommitTransactionAsync();
    Task RollbackTransactionAsync();
}

UnitOfWork.cs at ~/Data/UnitOfWork

public class UnitOfWork : IUnitOfWork
{
    private readonly ApplicationDbContext _context;
    private bool _disposed;
    private IDbContextTransaction? _currentTransaction;

    // ConcurrentDictionary for thread-safe repository caching
    private readonly ConcurrentDictionary<Type, object> _repositories = new();

    public UnitOfWork(ApplicationDbContext context)
    {
        _context = context;
    }

    public IRepository<T> Repository<T>() where T : class
    {
        return (IRepository<T>)_repositories.GetOrAdd(
            typeof(T),
            _ => new Repository<T>(_context)
        );
    }

    public int SaveChanges() => context.SaveChanges();
    public Task<int> SaveChangesAsync(CancellationToken cancellationToken = default) =>
        context.SaveChangesAsync(cancellationToken);

    public async Task BeginTransactionAsync()
    {
        if (_currentTransaction != null)
            return;

        _currentTransaction = await _context.Database.BeginTransactionAsync();
    }

    public async Task CommitTransactionAsync()
    {
        if (_currentTransaction == null)
            return;

        await _currentTransaction.CommitAsync();
        await _currentTransaction.DisposeAsync();
        _currentTransaction = null;
    }

    public async Task RollbackTransactionAsync()
    {
        if (_currentTransaction == null)
            return;

        await _currentTransaction.RollbackAsync();
        await _currentTransaction.DisposeAsync();
        _currentTransaction = null;
    }

    public void Dispose()
    {
        if (!_disposed)
        {
            _context.Dispose();
            _currentTransaction?.Dispose();
            _disposed = true;
        }
        GC.SuppressFinalize(this);
    }

    public async ValueTask DisposeAsync()
    {
        if (!_disposed)
        {
            await _context.DisposeAsync();
            if (_currentTransaction != null)
            {
                await _currentTransaction.DisposeAsync();
            }
            _disposed = true;
        }
        GC.SuppressFinalize(this);
    }
}

3. Configure Dependency Injection

Register the services in your Program.cs:

builder.Services.AddScoped<IUnitOfWork, UnitOfWork>();

4. Defining and Registering Entity to DbContext

First, let's define a simple Product entity:

Product.cs at ~/Data/Entities

using System.ComponentModel.DataAnnotations;

namespace UOWDemo.Models;

public class Product
{
    public int Id { get; set; }

    [Required]
    [MaxLength(100)]
    public string Name { get; set; } = string.Empty;

    [MaxLength(500)]
    public string? Description { get; set; }

    [Required]
    [Range(0.01, double.MaxValue)]
    public decimal Price { get; set; }

    [Required]
    [Range(0, int.MaxValue)]
    public int Stock { get; set; }

    public DateTime CreatedDate { get; set; } = DateTime.UtcNow;
}

• Go to your DbContext and implement following code.

    public DbSet<Product> Products { get; set; }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        base.OnModelCreating(modelBuilder);

        modelBuilder.Entity<Product>(entity =>
        {
            entity.HasKey(e => e.Id);
            entity.Property(e => e.Price).HasPrecision(18, 2);
            entity.Property(e => e.CreatedDate).HasDefaultValueSql("GETUTCDATE()");
        });

        modelBuilder.Entity<Product>().HasData(
            new Product { Id = 1, Name = "Laptop", Description = "High-performance laptop", Price = 1299.99m, Stock = 15, CreatedDate = new DateTime(2024, 1, 1, 0, 0, 0, DateTimeKind.Utc) },
            new Product { Id = 2, Name = "Mouse", Description = "Wireless gaming mouse", Price = 79.99m, Stock = 50, CreatedDate = new DateTime(2024, 1, 1, 0, 0, 0, DateTimeKind.Utc) },
            new Product { Id = 3, Name = "Keyboard", Description = "Mechanical keyboard", Price = 149.99m, Stock = 25, CreatedDate = new DateTime(2024, 1, 1, 0, 0, 0, DateTimeKind.Utc) }
        );
    }

5. Implement the UI

ProductService.cs at ~/Services

using System.Text.Json;
using UOWDemo.Models;

namespace UOWDemo.Services;

public class ProductService
{
    private readonly HttpClient _httpClient;

    public ProductService(HttpClient httpClient)
    {
        _httpClient = httpClient;
    }

    public async Task<List<Product>> GetAllProductsAsync()
    {
        var response = await _httpClient.GetAsync("/api/products");
        response.EnsureSuccessStatusCode();
        var json = await response.Content.ReadAsStringAsync();
        return JsonSerializer.Deserialize<List<Product>>(json, new JsonSerializerOptions
        {
            PropertyNameCaseInsensitive = true
        }) ?? new List<Product>();
    }
        
    public async Task CreateTwoProductsWithUowAsync(Product product1, Product product2)
    {
        var request = new TwoProductsRequest { Product1 = product1, Product2 = product2 };
        var json = JsonSerializer.Serialize(request);
        var content = new StringContent(json, System.Text.Encoding.UTF8, "application/json");

        var response = await _httpClient.PostAsync("/api/products/two-products-with-uow", content);
        response.EnsureSuccessStatusCode();
    }

    public async Task CreateTwoProductsWithoutUowAsync(Product product1, Product product2)
    {
        var request = new TwoProductsRequest { Product1 = product1, Product2 = product2 };
        var json = JsonSerializer.Serialize(request);
        var content = new StringContent(json, System.Text.Encoding.UTF8, "application/json");

        var response = await _httpClient.PostAsync("/api/products/two-products-without-uow", content);
        response.EnsureSuccessStatusCode();
    }

    public async Task DeleteProductAsync(int id)
    {
        var response = await _httpClient.DeleteAsync($"/api/products/{id}");
        response.EnsureSuccessStatusCode();
    }
}

Products.razor at ~/Components/Pages

@page "/products"
@using UOWDemo.Models
@using UOWDemo.Services
@inject ProductService ProductService
@inject IJSRuntime JSRuntime
@rendermode InteractiveServer

<PageTitle>Products</PageTitle>

<div class="container">
    <div class="row">
        <div class="col-12">
            <h1>Product Management</h1>
            <p>This page demonstrates Unit of Work transaction patterns with bulk operations.</p>
        </div>
    </div>

    <div class="row mb-3">
        <div class="col-12">
            <button class="btn btn-success me-2" @onclick="ShowTwoProductsForm">
                <i class="bi bi-plus-circle"></i> Add Two Products Demo
            </button>
        </div>
    </div>

    @if (isLoading)
    {
        <div class="text-center">
            <div class="spinner-border" role="status">
                <span class="visually-hidden">Loading...</span>
            </div>
        </div>
    }
    else
    {
        <div class="row">
            <div class="col-12">
                <div class="table-responsive">
                    <table class="table table-striped table-hover">
                        <thead class="table-dark">
                            <tr>
                                <th>ID</th>
                                <th>Name</th>
                                <th>Description</th>
                                <th>Price</th>
                                <th>Stock</th>
                                <th>Actions</th>
                            </tr>
                        </thead>
                        <tbody>
                            @foreach (var product in products)
                            {
                                <tr>
                                    <td>@product.Id</td>
                                    <td>@product.Name</td>
                                    <td>@product.Description</td>
                                    <td>$@product.Price.ToString("F2")</td>
                                    <td>@product.Stock</td>
                                    <td>
                                        <button class="btn btn-sm btn-outline-danger" @onclick="() => DeleteProduct(product.Id)">
                                            <i class="bi bi-trash"></i> Delete
                                        </button>
                                    </td>
                                </tr>
                            }
                        </tbody>
                    </table>
                </div>
            </div>
        </div>
    }
</div>


@if (showTwoProductsModal)
{
    <div class="modal fade show d-block" tabindex="-1" style="background-color: rgba(0,0,0,0.5);">
        <div class="modal-dialog modal-lg">
            <div class="modal-content">
                <div class="modal-header">
                    <h5 class="modal-title">Two Products Demo - Unit of Work vs No Unit of Work</h5>
                    <button type="button" class="btn-close" @onclick="HideTwoProductsModal"></button>
                </div>
                <div class="modal-body">
                    <div class="row">
                        <div class="col-md-6">
                            <div class="card">
                                <div class="card-header">
                                    <h6 class="card-title">Product 1</h6>
                                </div>
                                <div class="card-body">
                                    <div class="mb-3">
                                        <label class="form-label">Name</label>
                                        <input type="text" class="form-control" @bind="product1.Name" />
                                    </div>
                                    <div class="mb-3">
                                        <label class="form-label">Description</label>
                                        <textarea class="form-control" @bind="product1.Description"></textarea>
                                    </div>
                                    <div class="mb-3">
                                        <label class="form-label">Price</label>
                                        <input type="number" step="0.01" class="form-control" @bind="product1.Price" />
                                    </div>
                                    <div class="mb-3">
                                        <label class="form-label">Stock</label>
                                        <input type="number" class="form-control" @bind="product1.Stock" />
                                    </div>
                                </div>
                            </div>
                        </div>
                        <div class="col-md-6">
                            <div class="card">
                                <div class="card-header">
                                    <h6 class="card-title">Product 2</h6>
                                </div>
                                <div class="card-body">
                                    <div class="mb-3">
                                        <label class="form-label">Name</label>
                                        <input type="text" class="form-control" @bind="product2.Name" />
                                    </div>
                                    <div class="mb-3">
                                        <label class="form-label">Description</label>
                                        <textarea class="form-control" @bind="product2.Description"></textarea>
                                    </div>
                                    <div class="mb-3">
                                        <label class="form-label">Price</label>
                                        <input type="number" step="0.01" class="form-control" @bind="product2.Price" />
                                    </div>
                                    <div class="mb-3">
                                        <label class="form-label">Stock</label>
                                        <input type="number" class="form-control" @bind="product2.Stock" />
                                    </div>
                                </div>
                            </div>
                        </div>
                    </div>
                    <div class="alert alert-info mt-3">
                        <strong>Demo Purpose:</strong> Check the console logs to see the difference in SQL transactions.
                        <ul>
                            <li><strong>With Unit of Work:</strong> Both products saved in a single transaction</li>
                            <li><strong>Without Unit of Work:</strong> Each product saved in separate transactions</li>
                        </ul>
                    </div>
                </div>
                <div class="modal-footer d-flex justify-content-between">
                    <button type="button" class="btn btn-success flex-fill me-2" @onclick="SaveTwoProductsWithUow">
                        Save with Unit of Work (Single Transaction)
                    </button>
                    <button type="button" class="btn btn-warning flex-fill ms-2" @onclick="SaveTwoProductsWithoutUow">
                        Save without Unit of Work (Separate Transactions)
                    </button>
                </div>
            </div>
        </div>
    </div>
}

@code {
    private List<Product> products = new();
    private bool isLoading = true;

    private bool showTwoProductsModal = false;
    private Product product1 = new();
    private Product product2 = new();

    protected override async Task OnInitializedAsync()
    {
        await LoadProducts();
    }

    private async Task LoadProducts()
    {
        try
        {
            isLoading = true;
            products = await ProductService.GetAllProductsAsync();
        }
        catch (Exception ex)
        {
            await JSRuntime.InvokeVoidAsync("alert", $"Error loading products: {ex.Message}");
        }
        finally
        {
            isLoading = false;
        }
    }


    private void ShowTwoProductsForm()
    {
        product1 = new Product { Name = "Product 1", Description = "First product description", Price = 10.00m, Stock = 100 };
        product2 = new Product { Name = "Product 2", Description = "Second product description", Price = 20.00m, Stock = 50 };
        showTwoProductsModal = true;
    }

    private void HideTwoProductsModal()
    {
        showTwoProductsModal = false;
        product1 = new Product();
        product2 = new Product();
    }

    private async Task SaveTwoProductsWithUow()
    {
        try
        {
            await ProductService.CreateTwoProductsWithUowAsync(product1, product2);
            await JSRuntime.InvokeVoidAsync("alert", "Two products saved with Unit of Work! Check console logs to see single transaction.");
            await LoadProducts();
            HideTwoProductsModal();
        }
        catch (Exception ex)
        {
            await JSRuntime.InvokeVoidAsync("alert", $"Error saving products with UoW: {ex.Message}");
        }
    }

    private async Task SaveTwoProductsWithoutUow()
    {
        try
        {
            await ProductService.CreateTwoProductsWithoutUowAsync(product1, product2);
            await JSRuntime.InvokeVoidAsync("alert", "Two products saved without Unit of Work! Check console logs to see separate transactions.");
            await LoadProducts();
            HideTwoProductsModal();
        }
        catch (Exception ex)
        {
            await JSRuntime.InvokeVoidAsync("alert", $"Error saving products without UoW: {ex.Message}");
        }
    }

    private async Task DeleteProduct(int id)
    {
        if (await JSRuntime.InvokeAsync<bool>("confirm", "Are you sure you want to delete this product?"))
        {
            try
            {
                await ProductService.DeleteProductAsync(id);
                await LoadProducts();
            }
            catch (Exception ex)
            {
                await JSRuntime.InvokeVoidAsync("alert", $"Error deleting product: {ex.Message}");
            }
        }
    }
}

UI Preview

ProductsController.cs at ~/Controllers

using Microsoft.AspNetCore.Mvc;
using UOWDemo.Data;
using UOWDemo.Models;
using UOWDemo.UnitOfWork;

namespace UOWDemo.Controllers;

[ApiController]
[Route("api/[controller]")]
public class ProductsController : ControllerBase
{
    private readonly IUnitOfWork _unitOfWork;
    private readonly ApplicationDbContext _context;

    public ProductsController(IUnitOfWork unitOfWork, ApplicationDbContext context)
    {
        _unitOfWork = unitOfWork;
        _context = context;
    }

    [HttpGet]
    public async Task<IActionResult> GetProducts()
    {
        var repository = _unitOfWork.Repository<Product>();
        var products = await repository.GetAllAsync();
        return Ok(products);
    }


    [HttpPost("two-products-with-uow")]
    public async Task<IActionResult> CreateTwoProductsWithUow(TwoProductsRequest request)
    {
        if (!ModelState.IsValid)
            return BadRequest(ModelState);

        await _unitOfWork.BeginTransactionAsync();

        try
        {
            var repository = _unitOfWork.Repository<Product>();
            await repository.AddAsync(request.Product1);
            await repository.AddAsync(request.Product2);
            await _unitOfWork.SaveChangesAsync();
            await _unitOfWork.CommitTransactionAsync();

            return Ok(new { message = "Two products created with Unit of Work (single transaction)",
                products = new[] { request.Product1, request.Product2 } });
        }
        catch
        {
            await _unitOfWork.RollbackTransactionAsync();
            throw;
        }
    }

    [HttpPost("two-products-without-uow")]
    public async Task<IActionResult> CreateTwoProductsWithoutUow(TwoProductsRequest request)
    {
        if (!ModelState.IsValid)
            return BadRequest(ModelState);

        // First product - separate transaction
        await _context.Products.AddAsync(request.Product1);
        await _context.SaveChangesAsync();

        // Second product - separate transaction
        await _context.Products.AddAsync(request.Product2);
        await _context.SaveChangesAsync();

        return Ok(new { message = "Two products created without Unit of Work (separate transactions)",
            products = new[] { request.Product1, request.Product2 } });
    }

    [HttpDelete("{id}")]
    public async Task<IActionResult> DeleteProduct(int id)
    {
        var repository = _unitOfWork.Repository<Product>();
        var product = await repository.GetByIdAsync(id);

        if (product == null)
            return NotFound();

        repository.Remove(product);
        await _unitOfWork.SaveChangesAsync();

        return NoContent();
    }
}

The code base should be shown like this.

6. Seeing the Difference: Transaction Logging

To see the transaction behavior in action, configure Entity Framework logging in appsettings.Development.json:

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning",
      "Microsoft.EntityFrameworkCore.Database.Command": "Information",
      "Microsoft.EntityFrameworkCore.Database.Transaction": "Information"
    }
  }
}

Now when you run the demo, the console will show:

With Unit of Work - One Transaction:

BEGIN TRANSACTION
INSERT INTO [Products] ([Name], [Description], [Price], [Stock]) VALUES ('Product 1', ...)
INSERT INTO [Products] ([Name], [Description], [Price], [Stock]) VALUES ('Product 2', ...)
COMMIT TRANSACTION

Without Unit of Work - Two Separate Transactions:

BEGIN TRANSACTION
INSERT INTO [Products] ([Name], [Description], [Price], [Stock]) VALUES ('Product 1', ...)
COMMIT TRANSACTION

BEGIN TRANSACTION
INSERT INTO [Products] ([Name], [Description], [Price], [Stock]) VALUES ('Product 2', ...)
COMMIT TRANSACTION

What If?

What if we were using the ABP Framework instead of manually implementing the Unit of Work and Generic Repository? Well, most of the heavy lifting we did in this example would be handled automatically. ABP provides built-in support for Unit of Work, transactions, and repository patterns, allowing you to focus on business logic rather than plumbing code.

Key Advantages with ABP

Automatic Transaction Management: Every application service method runs within a transaction by default. If an exception occurs, changes are automatically rolled back.

• [UnitOfWork] Attribute: You can simply annotate a method with [UnitOfWork] to ensure all repository operations within it run in a single transaction.

• Automatic SaveChanges: You don’t need to call SaveChanges() manually; ABP takes care of persisting changes at the end of a Unit of Work.

• Configurable Transaction Options: Transaction isolation levels and timeouts can be easily configured, helping with performance and data consistency.

• Event-Based Completion: After a successful transaction, related domain events can be triggered automatically—for example, sending a confirmation email when an entity is created.

And many of them. If you interested in check this document. https://abp.io/docs/latest/framework/architecture/domain-driven-design/unit-of-work

📌 Example:

[UnitOfWork]
public void CreatePerson(CreatePersonInput input)
{
    var person = new Person { Name = input.Name, EmailAddress = input.EmailAddress };
    _personRepository.Insert(person);
    _statisticsRepository.IncrementPeopleCount();
}

In this example, both repository operations execute within the same transaction. ABP handles the commit automatically, so either all changes succeed or none are applied.

Takeaway: With ABP, developers don’t need to manually implement Unit of Work or manage transactions. This reduces boilerplate code, ensures consistency, and lets you focus on the domain logic.

Conclusion

The Unit of Work pattern shines in scenarios where multiple operations must succeed or fail together. By centralizing transaction management and repository access, it reduces complexity and ensures consistency.

This demo kept things simple with a single Product entity, but the same approach scales to more complex domains. Whether you’re building an e-commerce app, a financial system, or any data-heavy application, adopting Unit of Work with a Generic Repository can make your codebase cleaner, safer, and easier to maintain.

Feel free to clone the sample project, experiment with it, and adapt the pattern to your own needs. 🚀

Entity Framework Core has official support for HierarchyId, which allows you to store and query hierarchical data in SQL Server databases. Hierarchical data is a common data structure found in many applications. Whether you are dealing with organizational structures, product categories, or threaded discussions, handling hierarchies efficiently is crucial. In this blog post, we will explore how to manage hierarchical data using Entity Framework Core (EF Core) in combination with HierarchyId.

How to use HierarchyId in EF Core

To use HierarchyId in EF Core, you need to install the Microsoft.EntityFrameworkCore.SqlServer.HierarchyId NuGet package. This package contains query and update support for HierarchyId.

To configure EF Core to use HierarchyId, you need to call the UseHierarchyId method when configuring the SQL Server provider.

options.UseSqlServer(
    connectionString,
    x => x.UseHierarchyId());

Modeling Hierarchies

The HierarchyId type can be used for properties of an entity type. For example, assume we want to model the personnel in an organization. Each person has a name and a manager. The manager is also a person. We can model this using the following entity type:

public class Person
{
    public int Id { get; set; }
    public string Name { get; set; }
    public HierarchyId Manager { get; set; }
}

Each person can be traced from the patriarch down the tree using its Manager property. SQL Server uses a compact binary format for these paths, but it is common to parse to and from a human-readable string representation when working with code. In this representation, the position at each level is separated by a / character.

Querying Hierarchies

HierarchyId exposes several methods that can be used in LINQ queries.

• GetAncestor(int level) returns the ancestor at the specified level.

• GetDescendant(HierarchyId? child1, HierarchyId? child2) returns the descendant at the specified level.

• GetLevel() returns the level of the node in the hierarchy.

• GetReparentedValue(HierarchyId? oldRoot, HierarchyId? newRoot) returns the node with a new parent.

• IsDescendantOf(HierarchyId? parent) returns whether the node is a descendant of the specified node.

Example:

// Get entities at a given level in the tree
var generation = await context.Persons.Where(x => x.Manager.GetLevel() == level).ToListAsync();

// Get the direct ancestor of an entity
var parent = await context.Persons.Where(x => x.Manager.GetAncestor(1) == manager).SingleAsync();

For example, your company may want to change the manager of an organizational unit. To do this, you can use the GetReparentedValue method to update the manager for all descendants of the organizational unit.

var newManager = await context.Persons.SingleAsync(x => x.Id == newManagerId);

var descendants = await context.Persons
    .Where(x => x.Manager.IsDescendantOf(oldManager))
    .ToListAsync();

foreach (var descendant in descendants)
{
    descendant.Manager = descendant.Manager.GetReparentedValue(oldManager.Manager, newManager.Manager);
}

await context.SaveChangesAsync();

References

For more information about hierarchy id, see the following resource:

• https://learn.microsoft.com/en-us/ef/core/what-is-new/ef-core-8.0/whatsnew#hierarchyid-in-net-and-ef-core

In this article we will show how to use gRPC health checks with the ABP Framework.

Health Checks

ASP.NET Core 7 supports gRPC health checks. Health Checks allow us to determine the overall health and availability of our application infrastructure. They are exposed as HTTP endpoints and can be configured to provide information for various monitoring scenarios, such as the response time and memory usage of our application, or whether our application can communicate with our database provider.

gRPC Health Checks

The gRPC health checking protocol is a standard for reporting the health of gRPC server apps. An app exposes health checks as a gRPC service. They are typically used with an external monitoring service to check the status of an app.

Grpc.AspNetCore.HealthChecks

ASP.NET Core supports the gRPC health checking protocol with the Grpc.AspNetCore.HealthChecks package. Results from .NET health checks are reported to callers.

Using gRPC Health Checks with the ABP Framework

In this article, I'm assuming you've used gRPC with ABP before. If you are still having problems with this, it may be good for you to review this article. https://community.abp.io/posts/using-grpc-with-the-abp-framework-2dgaxzw3

Set up gRPC Health Checks

In this solution, *.HttpApi.Host is the project that configures and runs the server-side application. So, we will make changes in that project.

• Add the Grpc.AspNetCore.HealthChecks package to your project.

dotnet add package Grpc.AspNetCore.HealthChecks

• AddGrpcHealthChecks to register services that enable health checks.

public override void ConfigureServices(ServiceConfigurationContext context)
{
    // Other configurations...

    context.Services.AddGrpcHealthChecks()
        .AddCheck("SampleHealthCheck", () => HealthCheckResult.Healthy());
}

• MapGrpcHealthChecksService to add a health check service endpoint.

public override void OnApplicationInitialization(ApplicationInitializationContext context)
{
    // Other middlewares...

    app.UseConfiguredEndpoints(builder =>
    {
        builder.MapGrpcHealthChecksService();
    });
}

Calling Health Checks From a Client

Now that our server is configured for gRPC health checks, we can test it by creating a basic console client.

var channel = GrpcChannel.ForAddress("https://localhost:44357");
var client = new Health.HealthClient(channel);

var response = await client.CheckAsync(new HealthCheckRequest());
var status = response.Status;

Console.WriteLine($"Health Status: {status}");

References

• https://learn.microsoft.com/en-us/aspnet/core/release-notes/aspnetcore-7.0?view=aspnetcore-7.0#grpc-health-checks-in-aspnet-core