Uni Of Work - Project Structure

                       

 

Project Structure

1. Controllers

   • Your ASP.NET Core MVC controllers handle incoming HTTP requests, interact with services, and return responses.

2. Services

   • Interfaces: Define interfaces for your services that will interact with data.
   • Implementations: Implement these interfaces to encapsulate business logic and data operations.
   • Example:

     Services/
     ├── ICustomerService.cs
     ├── CustomerService.cs
     

3. Repositories

   • Interfaces: Define interfaces for repositories that will handle data operations.
   • Implementations: Implement these interfaces to perform CRUD operations on specific entities.
   • Example:

     Repository/
     ├── ICustomerRepository.cs
     ├── CustomerRepository.cs
     

4. DbContext

   • Your Entity Framework DbContext manages database connections and entity relationships.
   • Example:

     Data/
     ├── ApplicationDbContext.cs
     

5. Unit of Work

   • Implement the Unit of Work pattern to coordinate data operations across multiple repositories within a single transaction.
   • Example:

     Infrastructure/
     ├── IUnitOfWork.cs
     ├── UnitOfWork.cs
     

6. Models

   • Define your data models or entities that represent database tables.
   • Example:

     Models/
     ├── Customer.cs
     

Implementation

Here’s how these components would interact:

• DbContext (ApplicationDbContext.cs):

  csharp
  public class ApplicationDbContext : DbContext
  {
      public DbSet<Customer> Customers { get; set; }
      // Other DbSets and configuration
  }
  

• Repositories (ICustomerRepository.cs, CustomerRepository.cs):

  csharp
  public interface ICustomerRepository
  {
      Task<Customer> GetByIdAsync(int id);
      void Add(Customer customer);
      void Update(Customer customer);
      void Delete(Customer customer);
      // Other methods as needed
  }
  
  public class CustomerRepository : ICustomerRepository
  {
      private readonly ApplicationDbContext _context;
  
      public CustomerRepository(ApplicationDbContext context)
      {
          _context = context;
      }
  
      public async Task<Customer> GetByIdAsync(int id)
      {
          return await _context.Customers.FindAsync(id);
      }
  
      public void Add(Customer customer)
      {
          _context.Customers.Add(customer);
      }
  
      public void Update(Customer customer)
      {
          _context.Customers.Update(customer);
      }
  
      public void Delete(Customer customer)
      {
          _context.Customers.Remove(customer);
      }
  
      // Implement other repository methods
  }
  

• Unit of Work (IUnitOfWork.cs, UnitOfWork.cs):

  csharp
  public interface IUnitOfWork : IDisposable
  {
      ICustomerRepository Customers { get; }
      // Other repositories as needed
  
      Task<int> CompleteAsync();
  }
  
  public class UnitOfWork : IUnitOfWork
  {
      private readonly ApplicationDbContext _context;
  
      public UnitOfWork(ApplicationDbContext context)
      {
          _context = context;
          Customers = new CustomerRepository(_context);
          // Initialize other repositories
      }
  
      public ICustomerRepository Customers { get; private set; }
      // Other repositories as properties
  
      public async Task<int> CompleteAsync()
      {
          return await _context.SaveChangesAsync();
      }
  
      public void Dispose()
      {
          _context.Dispose();
      }
  }
  

• Services (ICustomerService.cs, CustomerService.cs):

  csharp
  public interface ICustomerService
  {
      Task<Customer> GetCustomerByIdAsync(int id);
      Task CreateCustomerAsync(Customer customer);
      Task UpdateCustomerAsync(Customer customer);
      Task DeleteCustomerAsync(int id);
  }
  
  public class CustomerService : ICustomerService
  {
      private readonly IUnitOfWork _unitOfWork;
  
      public CustomerService(IUnitOfWork unitOfWork)
      {
          _unitOfWork = unitOfWork;
      }
  
      public async Task<Customer> GetCustomerByIdAsync(int id)
      {
          return await _unitOfWork.Customers.GetByIdAsync(id);
      }
  
      public async Task CreateCustomerAsync(Customer customer)
      {
          _unitOfWork.Customers.Add(customer);
          await _unitOfWork.CompleteAsync();
      }
  
      public async Task UpdateCustomerAsync(Customer customer)
      {
          _unitOfWork.Customers.Update(customer);
          await _unitOfWork.CompleteAsync();
      }
  
      public async Task DeleteCustomerAsync(int id)
      {
          var customer = await _unitOfWork.Customers.GetByIdAsync(id);
          if (customer != null)
          {
              _unitOfWork.Customers.Delete(customer);
              await _unitOfWork.CompleteAsync();
          }
      }
  }
  

Dependency Injection (Startup.cs)

In your Startup.cs file, configure dependency injection for your services and the unit of work:

csharp
public void ConfigureServices(IServiceCollection services)
{
    // DbContext
    services.AddDbContext<ApplicationDbContext>(options =>
        options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));

    // Repositories
    services.AddScoped<ICustomerRepository, CustomerRepository>();
    // Other repositories

    // Unit of Work
    services.AddScoped<IUnitOfWork, UnitOfWork>();

    // Services
    services.AddScoped<ICustomerService, CustomerService>();
    // Other services

    // MVC
    services.AddControllersWithViews();
}

Controller Usage

Finally, in your controller, inject the service(s) you need and use them to handle requests:

csharp
public class CustomerController : Controller
{
    private readonly ICustomerService _customerService;

    public CustomerController(ICustomerService customerService)
    {
        _customerService = customerService;
    }

    public async Task<IActionResult> Index()
    {
        var customers = await _customerService.GetAllCustomersAsync();
        return View(customers);
    }

    // Other action methods
}

Summary

This structured approach ensures separation of concerns and facilitates maintainability and scalability of your ASP.NET Core MVC application using the Unit of Work pattern. Each component (controllers, services, repositories, DbContext, and Unit of Work) plays a specific role in handling requests, business logic, data access, and transaction management, respectively.