El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
HOME Mis cursos Finalizados
◄ Anterior
◄

ASP.NET Core

Siguiente ►
►

ASP.NET Core es un framework de código abierto y multiplataforma para construir aplicaciones modernas basadas en la nube, como aplicaciones web, servicios web y APIs. En este módulo, aprenderás los conceptos fundamentales de ASP.NET Core, cómo configurar un proyecto, y cómo construir y desplegar aplicaciones web robustas y escalables.

Contenido

  1. Introducción a ASP.NET Core
  2. Configuración del Entorno de Desarrollo
  3. Creación de un Proyecto ASP.NET Core
  4. Estructura de un Proyecto ASP.NET Core
  5. Controladores y Rutas
  6. Vistas y Razor Pages
  7. Modelos y Enlace de Datos
  8. Inyección de Dependencias
  9. Manejo de Errores y Registro
  10. Despliegue de una Aplicación ASP.NET Core

Introducción a ASP.NET Core

ASP.NET Core es una reescritura completa de ASP.NET, diseñada para ser más modular, más ligera y más rápida. Algunas de sus características clave incluyen:

  • Multiplataforma: Funciona en Windows, macOS y Linux.
  • Alto rendimiento: Optimizado para un rendimiento superior.
  • Modularidad: Permite incluir solo los componentes necesarios.
  • Integración con herramientas modernas: Compatible con Docker, Kubernetes, y más.

Configuración del Entorno de Desarrollo

Para desarrollar aplicaciones ASP.NET Core, necesitas instalar el SDK de .NET Core y un editor de código. Aquí están los pasos para configurar tu entorno:

  1. Instalar .NET Core SDK:

  2. Instalar un Editor de Código:

    • Visual Studio: Una opción completa con muchas características.
    • Visual Studio Code: Un editor ligero y extensible.

  3. Verificar la Instalación:

    • Abre una terminal y ejecuta: 
      dotnet --version
    • Deberías ver la versión del SDK instalada.

Creación de un Proyecto ASP.NET Core

Para crear un nuevo proyecto ASP.NET Core, sigue estos pasos:

  1. Abre una terminal y navega al directorio donde deseas crear el proyecto.

  2. Ejecuta el siguiente comando:

    dotnet new mvc -n MiProyectoAspNetCore

    Esto creará un nuevo proyecto MVC en un directorio llamado MiProyectoAspNetCore.

  3. Navega al directorio del proyecto:

    cd MiProyectoAspNetCore

  4. Ejecuta el proyecto:

    dotnet run

    Abre un navegador web y navega a http://localhost:5000 para ver la aplicación en funcionamiento.

Estructura de un Proyecto ASP.NET Core

Un proyecto ASP.NET Core tiene una estructura específica. Aquí hay una descripción de los directorios y archivos más importantes:

  • Controllers: Contiene los controladores que manejan las solicitudes HTTP.
  • Views: Contiene las vistas que se renderizan en respuesta a las solicitudes.
  • Models: Contiene las clases de modelo que representan los datos de la aplicación.
  • wwwroot: Contiene archivos estáticos como CSS, JavaScript e imágenes.
  • Startup.cs: Configura los servicios y el pipeline de la aplicación.
  • Program.cs: Configura y arranca la aplicación.

Controladores y Rutas

Los controladores son clases que manejan las solicitudes HTTP y devuelven respuestas. Aquí hay un ejemplo de un controlador simple:

using Microsoft.AspNetCore.Mvc;

namespace MiProyectoAspNetCore.Controllers
{
    public class HomeController : Controller
    {
        public IActionResult Index()
        {
            return View();
        }

        public IActionResult About()
        {
            ViewData["Message"] = "Your application description page.";
            return View();
        }
    }
}

Las rutas definen cómo se asignan las URL a los controladores y acciones. La configuración de rutas se encuentra en Startup.cs:

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

    app.UseHttpsRedirection();
    app.UseStaticFiles();
    app.UseCookiePolicy();

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

Vistas y Razor Pages

Las vistas son plantillas que se utilizan para generar HTML dinámico. ASP.NET Core utiliza Razor como motor de vistas. Aquí hay un ejemplo de una vista Razor:

@{
    ViewData["Title"] = "Home Page";
}

<div class="text-center">
    <h1 class="display-4">Welcome</h1>
    <p>Learn how to build ASP.NET apps with free training courses.</p>
