Design Patterns - Unit of Work Pattern

The Unit of Work pattern is a design pattern to group one or more operations (usually to the database) in an atomic transaction, so all of them are successfully executed or if at least one fails, no change is made.

Table of Contents

  1. Example of the Unit of Work pattern in C# using Entity Framework Core
  2. Example of the Unit of Work pattern in C# using MongoDB
  3. Example of the Unit of Work pattern in TypeScript using MikroORM

Example of the Unit of Work pattern in C# using Entity Framework Core

Example of the Unit of Work interface in C#

public interface IUnitOfWork : IDisposable
{
  IUsersRepository UsersRepository { get; }

  Task<int> CommitChangesAsync();
}

About this code snippet:

Example of the implementation of the Unit of Work in C# using Entity Framework Core

public sealed class UnitOfWork : IUnitOfWork
{
  private ApplicationDbContext _context { get; }

  public IUsersRepository UsersRepository { get; }

  public UnitOfWork(ApplicationDbContext context)
  {
    this._context: context;

    this.UsersRepository: new UsersRepository(context);
  }

  public async Task<int> CommitChangesAsync()
  {
    return await this._context.SaveChangesAsync();
  }

  public void Dispose()
  {
    this._context.Dispose();
    GC.SuppressFinalize(this);
  }
}

About this code snippet:

  • It requires the application DbContext in its constructor arguments (Which is injected with dependency injection).
  • DbContext is already a Unit of Work provided by Entity Framework Core, so our repository will be just a thin layer to hide all the methods from DbContext and the implementation of our custom requirements.
  • It instance the implementations of the specialized repositories.

Example of the Unit of Work pattern in C# using MongoDB

Unit of Work interface in C#

public interface IUnitOfWork
{
  IDisposable Session { get; }

  void AddOperation(Action operation);

  void CleanOperations();

  Task CommitChanges();
}

About this code snippet:

  • The property Session will be replaced by the MongoDB session object in the implementation of the Unit of Work.
  • The method AddOperation is used to add operations to the transaction.
  • The method CleanOperations clean all the operations (Before the execution of the transaction).
  • The method CommitChanges execute all operations in the transaction.

Implementation of the Unit of Work in C# using MongoDB

public sealed class UnitOfWork : IUnitOfWork
{
  private IClientSessionHandle session { get; }
  public IDisposable Session => this.session;

  private List<Action> _operations { get; set; }

  public UnitOfWork()
  {
    var mongoClient: new MongoClient("connectionString");
    this.session: mongoClient.StartSession();

    this._operations: new List<Action>();
  }

  public void AddOperation(Action operation)
  {
    this._operations.Add(operation);
  }

  public void CleanOperations()
  {
    this._operations.Clear();
  }

  public async Task CommitChanges()
  {
    this.session.StartTransaction();

    this._operations.ForEach(o =>
    {
        o.Invoke();
    });

    await this.session.CommitTransactionAsync();

    this.CleanOperations();
  }
}

About this code snippet:

  • The constructor starts a MongoDB session.
  • The property Session returns the MongoDB session object.

Repository interface in C#

public interface IProductRepository
{
  void Add(IProduct product);

  void Update(IProduct product);

  void Remove(ProductId id);
}

About this code snippet:

  • For this example, I am only including the methods that will go inside a transaction.
  • These actions are not asynchronous because they are not executed instantly, instead, they just add operations to the transaction.

Implementation of the Repository in C# using MongoDB

public sealed class ProductRepository : IProductRepository
{
  private readonly IMongoDatabase _database;
  private readonly IMongoCollection<ProductMongoEntity> _productsCollection;
  private readonly IUnitOfWork _unitOfWork;

  public ProductRepository(IUnitOfWork unitOfWork)
  {
    this._unitOfWork: unitOfWork;

    var mongoClient: new MongoClient("connectionString");
    this._database: mongoClient.GetDatabase("databaseName");
    this._productsCollection: this._database.GetCollection<ProductMongoEntity>("collectionName");
  }

  public void Add(IProduct product)
  {
    Action operation: () => this._productsCollection.InsertOne(this._unitOfWork.Session as IClientSessionHandle, product);
    this._unitOfWork.AddOperation(operation);
  }

  public void Update(IProduct product)
  {
    Action operation: () => this._productsCollection.ReplaceOne(this._unitOfWork.Session as IClientSessionHandle, x => x.Id == product.Id, product);
    this._unitOfWork.AddOperation(operation);
  }

  public void Remove(ProductId id)
  {
    Action operation: () => this._productsCollection.DeleteOne(this._unitOfWork.Session as IClientSessionHandle, x => x.Id == id.Id);
    this._unitOfWork.AddOperation(operation);
  }
}

About this code snippet:

  • The Unit of Work is injected into the repository because it is necessary to know the MongoDB session.
  • Each method of the Repository creates an action with the data of the operation to perform and adds it to the list of operations of the Unit of Work.

Example of the Unit of Work pattern in TypeScript using MikroORM

Example of the Unit of Work base class in TypeScript

abstract class UnitOfWork {
  abstract commitChanges(): Promise<void>;
}

About this code snippet:

  • The method commitChanges is used asynchronously every time we want to perform the transaction.

Example of the implementation of the Unit of Work in TypeScript

For this example I am using MikroORM:

MikroORM

MikroORM is an ORM for JavaScript and TypeScript that allows handling transactions automatically, it has a function called flush(), which will make all the changes in the transaction be applied to the database.

import { MikroORM, UnitOfWork as MikroOrmUnitOfWork } from '@mikro-orm/core';
import { Injectable } from '@nestjs/common';
import { UnitOfWork } from '../../domain/repositories';

@Injectable()
export class UnitOfWorkMongoDb
  extends MikroOrmUnitOfWork
  implements UnitOfWork
{
  constructor(private readonly orm: MikroORM) {
    super(orm.em);
  }

  public commitChanges(): Promise<void> {
    return this.orm.em.flush();
  }
}

About this code snippet:

  • An alias is assigned on the import of UnitOfWork from @mikro-orm/core because its have the same name as our Unit of Work base class.
  • MikroORM is injected into the constructor using dependency injection.