¿Qué es ASP.NET Core MVC?

ASP.NET Core es un framework multi-plataforma, de código abierto y alta performance para desarrollar aplicaciones modernas, basadas en la nube e intercontectadas. Con ASP.NET Core puedes:

  • Desarrollar aplicaciones Web, servicios, aplicaciones IoT y backend móviles utilizando C#, F# o Visual Basic.NET
  • Usar tus herramientas favoritas de desarrollo en Windows, macOS, y Linux
  • Desplegar a la nube o de manera local
  • Ejecutar sobre .NET Core o el .NET Framework Full

Si hemos utilizado ASP.NET clásico antes, debemos aclarar que este es un framework nuevo que se ejecuta sobre varias plataformas (por ej: Windows, Linux y MacOs), que es muchisimo más rápido pero no incluye algunas cosas como por ejemplo Webforms (aunque incluye Razor Pages que es un remplazo más eficiente).

En el tema velocidad, es uno de los frameworks más rápidos y al ser open source se sigue trabajando para que su performance mejore aún más. (ver Benchmarks)

Cada versión ASP.NET tiene distintos modelos de trabajo para hacer las aplicaciones, en el ASP.NET clásico existía WebForms, MVC y Web Api (entre otros), en este existe MVC (Incluye Web Api) y Razor Pages. En este artículo nos vamos a enfocar en MVC.

Modelo Vista Controlador

ASP.NET Core MVC implementa el patrón Modelo Vista Controlador así que empecemos por ahí.

El patrón MVC es un patrón de diseño de software de la capa de presentación que separa los componentes de la solución en tres partes: modelo, vista y controlador 😀.

¿Por qué usar MVC?

Tener los componentes separados nos permite desarrollar más rápido y tambien mejora la mantenibilidad ya que cada modificación tiene un impacto menor en otras partes del sistema y al mismo tiempo, es más facil saber qué es lo que tengo que modificar.

El Modelo

El modelo es el que contiene los datos de la aplicación. También maneja los comportamientos fundamentales. Puede responder a solicitudes de información de otros objetos, responder solicitudes de cambio de estado de otros objetos e incluso notificar a los observadores (si corresponde) cuando su información interna cambie.

Así, si estamos haciendo un sistema de liquidación de sueldos podríamos tener como parte del modelo una clase Empleado.

En ASP.NET MVC el módelo son clases comunes escritas en .NET.

public class Empleado {
  public string NombreCompleto {get;set;}
  public DateTime FechaIngreso {get;set;}

  public int CalcularAntiguedad() {
    return (DateTime.Now - FechaIngreso).TotalDays / 365; // Antigüedad en años
  }
}

En entornos comunes utilizamos las mismas clases que el modelo de negocio. Si la cosa se pone compleja, se pueden utilizar ViewModels que son clases nuevas que hacemos para adaptar el modelo de negocio a la forma en la que lo queremos presentar. (Por ejemplo una clase que tenga los datos del empleado con las fechas en un formato espécifico).

La vista

La vista provee la interfaz gráfica con la que va a interfaccionar el usuario. Muestra el modelo de una forma que sea util para el usuario.

