ASP.NET Hosting

ASP.NET Tutorial: Clean Architecture ASP.NET Core Web API Proxy

Suzan Kara

Building a solid and scalable solution is critical in modern web development. This path frequently entails harmonizing architectural concepts and design patterns in order to improve maintainability and flexibility. Our project investigates the development of an ASP.NET Core Web API using the Clean Architecture paradigm and the Proxy Pattern. Our implementation, which focuses on the dynamic area of CarCompany administration, takes a structured and modular approach to CRUD (Create, Read, Update, Delete) activities.

We intend to build a Proxy layer, which will provide a versatile gateway for providing extra capabilities like as caching, logging, and validation, by making systematic use of interfaces, repositories, and dependency injection. This confluence of industry best practices serves as the foundation for a robust and flexible web API designed for CarCompany data management.

Clean Architecture for a Proxy Pattern in an ASP.NET Core Web API. The next example will concentrate on a CarCompany CRUD (Create, Read, Update, and Delete) application.

1. Define the Domain Model

// Domain Layer
public class CarCompany
{
    public int Id { get; set; }
    public string Name { get; set; }
}

2. Create an Interface for the Repository

// Data Access Layer
public interface ICarCompanyRepository
{
    Task<CarCompany> GetByIdAsync(int id);
    Task<List<CarCompany>> GetAllAsync();
    Task<int> CreateAsync(CarCompany carCompany);
    Task UpdateAsync(CarCompany carCompany);
    Task DeleteAsync(int id);
}

3. Implement the Repository

// Data Access Layer
public class CarCompanyRepository: ICarCompanyRepository
{
    private readonly ApplicationDbContext _dbContext;

    public CarCompanyRepository(ApplicationDbContext dbContext)
    {
        _dbContext = dbContext;
    }

    public async Task<CarCompany> GetByIdAsync(int id)
    {
        return await _dbContext.CarCompanies.FindAsync(id);
    }

    public async Task<List<CarCompany>> GetAllAsync()
    {
        return await _dbContext.CarCompanies.ToListAsync();
    }

    public async Task<int> CreateAsync(CarCompany carCompany)
    {
        _dbContext.CarCompanies.Add(carCompany);
        await _dbContext.SaveChangesAsync();
        return carCompany.Id;
    }

    public async Task UpdateAsync(CarCompany carCompany)
    {
        _dbContext.Entry(carCompany).State = EntityState.Modified;
        await _dbContext.SaveChangesAsync();
    }

    public async Task DeleteAsync(int id)
    {
        var carCompany = await _dbContext.CarCompanies.FindAsync(id);
        if (carCompany != null)
        {
            _dbContext.CarCompanies.Remove(carCompany);
            await _dbContext.SaveChangesAsync();
        }
    }
}

4. Create a Proxy for the Repository

// Application Layer
public class CarCompanyRepositoryProxy : ICarCompanyRepository
{
    private readonly ICarCompanyRepository _realRepository;

    public CarCompanyRepositoryProxy(ICarCompanyRepository realRepository)
    {
        _realRepository = realRepository;
    }

    public async Task<CarCompany> GetByIdAsync(int id)
    {
        return await _realRepository.GetByIdAsync(id);
    }

    public async Task<List<CarCompany>> GetAllAsync()
    {
        return await _realRepository.GetAllAsync();
    }

    public async Task<int> CreateAsync(CarCompany carCompany)
    {
        return await _realRepository.CreateAsync(carCompany);
    }

    public async Task UpdateAsync(CarCompany carCompany)
    {
        await _realRepository.UpdateAsync(carCompany);
    }

    public async Task DeleteAsync(int id)
    {
        await _realRepository.DeleteAsync(id);
    }
}

5. Dependency Injection in Startup.cs

// In Startup.cs ConfigureServices method
services.AddScoped<ICarCompanyRepository, CarCompanyRepository>();
services.AddScoped<ICarCompanyRepository, CarCompanyRepositoryProxy>();

6. Use the Proxy in Your Controller

// API Layer
[ApiController]
[Route("api/carcompanies")]
public class CarCompanyController: ControllerBase
{
    private readonly ICarCompanyRepository _repository;

    public CarCompanyController(ICarCompanyRepository repository)
    {
        _repository = repository;
    }

    [HttpGet("{id}")]
    public async Task<IActionResult> GetById(int id)
    {
        try
        {
            var carCompany = await _repository.GetByIdAsync(id);

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

            return Ok(carCompany);
        }
        catch (Exception ex)
        {
            // Log the exception
            return StatusCode(500, "Internal Server Error");
        }
    }

    [HttpGet]
    public async Task<IActionResult> GetAll()
    {
        try
        {
            var carCompanies = await _repository.GetAllAsync();
            return Ok(carCompanies);
        }
        catch (Exception ex)
        {
            // Log the exception
            return StatusCode(500, "Internal Server Error");
        }
    }

    [HttpPost]
    public async Task<IActionResult> Create([FromBody] CarCompany carCompany)
    {
        try
        {
            if (carCompany == null)
                return BadRequest("Invalid data");

            var id = await _repository.CreateAsync(carCompany);
            return CreatedAtAction(nameof(GetById), new { id }, carCompany);
        }
        catch (Exception ex)
        {
            // Log the exception
            return StatusCode(500, "Internal Server Error");
        }
    }

    [HttpPut("{id}")]
    public async Task<IActionResult> Update(int id, [FromBody] CarCompany carCompany)
    {
        try
        {
            if (carCompany == null || id != carCompany.Id)
                return BadRequest("Invalid data");

            await _repository.UpdateAsync(carCompany);
            return NoContent();
        }
        catch (Exception ex)
        {
            // Log the exception
            return StatusCode(500, "Internal Server Error");
        }
    }

    [HttpDelete("{id}")]
    public async Task<IActionResult> Delete(int id)
    {
        try
        {
            await _repository.DeleteAsync(id);
            return NoContent();
        }
        catch (Exception ex)
        {
            // Log the exception
            return StatusCode(500, "Internal Server Error");
        }
    }
}

The provided code outlines the implementation of the Proxy Pattern in an ASP.NET Core Web API with Clean Architecture for a CarCompany CRUD application. Here are the key takeaways.

  • Domain Model: The carCompany class in the Domain Layer represents the main entity.
  • Repository Interface: ICarCompanyRepository in the Data Access Layer defines the contract for data operations.
  • Repository Implementation: CarCompanyRepository implements the repository interface, providing basic CRUD operations.
  • Proxy for Repository: CarCompanyRepositoryProxy acts as a proxy for the real repository, allowing additional logic to be executed before or after invoking the real repository.
  • Dependency Injection: In Startup. cs, the dependencies are configured using the built-in dependency injection system of ASP.NET Core.
  • Controller: The CarCompanyController in the API Layer uses the proxy repository to handle HTTP requests, performing CRUD operations on the CarCompany entity.
  • Error Handling: Basic error handling is included in each action of the controller. Exceptions are caught and logged, and appropriate HTTP status codes are returned.

ASP.NET Core 8 Hosting Recommendation

HostForLIFE.eu
HostForLIFE.eu is a popular recommendation that offers various hosting choices. Starting from shared hosting to dedicated servers, you will find options fit for beginners and popular websites. It offers various hosting choices if you want to scale up. Also, you get flexible billing plans where you can choose to purchase a subscription even for one or six months.