Capa de servicio

Implementar una capa de servicio en una aplicación ASP.NET MVC es una buena práctica para separar la lógica de negocio de la lógica de presentación. Esto permite un mejor mantenimiento, reutilización del código y pruebas más sencillas. A continuación, te mostraré cómo crear una capa de servicio paso a paso.

1. Estructura del Proyecto

Primero, es útil tener una estructura de proyecto clara. Una estructura común puede ser:

/MiProyecto
    /Controllers
    /Models
    /Services
    /Repositories
    /Views

• Controllers: Contiene los controladores de MVC.
• Models: Contiene las clases de modelo.
• Services: Contiene la lógica de negocio y los servicios.
• Repositories: Contiene la lógica de acceso a datos.
• Views: Contiene las vistas de la aplicación.

2. Crear Modelos

Vamos a crear un modelo simple. Por ejemplo, supongamos que estamos trabajando con una aplicación de gestión de productos.

// Models/Producto.cs
public class Producto
{
    public int Id { get; set; }
    public string Nombre { get; set; }
    public decimal Precio { get; set; }
}

3. Crear un Repositorio

El repositorio se encargará de la interacción con la base de datos.

// Repositories/IProductoRepository.cs
public interface IProductoRepository
{
    IEnumerable<Producto> ObtenerTodos();
    Producto ObtenerPorId(int id);
    void Agregar(Producto producto);
    void Actualizar(Producto producto);
    void Eliminar(int id);
}

// Repositories/ProductoRepository.cs
public class ProductoRepository : IProductoRepository
{
    private readonly ApplicationDbContext _context;

    public ProductoRepository(ApplicationDbContext context)
    {
        _context = context;
    }

    public IEnumerable<Producto> ObtenerTodos()
    {
        return _context.Productos.ToList();
    }

    public Producto ObtenerPorId(int id)
    {
        return _context.Productos.Find(id);
    }

    public void Agregar(Producto producto)
    {
        _context.Productos.Add(producto);
        _context.SaveChanges();
    }

    public void Actualizar(Producto producto)
    {
        _context.Productos.Update(producto);
        _context.SaveChanges();
    }

    public void Eliminar(int id)
    {
        var producto = ObtenerPorId(id);
        if (producto != null)
        {
            _context.Productos.Remove(producto);
            _context.SaveChanges();
        }
    }
}

4. Crear la Capa de Servicio

Ahora creamos la capa de servicio que utiliza el repositorio.

// Services/IProductoService.cs
public interface IProductoService
{
    IEnumerable<Producto> ObtenerTodos();
    Producto ObtenerPorId(int id);
    void CrearProducto(Producto producto);
    void ActualizarProducto(Producto producto);
    void EliminarProducto(int id);
}

// Services/ProductoService.cs
public class ProductoService : IProductoService
{
    private readonly IProductoRepository _productoRepository;

    public ProductoService(IProductoRepository productoRepository)
    {
        _productoRepository = productoRepository;
    }

    public IEnumerable<Producto> ObtenerTodos()
    {
        return _productoRepository.ObtenerTodos();
    }

    public Producto ObtenerPorId(int id)
    {
        return _productoRepository.ObtenerPorId(id);
    }

    public void CrearProducto(Producto producto)
    {
        _productoRepository.Agregar(producto);
    }

    public void ActualizarProducto(Producto producto)
    {
        _productoRepository.Actualizar(producto);
    }

    public void EliminarProducto(int id)
    {
        _productoRepository.Eliminar(id);
    }
}

5. Inyección de Dependencias

Para utilizar la capa de servicio en el controlador, necesitas registrar las dependencias en el contenedor de inyección de dependencias. Esto generalmente se hace en Startup.cs.

// Startup.cs
public void ConfigureServices(IServiceCollection services)
{
    services.AddControllersWithViews();

    // Registrar el contexto de la base de datos
    services.AddDbContext<ApplicationDbContext>(options =>
        options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));

    // Registrar el repositorio y el servicio
    services.AddScoped<IProductoRepository, ProductoRepository>();
    services.AddScoped<IProductoService, ProductoService>();
}

6. Usar la Capa de Servicio en un Controlador

Ahora que tienes la capa de servicio configurada, puedes usarla en un controlador.

// Controllers/ProductosController.cs
public class ProductosController : Controller
{
    private readonly IProductoService _productoService;

    public ProductosController(IProductoService productoService)
    {
        _productoService = productoService;
    }

    public IActionResult Index()
    {
        var productos = _productoService.ObtenerTodos();
        return View(productos);
    }

    public IActionResult Details(int id)
    {
        var producto = _productoService.ObtenerPorId(id);
        if (producto == null)
        {
            return NotFound();
        }
        return View(producto);
    }

    [HttpPost]
    public IActionResult Create(Producto producto)
    {
        if (ModelState.IsValid)
        {
            _productoService.CrearProducto(producto);
            return RedirectToAction(nameof(Index));
        }
        return View(producto);
    }

    // Otros métodos para actualizar y eliminar...
}

7. Vistas

Finalmente, puedes crear vistas para mostrar los productos, como Index.cshtml, Details.cshtml, y Create.cshtml, donde puedes mostrar los datos y permitir al usuario interactuar con la aplicación.

https://medium.com/@ImAnandPanchal/building-a-robust-net-c1a76430780a