Introducción a ASP.NET Core

ASP.NET Core representa la evolución moderna del framework web de Microsoft, diseñado para crear aplicaciones web y APIs robustas, escalables y multiplataforma. A diferencia de las versiones anteriores de ASP.NET, ASP.NET Core es completamente de código abierto, funciona en Windows, macOS y Linux, y está optimizado para el desarrollo de aplicaciones modernas en la nube. Para un desarrollador de C#, dominar ASP.NET Core abre las puertas al desarrollo web profesional y te permite crear desde simples sitios web hasta complejas aplicaciones empresariales.

En este artículo exploraremos los conceptos fundamentales de ASP.NET Core, su arquitectura, los diferentes tipos de aplicaciones que puedes crear, y cómo configurar tu primer proyecto. Aprenderás sobre el patrón MVC (Modelo-Vista-Controlador), el sistema de inyección de dependencias, y cómo ASP.NET Core maneja las peticiones HTTP. Este conocimiento te preparará para crear aplicaciones web dinámicas y servicios web que pueden servir tanto a navegadores web como a aplicaciones móviles.

¿Qué es ASP.NET Core?

ASP.NET Core es un framework de desarrollo web gratuito, de código abierto y multiplataforma para construir aplicaciones web modernas y servicios web. Es la reimplementación completa de ASP.NET Framework, diseñada desde cero para ser más rápida, más ligera y más flexible.

Características principales

Característica	Descripción
Multiplataforma	Ejecuta en Windows, macOS, Linux y en contenedores
Alto rendimiento	Optimizado para velocidad y eficiencia de memoria
Código abierto	Disponible en GitHub con licencia MIT
Modular	Sistema de paquetes NuGet que permite incluir solo lo necesario
Integración nativa con la nube	Soporte nativo para despliegue en Azure, Docker y Kubernetes
Inyección de dependencias	Sistema DI integrado desde el núcleo del framework

Arquitectura de ASP.NET Core

ASP.NET Core utiliza una arquitectura basada en middleware que procesa las peticiones HTTP a través de un pipeline configurable:

// Ejemplo básico del pipeline de middleware
public class Startup
{
    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
    {
        // Cada Use() añade un middleware al pipeline
        app.UseRouting();
        app.UseAuthentication();
        app.UseAuthorization();
        
        app.UseEndpoints(endpoints =>
        {
            endpoints.MapControllers();
        });
    }
}

Tipos de aplicaciones ASP.NET Core

ASP.NET Core permite crear diferentes tipos de aplicaciones web según tus necesidades:

Aplicaciones MVC (Modelo-Vista-Controlador)

Las aplicaciones MVC siguen el patrón arquitectónico que separa la lógica de negocio (Modelo), la presentación (Vista) y el control de flujo (Controlador):

// Controlador ejemplo
public class HomeController : Controller
{
    public IActionResult Index()
    {
        var modelo = new HomeViewModel
        {
            Mensaje = "¡Bienvenido a ASP.NET Core!",
            Fecha = DateTime.Now
        };
        
        return View(modelo);
    }
}

// Modelo ejemplo
public class HomeViewModel
{
    public string Mensaje { get; set; }
    public DateTime Fecha { get; set; }
}

Web APIs

Las Web APIs permiten crear servicios que devuelven datos en formato JSON o XML para ser consumidos por aplicaciones móviles, SPAs o otros servicios:

[ApiController]
[Route("api/[controller]")]
public class ProductosController : ControllerBase
{
    [HttpGet]
    public IActionResult ObtenerProductos()
    {
        var productos = new[]
        {
            new { Id = 1, Nombre = "Laptop", Precio = 1200.00 },
            new { Id = 2, Nombre = "Mouse", Precio = 25.50 }
        };
        
        return Ok(productos);
    }
    
    [HttpPost]
    public IActionResult CrearProducto([FromBody] Producto producto)
    {
        // Lógica para crear el producto
        return CreatedAtAction(nameof(ObtenerProductos), producto);
    }
}

Razor Pages

Razor Pages proporciona un modelo más simple para crear páginas web, ideal para aplicaciones que no requieren la complejidad completa del patrón MVC:

// Archivo: Pages/Contacto.cshtml.cs
public class ContactoModel : PageModel
{
    [BindProperty]
    public string Nombre { get; set; }
    
    [BindProperty]
    public string Email { get; set; }
    
    public void OnGet()
    {
        // Lógica para mostrar la página
    }
    
    public IActionResult OnPost()
    {
        if (ModelState.IsValid)
        {
            // Procesar el formulario
            return RedirectToPage("Gracias");
        }
        
        return Page();
    }
}

Configuración y servicios

ASP.NET Core utiliza un sistema de configuración flexible y un contenedor de inyección de dependencias integrado:

Configuración de servicios

