Inyección de Dependencias en ASP.NET Core: Un cliente SMTP (I)

En este artículo, vamos a construir una aplicación ASP.NET Core utilizando la inyección de dependencias para un cliente de correo electrónico (SMTP) llamado MailService. Proporcionaremos ejemplos de código extensos y explicaciones detalladas para cada paso, asegurando que cualquier programador pueda seguir estos pasos y obtener una aplicación funcional en Visual Studio.

Paso 1: Crear el Proyecto ASP.NET Core

1. Abre Visual Studio y selecciona Create a new project.
2. Elige ASP.NET Core Web Application y haz clic en Next.
3. Nombra tu proyecto (por ejemplo, EmailServiceApp) y selecciona una ubicación para guardarlo. Haz clic en Create.
4. En la siguiente ventana, selecciona ASP.NET Core Web App (Model-View-Controller) y asegúrate de que la versión de .NET Core sea 3.0 o superior. Haz clic en Create.

 

Paso 2: Configurar el Contenedor de Servicios

2.1 Definir la Interfaz y la Implementación del Servicio de Correo

Primero, vamos a definir una interfaz IMailService que describa el contrato del servicio de correo y luego implementar esta interfaz en una clase MailService.

Crear la Interfaz IMailService

1. En el Explorador de Soluciones, haz clic derecho en el proyecto y selecciona Add > New Folder. Nombra la carpeta Services.
2. Haz clic derecho en la carpeta Services y selecciona Add > Class. Nombra la clase IMailService.cs.
3. Define la interfaz IMailService como se muestra a continuación:

namespace EmailServiceApp.Services
{
    public interface IMailService
    {
        void SendEmail(string to, string subject, string body);
    }
}

En este código, IMailService define un método SendEmail que toma tres parámetros: to (destinatario del correo), subject (asunto del correo) y body (cuerpo del correo). Esta interfaz actúa como un contrato que cualquier implementación de servicio de correo debe cumplir.

Implementar la Clase MailService

1. Haz clic derecho en la carpeta Services y selecciona Add > Class. Nombra la clase MailService.cs.
2. Implementa la clase MailService como se muestra a continuación:

using System;

namespace EmailServiceApp.Services
{
    public class MailService : IMailService
    {
        private readonly string _smtpServer;
        private readonly int _smtpPort;

        public MailService(string smtpServer, int smtpPort)
        {
            _smtpServer = smtpServer;
            _smtpPort = smtpPort;
        }

        public void SendEmail(string to, string subject, string body)
        {
            // Aquí iría la lógica para enviar el correo
            Console.WriteLine($"Enviando correo a {to} con asunto {subject} usando {_smtpServer}:{_smtpPort}");
        }
    }
}

En esta implementación, MailService acepta parámetros para el servidor SMTP y el puerto en su constructor. Estos valores se almacenan en campos privados y se utilizan en el método SendEmail para enviar el correo electrónico. Por simplicidad, estamos utilizando Console.WriteLine para simular el envío de correo.

2.2 Registrar el Servicio en Startup.cs

Para que el contenedor de servicios pueda proporcionar MailService cuando se necesite, debemos registrarlo en el método ConfigureServices de Startup.cs.

1. Abre el archivo Startup.cs y localiza el método ConfigureServices.
2. Registra MailService como un servicio transitorio (transient):

public void ConfigureServices(IServiceCollection services)
{
    services.AddControllersWithViews();
    
    // Registro del servicio de correo
    services.AddTransient<IMailService>(provider => new MailService("smtp.example.com", 25));
}

En este código, services.AddTransient registra MailService como un servicio transitorio que implementa IMailService. Esto significa que se creará una nueva instancia de MailService cada vez que se inyecte IMailService.

Nota: En algunas situaciones, es necesario registrar un servicio con parámetros específicos que no pueden ser directamente configurados a través de la inyección de dependencias estándar. En tales casos, se utiliza una expresión lambda para proporcionar una configuración personalizada: services.AddTransient<IMailService>(provider => new MailService("smtp.example.com", 25));.

Explicación sobre AddTransient<IMailService>(provider => new MailService("smtp.example.com", 25)):

• AddTransient<IMailService>(provider => new MailService("smtp.example.com", 25)) utiliza una expresión lambda para registrar el servicio.
• provider es una instancia de IServiceProvider que puede ser utilizada para resolver dependencias adicionales si es necesario.
• new MailService("smtp.example.com", 25) crea una nueva instancia de MailService con parámetros específicos, en este caso, la dirección del servidor SMTP y el puerto.
• Este método es útil cuando los parámetros del constructor no pueden ser obtenidos a través del contenedor de servicios, como valores de configuración específicos que no están inyectados directamente.

Explicación sobre provider:

• provider es una instancia de la interfaz IServiceProvider que es proporcionada por ASP.NET Core para resolver dependencias dentro del contenedor de servicios.
• Cuando se utiliza una expresión lambda para registrar un servicio, como en el método con Expresión Lambda, se puede acceder a provider dentro de la lambda.
• Esto permite resolver dependencias adicionales dentro de la expresión lambda si es necesario, lo que proporciona flexibilidad para configurar el servicio de manera más dinámica.

