ASP.NET Core en Visual Studio: Estructura de un Proyecto

Comprender la estructura de un proyecto ASP.NET Core es clave para aprovechar al máximo su potencial. ASP.NET Core organiza su estructura de carpetas y archivos para facilitar el desarrollo y la escalabilidad de aplicaciones modernas y robustas. En este artículo, desglosaremos cada carpeta y archivo que encontrarás al crear un proyecto ASP.NET Core en Visual Studio y explicaremos el rol de cada uno en el flujo de trabajo de la aplicación.

Crear un Proyecto ASP.NET Core en Visual Studio

Para comenzar, abriremos Visual Studio y crearemos un nuevo proyecto ASP.NET Core:

1. Abrir Visual Studio.
2. Seleccionar Crear un nuevo proyecto.
3. En Modelo de proyecto, seleccionar Aplicación Web ASP.NET Core.
4. Escoger .NET Core y la versión más reciente de ASP.NET Core.
5. Seleccionar la plantilla adecuada (en este caso, una Aplicación Web MVC (Modelo-Vista-Controlador).
6. Nombrar el proyecto y hacer clic en Crear.

Visual Studio generará automáticamente la estructura de carpetas y archivos base de ASP.NET Core, que analizaremos en detalle a continuación.

NombreDelProyecto
├── Controllers                // Controladores que gestionan la lógica de la aplicación
│   └── HomeController.cs      // Ejemplo de controlador
│
├── Models                     // Modelos de datos, que representan la estructura de los datos
│   └── EjemploModel.cs        // Ejemplo de modelo
│
├── Views                      // Vistas o plantillas de la interfaz de usuario
│   ├── Home                   // Carpeta de vistas para el controlador Home
│   │   └── Index.cshtml       // Ejemplo de vista para la acción Index del controlador Home
│   ├── Shared                 // Vistas compartidas entre varios controladores
│   │   └── _Layout.cshtml     // Plantilla principal de diseño de la aplicación
│   └── _ViewImports.cshtml    // Configuraciones de importación para las vistas
│   └── _ViewStart.cshtml      // Configuración de layout común para todas las vistas
│
├── wwwroot                    // Carpeta raíz pública de la aplicación para archivos estáticos
│   ├── css                    // Archivos CSS personalizados
│   │   └── site.css
│   ├── js                     // Archivos JavaScript personalizados
│   │   └── site.js
│   └── lib                    // Bibliotecas de terceros (Bootstrap, jQuery, etc.)
│       ├── bootstrap
│       └── jquery
│
├── appsettings.json           // Configuración de la aplicación (p. ej., cadenas de conexión)
├── Program.cs                 // Punto de entrada principal de la aplicación
└── Startup.cs                 // Configuración de servicios y pipeline de la aplicación

• CarpetaControllers: Almacena los controladores que gestionan la lógica de la aplicación y responden a las solicitudes de los usuarios.

• Carpeta Models: Aquí se definen los modelos de datos, es decir, las clases que representan los datos y, generalmente, incluyen validaciones y lógica de negocio.

• CarpetaViews: Contiene las vistas de la aplicación. Las vistas son las plantillas que se renderizan en el navegador del usuario y suelen estar en archivos .cshtml.

• Carpetawwwroot: Esta es la carpeta pública donde se colocan todos los archivos estáticos, como imágenes, CSS, JavaScript, fuentes y bibliotecas externas. Todo lo que se encuentra aquí es accesible directamente por los clientes (navegadores).

• Archivoappsettings.json: Archivo de configuración que define las configuraciones de la aplicación, como cadenas de conexión de bases de datos y otros ajustes de la aplicación.

• Archivos Program.cs y Startup.cs: Program.cs es el punto de entrada de la aplicación, donde se configura y ejecuta el host web. Startup.cs define la configuración y los servicios que usará la aplicación, así como la configuración del pipeline de middleware.

 

Estructura de un Proyecto ASP.NET Core MVC en Visual Studio

ASP.NET Core se organiza en un modelo de proyecto modular que facilita la organización del código, el manejo de dependencias y la escalabilidad. En Visual Studio, al crear un nuevo proyecto ASP.NET Core MVC, se genera una estructura con carpetas y archivos esenciales que forman la base de la aplicación.

Carpeta wwwroot

La carpeta wwwroot es la raíz pública de la aplicación. Todos los archivos estáticos (como CSS, JavaScript, imágenes, fuentes, etc.) que deben estar disponibles para los clientes se almacenan aquí. Es esencial para separar los archivos públicos del código del servidor, mejorando así la seguridad y organización.

• Carpeta css: Contiene archivos de estilos CSS que definen la apariencia de la aplicación.

• Carpeta js: Almacena los archivos JavaScript necesarios para la interactividad del lado del cliente.

• Carpeta lib: Esta carpeta, que se genera al usar la biblioteca de administradores de paquetes (por ejemplo, LibMan), almacena bibliotecas externas como Bootstrap y jQuery.

wwwroot
├── css
│   └── site.css       // Estilos personalizados
├── js
│   └── site.js        // Scripts personalizados
└── lib
    ├── bootstrap
    └── jquery         // Librerías de terceros

Carpeta Controllers

La carpeta Controllers contiene todos los controladores de la aplicación. Los controladores son responsables de gestionar las solicitudes de los usuarios, interactuar con los modelos y devolver las respuestas adecuadas (usualmente en forma de vistas o datos JSON).

Un controlador típico hereda de Controller y maneja rutas y acciones:

using Microsoft.AspNetCore.Mvc;

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

        public IActionResult About()
        {
            ViewData["Message"] = "Información sobre la aplicación.";
            return View();
        }
    }
}