</div>

Modelos y Enlace de Datos

Los modelos representan los datos de la aplicación. Aquí hay un ejemplo de un modelo simple:

public class Producto
{
    public int Id { get; set; }
    public string Nombre { get; set; }
    public decimal Precio { get; set; }
}

El enlace de datos es el proceso de tomar datos de una solicitud HTTP y asignarlos a un modelo. ASP.NET Core facilita esto automáticamente.

Inyección de Dependencias

ASP.NET Core tiene soporte integrado para la inyección de dependencias (DI). Aquí hay un ejemplo de cómo registrar y usar un servicio:

  1. Registrar el servicio en Startup.cs:

    public void ConfigureServices(IServiceCollection services)
{
    services.AddTransient<IMiServicio, MiServicio>();
    services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_2);
}

  2. Usar el servicio en un controlador:

    public class HomeController : Controller
{
    private readonly IMiServicio _miServicio;

    public HomeController(IMiServicio miServicio)
    {
        _miServicio = miServicio;
    }

    public IActionResult Index()
    {
        var datos = _miServicio.ObtenerDatos();
        return View(datos);
    }
}

Manejo de Errores y Registro

ASP.NET Core proporciona mecanismos para manejar errores y registrar eventos. Aquí hay un ejemplo de cómo configurar el manejo de errores:

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

    app.UseHttpsRedirection();
    app.UseStaticFiles();
    app.UseCookiePolicy();

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

Para registrar eventos, puedes usar el servicio de registro integrado:

public class HomeController : Controller
{
    private readonly ILogger<HomeController> _logger;

    public HomeController(ILogger<HomeController> logger)
    {
        _logger = logger;
    }

    public IActionResult Index()
    {
        _logger.LogInformation("Index page visited.");
        return View();
    }
}

Despliegue de una Aplicación ASP.NET Core

Para desplegar una aplicación ASP.NET Core, puedes usar varios métodos, incluyendo:

  • Azure App Service: Una plataforma de nube para desplegar aplicaciones web.
  • Docker: Contenedores para empaquetar y desplegar aplicaciones.
  • IIS: Servidor web de Microsoft para aplicaciones ASP.NET.

Despliegue en Azure App Service

  1. Crear un App Service en Azure:

    • Ve al portal de Azure y crea un nuevo App Service.

  2. Publicar la aplicación desde Visual Studio:

    • Haz clic derecho en el proyecto y selecciona "Publicar".
    • Selecciona "Azure" y sigue las instrucciones para desplegar la aplicación.

Despliegue con Docker

  1. Crear un archivo Dockerfile:

    FROM mcr.microsoft.com/dotnet/core/aspnet:3.1 AS base
WORKDIR /app
EXPOSE 80

FROM mcr.microsoft.com/dotnet/core/sdk:3.1 AS build
WORKDIR /src
COPY ["MiProyectoAspNetCore/MiProyectoAspNetCore.csproj", "MiProyectoAspNetCore/"]
RUN dotnet restore "MiProyectoAspNetCore/MiProyectoAspNetCore.csproj"
COPY . .
WORKDIR "/src/MiProyectoAspNetCore"
RUN dotnet build "MiProyectoAspNetCore.csproj" -c Release -o /app/build

FROM build AS publish
RUN dotnet publish "MiProyectoAspNetCore.csproj" -c Release -o /app/publish

FROM base AS final
WORKDIR /app
COPY --from=publish /app/publish .
ENTRYPOINT ["dotnet", "MiProyectoAspNetCore.dll"]

  2. Construir y ejecutar el contenedor Docker:

    docker build -t mi-proyecto-aspnetcore .
docker run -d -p 8080:80 mi-proyecto-aspnetcore

Conclusión

En este módulo, has aprendido los conceptos fundamentales de ASP.NET Core, cómo configurar un proyecto, y cómo construir y desplegar aplicaciones web. ASP.NET Core es una herramienta poderosa y flexible para desarrollar aplicaciones modernas y escalables. Con los conocimientos adquiridos, estás listo para explorar más a fondo y construir aplicaciones web robustas.

En el siguiente módulo, profundizaremos en la creación de aplicaciones móviles con Xamarin. ¡Sigue adelante y sigue aprendiendo!

◄ Anterior
◄
Siguiente ►
►
El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
© Copyright 2024. Todos los derechos reservados