• Sin embargo, es importante usar esta funcionalidad con precaución para mantener la claridad y la legibilidad del código.

 

Paso 3: Inyectar y Usar el Servicio en un Controlador

3.1 Crear el Controlador

1. Haz clic derecho en la carpeta Controllers y selecciona Add > Controller....
2. Selecciona MVC Controller - Empty y haz clic en Add. Nombra el controlador HomeController.

3.2 Inyectar el Servicio en el Controlador

1. Abre HomeController.cs y modifica el controlador para inyectar IMailService a través del constructor:

using EmailServiceApp.Services;
using Microsoft.AspNetCore.Mvc;

namespace EmailServiceApp.Controllers
{
    public class HomeController : Controller
    {
        private readonly IMailService _mailService;

        public HomeController(IMailService mailService)
        {
            _mailService = mailService;
        }

        public IActionResult Index()
        {
            // Uso del servicio de correo para enviar un correo de prueba
            _mailService.SendEmail("test@example.com", "Test Subject", "This is a test email.");
            
            return View();
        }
    }
}

En este código, HomeController tiene una dependencia de IMailService, que se inyecta a través del constructor. Luego, en la acción Index, utilizamos _mailService para enviar un correo electrónico de prueba.

 

Paso 4: Configurar la Vista

1. Haz clic derecho en la carpeta Views y selecciona Add > New Folder. Nombra la carpeta Home.
2. Haz clic derecho en la carpeta Home y selecciona Add > New Item.... Selecciona Razor View y nombra la vista Index.cshtml.

4.1 Crear la Vista Index.cshtml

1. Abre Index.cshtml y añade contenido básico:

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

<h1>Welcome to Email Service App</h1>
<p>The email has been sent successfully. Check your console for details.</p>

En esta vista, simplemente mostramos un mensaje de bienvenida y una indicación de que el correo se ha enviado correctamente.

 

Paso 5: Ejecutar y Probar la Aplicación

5.1 Configuración de la Ruta Predeterminada

Para asegurarnos de que HomeController se utilice como la página de inicio, debemos configurar la ruta predeterminada en Startup.cs.

1. Abre Startup.cs y modifica el método Configure para establecer la ruta predeterminada:

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?}");
    });
}

En este código, endpoints.MapControllerRoute establece HomeController y su acción Index como la ruta predeterminada.

5.2 Ejecutar la Aplicación

1. Haz clic en el botón Run o presiona F5 en Visual Studio para iniciar la aplicación.
2. Una vez que la aplicación esté en ejecución, abre el navegador web y navega a https://localhost:5001 (o la URL que Visual Studio haya asignado a tu proyecto).

5.3 Verificar la Salida

1. Si todo está configurado correctamente, deberías ver la página de inicio con el mensaje de bienvenida.
2. Abre la consola de Visual Studio (puedes encontrarla en la pestaña Output en la parte inferior de la ventana de Visual Studio) y verifica que el mensaje del servicio de correo se haya impreso, indicando que el correo electrónico se ha "enviado":

Enviando correo a test@example.com con asunto Test Subject usando smtp.example.com:25

Este mensaje confirma que el servicio de correo se ha ejecutado correctamente y se ha utilizado la configuración proporcionada.

 

Conclusión

Este artículo ha proporcionado una guía detallada y paso a paso sobre cómo configurar una aplicación ASP.NET Core utilizando la inyección de dependencias para un servicio de correo electrónico (MailService). Hemos cubierto desde la configuración del contenedor de servicios hasta la inyección y uso del servicio en un controlador, proporcionando ejemplos de código extensos y explicaciones detalladas para asegurar que cualquier programador pueda seguir estos pasos y obtener una aplicación funcional en Visual Studio.

Puntos Clave

1. Creación del Proyecto: Iniciamos con la creación de un proyecto ASP.NET Core en Visual Studio.
2. Configuración del Contenedor de Servicios: Definimos una interfaz IMailService y su implementación MailService, y registramos MailService en el contenedor de servicios como un servicio transitorio.
3. Inyección de Dependencias: Inyectamos IMailService en el HomeController y utilizamos el servicio para enviar un correo electrónico de prueba.
4. Configuración de la Vista: Configuramos una vista Razor para mostrar un mensaje de éxito.
5. Ejecución y Prueba: Ejecutamos la aplicación y verificamos la salida en la consola para asegurarnos de que el correo electrónico se ha enviado correctamente.

Recuerda que la inyección de dependencias es una práctica esencial para crear aplicaciones modulares y mantenibles. Al seguir estos pasos, no solo habrás creado una aplicación funcional, sino que también habrás aprendido principios clave de diseño que te ayudarán en proyectos futuros.

Próximos Pasos

Para ampliar este proyecto, en el próximo artículo de este Blog Inyección de Dependencias en ASP.NET Core: Un cliente SMTP (II), desarrollaremos las siguientes mejoras:

1. Autenticación y Autorización: Agregar autenticación y autorización para proteger tu aplicación.
2. Configuración de SMTP Real: Configurar un servidor SMTP real y utiliza una biblioteca como System.Net.Mail para enviar correos electrónicos reales.
3. Pruebas Unitarias: Implementar pruebas unitarias para asegurar que tu servicio de correo y otras partes de tu aplicación funcionen correctamente.