Carpeta Views

La carpeta Views contiene las vistas o plantillas de la interfaz de usuario que se devuelven al navegador. Esta carpeta se organiza siguiendo la convención Views/{NombreDelControlador}/{NombreVista}.cshtml.

• Views/Shared: Contiene vistas que son compartidas entre varios controladores, como el _Layout.cshtml, que sirve como plantilla principal de la aplicación.

• _ViewImports.cshtml: Este archivo importa espacios de nombres y configuraciones globales para todas las vistas.

• _ViewStart.cshtml: Configura opciones comunes para todas las vistas. Generalmente, define la plantilla principal (_Layout.cshtml).

Views
├── Home
│   ├── Index.cshtml      // Vista para el método Index en HomeController
│   └── About.cshtml      // Vista para el método About en HomeController
├── Shared
│   └── _Layout.cshtml    // Layout principal de la aplicación
├── _ViewImports.cshtml
└── _ViewStart.cshtml

Carpeta Models

La carpeta Models contiene las clases de modelos, que representan los datos de la aplicación. Aquí se definen los modelos de datos, a menudo relacionados con entidades de bases de datos.

Un ejemplo de modelo simple:

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

Archivo Program.cs

El archivo Program.cs es el punto de entrada de la aplicación. Contiene el método Main, que configura y ejecuta el host de la aplicación ASP.NET Core.

Ejemplo de Program.cs:

using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.Hosting;

namespace MiAplicacion
{
    public class Program
    {
        public static void Main(string[] args)
        {
            CreateHostBuilder(args).Build().Run();
        }

        public static IHostBuilder CreateHostBuilder(string[] args) =>
            Host.CreateDefaultBuilder(args)
                .ConfigureWebHostDefaults(webBuilder =>
                {
                    webBuilder.UseStartup<Startup>();
                });
    }
}

Archivo Startup.cs

Startup.cs es el archivo de configuración principal de la aplicación, donde se definen los servicios y el middleware. Los métodos clave son ConfigureServices y Configure.

• ConfigureServices(IServiceCollection services): Configura los servicios necesarios para la aplicación.

• Configure(IApplicationBuilder app, IWebHostEnvironment env): Configura el pipeline de middleware de la aplicación.

Ejemplo de Startup.cs:

