Controladores MVC

En ASP.NET MVC (Model-View-Controller), los controladores son la parte del patrón que gestiona las solicitudes del usuario, procesa la lógica de la aplicación y devuelve la respuesta correspondiente, generalmente en forma de vista. Los controladores son clases de C# que derivan de la clase base Controller y tienen varios métodos y características para manejar peticiones HTTP.

Aquí te explico los principales tipos de controladores y opciones, junto con ejemplos para cada uno.

---

1. Controladores Básicos

Un controlador básico hereda de la clase Controller y contiene métodos de acción que responden a solicitudes HTTP específicas. Los métodos de acción generalmente devuelven un tipo ActionResult, que representa el resultado de una acción.

using Microsoft.AspNetCore.Mvc;

public class HomeController : Controller
{
    public IActionResult Index()
    {
        return View();
    }

    public IActionResult About()
    {
        return Content("About page content.");
    }
}

• Index: Acción que devuelve una vista (normalmente el archivo Index.cshtml en la carpeta Views/Home).
• About: Acción que devuelve texto directo con Content.

---

2. Métodos de Acción con Parámetros

Los métodos de acción pueden aceptar parámetros que se pasan en la URL o mediante una solicitud HTTP. ASP.NET MVC enlaza automáticamente estos parámetros con los valores de la URL o el formulario.

public class ProductController : Controller
{
    public IActionResult Details(int id)
    {
        // Buscar el producto con el ID proporcionado
        var product = ProductRepository.GetProductById(id);
        if (product == null)
        {
            return NotFound(); // Devuelve un error 404 si no se encuentra el producto
        }
        return View(product); // Devuelve la vista con el producto encontrado
    }
}

• URL: /Product/Details/5
• El valor 5 se enlaza al parámetro id de la acción.

---

3. Verbos HTTP en Métodos de Acción

Los controladores pueden diferenciar acciones basadas en el verbo HTTP (GET, POST, PUT, DELETE). Esto es útil para diseñar APIs RESTful.

public class AccountController : Controller
{
    [HttpGet]
    public IActionResult Login()
    {
        return View();
    }

    [HttpPost]
    public IActionResult Login(LoginViewModel model)
    {
        if (ModelState.IsValid)
        {
            // Procesa el login
            return RedirectToAction("Index", "Home");
        }
        return View(model);
    }
}

• [HttpGet]: Solo permite el acceso a través de solicitudes GET (para mostrar la página de login).
• [HttpPost]: Solo permite el acceso a través de solicitudes POST (para enviar las credenciales de login).

---

4. Devolución de Diferentes Tipos de Resultados

Los métodos de acción pueden devolver distintos tipos de resultados:

• ViewResult: Renderiza una vista.
• ContentResult: Devuelve contenido simple (texto).
• JsonResult: Devuelve datos en formato JSON (útil para APIs).
• RedirectResult: Redirige a otra acción o URL.
• FileResult: Devuelve un archivo para descargar.

public class FileController : Controller
{
    public IActionResult GetFile()
    {
        var filePath = Path.Combine("wwwroot/files", "example.pdf");
        var bytes = System.IO.File.ReadAllBytes(filePath);
        return File(bytes, "application/pdf", "example.pdf");
    }

    public JsonResult GetJsonData()
    {
        var data = new { Name = "Product", Price = 25.50 };
        return Json(data);
    }
}

---

5. Controladores Asíncronos

Los controladores en ASP.NET MVC pueden ser asíncronos. Esto permite manejar operaciones de larga duración sin bloquear el hilo principal.

public class DataController : Controller
{
    public async Task<IActionResult> GetDataAsync()
    {
        var data = await DataService.GetDataAsync();
        return View(data);
    }
}

• GetDataAsync: Este método de acción es asíncrono y espera hasta que GetDataAsync complete su operación antes de devolver la vista.

---

6. Uso de Dependencias en Controladores (Inyección de Dependencias)

En ASP.NET MVC, puedes inyectar servicios en los controladores a través de su constructor. Esto sigue el patrón de Inversión de Control (IoC), lo que facilita la prueba y el mantenimiento del código.

public class OrderController : Controller
{
    private readonly IOrderService _orderService;

    public OrderController(IOrderService orderService)
    {
        _orderService = orderService;
    }

    public IActionResult List()
    {
        var orders = _orderService.GetAllOrders();
        return View(orders);
    }
}

---

7. Uso de Rutas Personalizadas

Puedes definir rutas personalizadas en ASP.NET MVC mediante atributos o en el archivo de configuración de rutas.

[Route("products/{category}/{id}")]
public class ProductController : Controller
{
    public IActionResult Details(string category, int id)
    {
        // Implementa la lógica para mostrar el producto
        return View();
    }
}

• URL: /products/electronics/3
• Los valores electronics y 3 se enlazan a los parámetros category e id.

---

8. Filtrado y Autorización en Controladores

ASP.NET MVC permite aplicar filtros, como Authorize, para restringir el acceso a ciertas acciones o controladores completos.

[Authorize]
public class DashboardController : Controller
{
    public IActionResult Index()
    {
        return View();
    }

    [AllowAnonymous]
    public IActionResult PublicInfo()
    {
        return View();
    }
}

• [Authorize]: Restringe el acceso a usuarios autenticados.
• [AllowAnonymous]: Permite el acceso sin autenticación (incluso dentro de un controlador autorizado).

---

9. Ejemplo Completo de Controlador

Aquí tienes un controlador con varias acciones y características combinadas:

using Microsoft.AspNetCore.Mvc;
using System.Collections.Generic;
using System.Threading.Tasks;

[Route("api/[controller]")]
public class ProductController : Controller
{
    private readonly IProductService _productService;

    public ProductController(IProductService productService)
    {
        _productService = productService;
    }

    [HttpGet]
    public async Task<IActionResult> GetAllProducts()
    {
        var products = await _productService.GetProductsAsync();
        return Ok(products);
    }

    [HttpGet("{id:int}")]
    public IActionResult GetProductById(int id)
    {
        var product = _productService.GetProductById(id);
        if (product == null)
        {
            return NotFound();
        }
        return Ok(product);
    }

    [HttpPost]
    public IActionResult AddProduct([FromBody] ProductModel model)
    {
        if (ModelState.IsValid)
        {
            _productService.AddProduct(model);
            return CreatedAtAction(nameof(GetProductById), new { id = model.Id }, model);
        }
        return BadRequest(ModelState);
    }

    [HttpDelete("{id:int}")]
    public IActionResult DeleteProduct(int id)
    {
        var success = _productService.DeleteProduct(id);
        if (!success)
        {
            return NotFound();
        }
        return NoContent();
    }
}

En este ejemplo:

• Rutas personalizadas y RESTful: Con Route y Http (GET, POST, DELETE).
• Asíncrono y sincrónico: Métodos GetAllProducts y GetProductById.
• Inyección de dependencias: IProductService en el constructor.
• Respuestas JSON: Con Ok, NotFound, CreatedAtAction, y BadRequest.

---

Estos son algunos de los conceptos y patrones más utilizados en los controladores de ASP.NET MVC. Con estas prácticas puedes crear controladores potentes y flexibles para manejar las diversas necesidades de tu aplicación.