Design and Architecture

Kevin Marois wrote:

var test = projectRepo.FindProjectsByName(entity.ProjectName);

if (test != null)
{
    projectRepo.Add(entity);

    foreach (var task in entity.Tasks)
    {
        projectTaskRepo.Add(task);
    }

    dc.SaveChanges();
}
else
{
    throw new DuplicateProjectException(entity.ProjectName);
}

var test = projectRepo.FindProjectsByName(entity.ProjectName);
if (test.Any()) throw new DuplicateProjectException(entity.ProjectName);

projectRepo.Add(entity);

foreach (var task in entity.Tasks)
{
    projectTaskRepo.Add(task);
}

dc.SaveChanges();

Kevin Marois wrote:

IEnumerable<TEntity> GetAll();
IEnumerable<TEntity> Find(Expression<Func<TEntity, bool>> predicate);

Richard Deeming wrote:

Purists frown on it,

interface IUnitOfWork : IDisposable
{
    void Save();
    Task SaveAsync();
}

// NB: Could implement the IUnitOfWork interface directly on the FalconContext class.
class FalconContextUnitOfWork : IUnitOfWork
{
    private readonly FalconContext _context;
    
    public FalconContextUnitOfWork(FalconContext context)
    {
        _context = context;
    }
    
    public void Save()
    {
        _context.SaveChanges();
    }
    
    public Task SaveAsync()
    {
        return _context.SaveChangesAsync();
    }
    
    public void Dispose()
    {
        _context.Dispose();
    }
}

interface IBizObject : IDisposable
{
    void AddProject(Project entity);
}

class BizObject : IBizObject
{
    private readonly IProjectsRepository _projectsRepository;
    private readonly IProjectsTaskRepository _projectsTaskRepository;
    private readonly IUnitOfWork _unitOfWork;
    
    public BizObject(IProjectsRepository projectsRepository, IProjectsTaskRepository projectsTaskRepository, IUnitOfWork unitOfWork)
    {
        _projectsRepository = projectsRepository;
        _projectsTaskRepository = projectsTaskRepository;
        _unitOfWork = _unitOfWork;
    }
    
    public void AddProject(Project entity)
    {
        if (_projectsRepository.FindProjectsByName(entity.ProjectName).Any())
        {
            throw new DuplicateProjectException(entity.ProjectName);
        }
        
        _projectsRepository.Add(entity);

        foreach (var task in entity.Tasks)
        {
            _projectsTaskRepository.Add(task);
        }
        
        _unitOfWork.Save();
    }
    
    public void Dispose()
    {
        _unitOfWork.Dispose();
    }
}

public class ProjectsController : ApiController
{
    private IBizObject _bo;
    
    public ProjectsController(IBizObject bo)
    {
        _bo = bo;
    }

    public IHttpActionResult AddProject(Project entity)
    {
        _bo.AddProject(entity);
        return Ok();
    }
    
    protected override void Dispose(bool disposing)
    {
        base.Dispose(disposing);
        if (disposing) _bo.Dispose();
    }
}

Richard Deeming wrote:

Register all of the concrete implementations as transient services in your DI container

1. Create or retrieve the FalconContext for the current request;
2. Create a new instance of the FalconContextUnitOfWork and repository classes, passing in the context;
3. Create a new instance of the BizObject class, passing in the repository and unit-of-work instances;
4. Create a new instance of your controller class, passing in the BizObject instance;
5. Invoke the controller action;
6. Clean up the transient / scoped instances for the request;

• Check customer credit limit
• Create an invoice header and details
• Call the Inventory portion to ensure handle inventory issues
• Call the shipping portion

Kevin Marois wrote:

These UOW's would be the classes that actually create the repos