using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;

namespace MiAplicacion
{
    public class Startup
    {
        public void ConfigureServices(IServiceCollection services)
        {
            services.AddControllersWithViews();
        }

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

            app.UseHttpsRedirection();
            app.UseStaticFiles();
            app.UseRouting();
            app.UseAuthorization();

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

Archivos de Configuración (appsettings.json)

appsettings.json es el archivo de configuración principal de ASP.NET Core, donde se almacenan configuraciones como cadenas de conexión y opciones personalizadas. Puedes definir configuraciones específicas para distintos entornos (p. ej., appsettings.Development.json).

Ejemplo de appsettings.json:

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft": "Warning"
    }
  },
  "ConnectionStrings": {
    "MiBaseDeDatos": "Server=localhost;Database=MiDB;User=sa;Password=ContraseñaSegura;"
  }
}

Otras Carpetas y Archivos Comunes

Además de las carpetas y archivos principales mencionados anteriormente, un proyecto ASP.NET Core puede incluir varias otras carpetas y archivos que facilitan la organización del código, la configuración y la gestión de recursos. A continuación, se presentan algunas de las más comunes:

Carpeta Data

La carpeta Data se utiliza comúnmente para almacenar clases relacionadas con la gestión de datos. Esto incluye:

• Contextos de base de datos: Clases que heredan de DbContext (como ApplicationDbContext) que representan una sesión con la base de datos y permiten la consulta y el guardado de datos.
• Migrations: Si estás utilizando Entity Framework Core, aquí se pueden almacenar las migraciones que describen cómo evolucionar la estructura de la base de datos.

Data
├── ApplicationDbContext.cs
└── Migrations
    ├── 20220101010101_InitialCreate.cs
    └── ApplicationDbContextModelSnapshot.cs

Carpeta Services

Aunque no se crea por defecto, es una buena práctica añadir una carpeta Services para organizar la lógica de negocio. En esta carpeta, puedes crear clases que manejen operaciones específicas, como la interacción con APIs externas o la gestión de datos complejos.

Services
└── EmailService.cs

public class EmailService {
    public void SendEmail(string to, string subject, string body) {
        // Lógica para enviar un correo electrónico
    }
}

Carpeta ViewModels

A veces, se crea una carpeta ViewModels para contener clases que definen los modelos que se utilizan para la vista. Estas clases suelen estar diseñadas específicamente para las vistas y pueden incluir solo las propiedades necesarias para la presentación, a diferencia de los modelos que se utilizan en la lógica de la aplicación.

ViewModels
└── ProductViewModel.cs

public class ProductViewModel {
    public int Id { get; set; }
    public string Name { get; set; }
    public decimal Price { get; set; }
    public string Description { get; set; }
}

Carpeta Properties

La carpeta Properties incluye archivos de configuración para el proyecto, como el archivo launchSettings.json, que define cómo se ejecuta la aplicación en diferentes entornos (por ejemplo, IIS Express o Kestrel). Este archivo permite establecer variables de entorno y la URL de inicio.

Properties
└── launchSettings.json

{
    "profiles": {
        "IIS Express": {
            "commandName": "IISExpress",
            "launchBrowser": true,
            "environmentVariables": {
                "ASPNETCORE_ENVIRONMENT": "Development"
            }
        },
        "NombreDelProyecto": {
            "commandName": "Project",
            "launchBrowser": true,
            "applicationUrl": "http://localhost:5000;https://localhost:5001",
            "environmentVariables": {
                "ASPNETCORE_ENVIRONMENT": "Development"
            }
        }
    }
}

 

Conclusión

Comprender la estructura de un proyecto ASP.NET Core es esencial para desarrollar aplicaciones bien organizadas y fáciles de mantener. Cada carpeta y archivo cumple una función específica y aporta modularidad a la aplicación. Con esta guía detallada, puedes identificar el rol de cada componente en la estructura del proyecto, permitiéndote configurar y personalizar tu aplicación de manera efectiva en Visual Studio.