public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        // Configurar servicios MVC
        services.AddControllersWithViews();
        
        // Configurar base de datos
        services.AddDbContext<ApplicationDbContext>(options =>
            options.UseSqlServer(connectionString));
            
        // Registrar servicios personalizados
        services.AddScoped<IProductoService, ProductoService>();
        services.AddSingleton<IConfiguracion, ConfiguracionService>();
    }
}

Inyección de dependencias

El sistema de DI permite inyectar servicios en controladores y otros componentes:

public class ProductosController : Controller
{
    private readonly IProductoService _productoService;
    private readonly ILogger<ProductosController> _logger;
    
    public ProductosController(
        IProductoService productoService,
        ILogger<ProductosController> logger)
    {
        _productoService = productoService;
        _logger = logger;
    }
    
    public async Task<IActionResult> Index()
    {
        _logger.LogInformation("Obteniendo lista de productos");
        var productos = await _productoService.ObtenerTodosAsync();
        return View(productos);
    }
}

Routing y manejo de peticiones

ASP.NET Core utiliza un sistema de enrutamiento flexible que mapea URLs a acciones de controlador:

Enrutamiento por convención

app.UseRouting();
app.UseEndpoints(endpoints =>
{
    endpoints.MapControllerRoute(
        name: "default",
        pattern: "{controller=Home}/{action=Index}/{id?}");
});

Enrutamiento por atributos

[Route("productos")]
public class ProductosController : Controller
{
    [HttpGet]
    public IActionResult Lista()
    {
        return View();
    }
    
    [HttpGet("{id:int}")]
    public IActionResult Detalle(int id)
    {
        return View();
    }
    
    [HttpPost("crear")]
    public IActionResult Crear([FromBody] Producto producto)
    {
        return View();
    }
}

Middleware personalizado

Puedes crear middleware personalizado para manejar aspectos transversales como logging, autenticación o manejo de errores:

public class LoggingMiddleware
{
    private readonly RequestDelegate _next;
    private readonly ILogger<LoggingMiddleware> _logger;
    
    public LoggingMiddleware(RequestDelegate next, ILogger<LoggingMiddleware> logger)
    {
        _next = next;
        _logger = logger;
    }
    
    public async Task InvokeAsync(HttpContext context)
    {
        _logger.LogInformation($"Petición: {context.Request.Method} {context.Request.Path}");
        
        await _next(context);
        
        _logger.LogInformation($"Respuesta: {context.Response.StatusCode}");
    }
}

// Registro del middleware
public void Configure(IApplicationBuilder app)
{
    app.UseMiddleware<LoggingMiddleware>();
    // Otros middleware...
}

Configuración de la aplicación

ASP.NET Core utiliza un sistema de configuración jerárquico que puede leer desde múltiples fuentes:

public class Startup
{
    private readonly IConfiguration _configuration;
    
    public Startup(IConfiguration configuration)
    {
        _configuration = configuration;
    }
    
    public void ConfigureServices(IServiceCollection services)
    {
        // Leer configuración
        var cadenaConexion = _configuration.GetConnectionString("DefaultConnection");
        var configuracionApi = _configuration.GetSection("ApiSettings");
        
        services.Configure<ApiSettings>(_configuration.GetSection("ApiSettings"));
    }
}

// Archivo appsettings.json
{
  "ConnectionStrings": {
    "DefaultConnection": "Server=localhost;Database=MiApp;Trusted_Connection=true"
  },
  "ApiSettings": {
    "BaseUrl": "https://api.ejemplo.com",
    "Timeout": 30
  }
}

Manejo de errores y logging

ASP.NET Core proporciona un sistema robusto para el manejo de errores y logging:

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    if (env.IsDevelopment())
    {
        app.UseDeveloperExceptionPage();
    }
    else
    {
        app.UseExceptionHandler("/Error");
        app.UseHsts();
    }
}

// Controlador para manejo de errores
public class ErrorController : Controller
{
    private readonly ILogger<ErrorController> _logger;
    
    public ErrorController(ILogger<ErrorController> logger)
    {
        _logger = logger;
    }
    
    [Route("/Error")]
    public IActionResult Error()
    {
        var requestId = Activity.Current?.Id ?? HttpContext.TraceIdentifier;
        _logger.LogError("Error en la aplicación. RequestId: {RequestId}", requestId);
        
        return View(new ErrorViewModel { RequestId = requestId });
    }
}

Resumen

ASP.NET Core es un framework web moderno y potente que te permite crear aplicaciones web escalables y eficientes. Su arquitectura basada en middleware, el sistema de inyección de dependencias integrado, y su naturaleza multiplataforma lo convierten en una excelente opción para el desarrollo web moderno. Has aprendido sobre los diferentes tipos de aplicaciones que puedes crear (MVC, Web API, Razor Pages), cómo configurar servicios, manejar el enrutamiento y crear middleware personalizado. Este conocimiento te proporciona una base sólida para comenzar a desarrollar aplicaciones web profesionales con C#, preparándote para crear tanto sitios web interactivos como servicios web que pueden integrarse con aplicaciones móviles y otros sistemas.