Una "sorta di" unità di unità di lavoro

Ho letto modello Unità di lavoro e tonnellate di Esempi di unità di lavoro MVC / EF ma quello che sto cercando di fare è incapsulare più unità di lavoro in un grande insieme. Forse questo schema esiste già da qualche parte, ma non ne sono consapevole se lo fa.

Per mantenere pulito DbContexts EF, li ho suddivisi in diversi domini, tuttavia a volte questi domini si sovrappongono. Devo anche fare un tipo di unità di lavoro non-db (come salvare un file sull'HD e cancellare il rollback). Non so se ci sia un modello diverso per questo o no, ma vorrei fare qualcosa di simile:

// very rough idea
public class UnitOfWork
{
  public UnitOfWork(Func<bool> work, Action commit)
  {
    _work = work;
    _commit = commit;
  }
  public Func<bool> _work;
  public Action _commit;
  public bool HasExecuted { get; set; }
  public bool IsSuccessful { get; set; }
  public Exception Exception { get; set; }
  public bool Work()
  {
    try
    {
      HasExecuted = true;
      IsSuccessful = _work();
    }
    catch(Exception ex)
    { 
      Exception = ex;
    }
    return IsSuccessful;
  }
  public 
}

// very rough idea
public class TransactionWork
{
  private List<UnitOfWork> _uofs = new List<UnitOfWork>();
  public void Add(UnitOfWork uof)
  {
    _oufs.Add(uof);
  }
  public bool Commit()
  {
    var result = true;
    var exceptions = new List<Exception>();
    foreach(var uof in _uofs)
    {
      result = result && uof.Work();
      if (uof.Exception != null)
      {
        exceptions.Add(uof.Exception);
      }
    }

    if (result)
    {
      foreach(var uof in _uofs)
      {
        uof.Commit();
      }
    }
    else if (exceptions.Count > 0)
    {
      throw new AggregateException(exceptions);
    }
    return result;
  }
}

// Transaction would be a custom object I create to encapsulate
// multiple UoW.
var transactionWork = New TransactionWork();

transactionWork.Add(uof1);
transactionWork.Add(uof2);

var result = transactionWork.Commit();

Se uno dei comandi di uof non è riuscito, tutti verrebbero ripristinati.

Sono curioso di sapere se esiste uno schema come questo, o qualsiasi tipo di miglioramento che non ho mai pensato, ecc. ecc.