En ASP.NET MVC la vista se escribe en archivos con extensión CSHTML (para C#), VBHTML (para Visual Basic.NET) y FSHTML (para F#).

@model CoreApp1.Models.Empleado

@{
    ViewData["Title"] = "Crear";
}

<h2>@ViewData.Title</h2>

<h4>Empleado</h4>
<hr />
<div class="row">
    <div class="col-md-4">
        <form asp-action="Create">
            ...
        </form>
    </div>
</div>

<div>
    <a asp-action="Index">Volver a la lista</a>
</div>

@section Scripts {
    @{await Html.RenderPartialAsync("_ValidationScriptsPartial");}
}

Estos archivos utilizan HTML común junto con algunas expresiones adicionales que agrega ASP.NET MVC y que vamos a ver más adelante.

El controlador

El controlador es el que coordina la interacción entre ambos y los mantiene separados y desacoplados. En ASP.NET MVC es una clase cuyo nombre termina de Controller y muchas veces hereda de la clase base Controller.

public class EmpleadoController : Controller {
  public IActionResult Create()
  {
      return View();
  }
}

Los métodos del controlador los llamamos acciones porque representan las cosas que va a poder hacer el usuario con esa clase de módelo espécifica a la que el controlador se refiere (en este caso empleado, se puede crear un empleado).

Resumiendo en pocas palabras

Entonces en pocas palabras en MVC el módelo es una clase común, con datos de nuestro modelo de negocio y método, la vista, un html con algunas palabras más que agrega asp.net mvc y el controlador, una clase que tiene métodos para cada una de las acciones que pueda hacer el usuario en el sistema.

Algunas cosas que tenemos que saber de ASP.NET MVC

ASP.NET MVC puede ser diferente a la forma en la que venimos trabajando así que vamos a enumerar algunas características para entender más el framework.

ASP.NET MVC se maneja con convenciones

ASP.NET WebForms hacía muchas cosas por nosotros para mantener un modelo de desarrollo similar a Winforms. Esto implicaba que muchas veces el código HTML resultante era algo pesado o tenía que recurrir excesivamente al uso de cosas como el ViewState.

Con ASP.NET MVC no tenemos todas esas cosas hechas por nosotros, estamos más cerca del HTML generado pero eso no implica necesariamente que tengamos que hacer más trabajo.

Para evitarnos más trabajo ASP.NET MVC define ciertas convenciones: si nombramos los archivos de cierta manera, si los ponemos en ciertas carpetas el Framework va a saber que son, como procesarnos y nos va a ahorrar trabajo. Si vemos el ejemplo de Controller más arriba vamos a ver que todos los controladores se llaman con el sufijo Controller y heredan de Controller.

Los controladores van en la carpeta Controller. Las vistas van en la carpeta Views dentro de otra carpeta con el nombre del Controller.

Las URLs no se corresponden con archivos

En frameworks y lenguajes más tradicionales como ASP.NET WebForms, PHP, páginas web estáticas, etc. cada dirección de la página se corresponde con un archivo:

En ASP.NET MVC las URLs no están definidas por los nombres de archivo sino que utiliza algo llamado rutas.

Las rutas definen como resolvemos cuando el usuario pone cierta dirección en su navegador para que le abra cierta página. En ASP.NET Core MVC se definen en el archivo Startup.cs y si creamos el proyecto desde el Visual Studio o la herramienta de consola ya están definidas y no las tendremos que tocar:

    public class Startup
    {
        ...

        // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
        public void Configure(IApplicationBuilder app, IHostingEnvironment env)
        {
           ...

            app.UseMvc(routes =>
            {
                routes.MapRoute(
                    name: "default",
                    template: "{controller=Home}/{action=Index}/{id?}");
            });
        }
    }

Ya lo vamos a ver más en detalle cuando pasemos a un ejercicio práctico pero básicamente lo que dice el código anterior es que la si yo tengo una dirección: **https://misitio.com/Comida/Ver/1"

  • La primera parte después del dominio Comida va a buscar un controlador que se llame ComidaController
  • La siguiente parte Ver va a buscar un método dentro de ComidaController que se llame Ver. Recordemos que las acciones son los métodos del controlador.
  • La ultima parte, el 1 lo va a tomar como el id que le va a pasar al método Ver. El signo de pregunta ? hace sea opcional.
  • Home e Index son los valores por defecto lo que quiere decir que: si no pongo nada me va a abrir la acción Index del Controlador HomeController.

Entonces el nombre del controlador, sus métodos y sus paramétros me van a determinar como va a ser la dirección de cada página.

Los controladores pueden devolver vistas o datos codificados

Como dijimos anteriormente los nombres de método del Controlador nos definen las acciones, y parte de las direcciones de nuestra aplicación web.

  • Estas direcciones pueden devolver una vista:
public IActionResult Crear()
{
    return View();
}

lo que nos quiere decir que va a procesar el archivo CSHTML que esté Views/Comida/Crear.cshtml (veamos como la carpeta se llama igual que el Controlador).

  • O sino estas direcciones pueden devolver datos:
public string[] Obtener()
{
    return new string[] {"Alfajor", "Chupetin", "Chocolate", "Helado"};
}

En este caso nos devuelve esa lista de cadenas de texto. ¿En que formato? por defecto en ASP.NET Core es en formato JSON. Pero se pueden agregar otros formatos como XML.

También puedo devolver objetos:

public List<Comida> Listar()
{
    return repositorioComidas.Listar();
}

En este caso estoy devolviendo objetos directamente, los objetos se codifican a JSON o a XML y pueden ser leidos desde el cliente movil, javascript, etc.

Eso es todo por ahora puede que algunas cosas no se entiendan todavía por lo que recomiendo que se vaya jugando un poco con hacer un proyecto nuevo de estas características.

En los proximos artículos estaremos viendo unos ejemplos prácticos.