Microsoft.Extensions.DependencyInjection es una potente biblioteca proporcionada por Microsoft .NET para facilitar la Inversión de Dependencias (DI), un patrón de diseño de software que promueve el acoplamiento flexible y mejora la testabilidad en las aplicaciones. DI a menudo se implementa utilizando el contenedor DI incorporado en .NET Core o bibliotecas como Autofac y Unity. DI implica inyectar dependencias (objetos que una clase necesita) en una clase en lugar de que la clase cree sus dependencias. Esto se hace típicamente a través de un constructor, método o inyección de propiedades.

Contenedor de inyección de dependencias

1. Registro de Servicios: Las dependencias se registran en un contenedor DI, típicamente en la raíz de composición de la aplicación. Estos registros especifican cómo el contenedor debe crear y gestionar las dependencias.

2. Resolución de Dependencias: Cuando un componente solicita una dependencia, el contenedor DI resuelve la dependencia creando una instancia de un tipo registrado que utiliza un método de extensión.

Tipos de inyección de dependencia

• Inyección de Constructor: Los servicios registrados se proporcionan a una clase a través de su constructor, que es la forma más común y recomendada de DI.
• Inyección de Método: Los servicios se resuelven y pasan como parámetros a un método.
• Inyección de Propiedades: Los servicios singleton o servicios con un tiempo de vida limitado pueden asignarse a las propiedades de una clase. Sin embargo, este enfoque es menos común y a menudo se considera inferior a la inyección de constructor porque puede introducir dependencias ocultas.

Comprensión de los tiempos de vida en la inyección de dependencia (DI): Scoped, Transient, and Singleton

1. Limitado: Las dependencias limitadas se crean una vez por solicitud o ámbito de vida, lo que significa que el contenedor proporciona la misma instancia dentro de una sola solicitud u operación. Esta consistencia es particularmente útil en aplicaciones web, donde las dependencias limitadas ayudan a mantener una dependencia estable a lo largo de una solicitud web.
2. Transitorio: Las dependencias transitorias se instancian cada vez que se solicitan desde el contenedor. Esto implica que se genera una nueva instancia de una dependencia transitoria cada vez que se necesita. Típicamente, las dependencias transitorias se usan para servicios livianos, sin estado o componentes.
3. Singleton: Las dependencias singleton se instancian solo una vez y se comparten a lo largo de toda la vida de la aplicación. Esto asegura que se use la misma instancia de una dependencia singleton para todas las solicitudes a lo largo de la duración de la aplicación. Las dependencias singleton se emplean típicamente para servicios con estado o componentes que necesitan ser accesibles de manera universal en toda la aplicación.

Instalación del paquete Microsoft.Extensions.DependencyInjection

Para comenzar a usar la inyección de dependencias en un proyecto .NET Core, primero debe instalar el paquete Microsoft.Extensions.DependencyInjection. Esto se puede hacer a través de la Consola del Administrador de Paquetes NuGet en Visual Studio con el siguiente comando:

Install-Package Microsoft.Extensions.DependencyInjection

Captura de pantalla

Ejemplo: Inyección de dependencia básica

En este ejemplo, vamos a crear una aplicación de muestra (aplicación de consola) en la que utilizaremos un proveedor de servicios para resolver servicios e inyectarlos en nuestro programa.

using Microsoft.Extensions.DependencyInjection;
using System;

// Define a service interface
public interface IMessageService
{
    void SendMessage(string message);
}

// Implement the service interface
public class ConsoleMessageService : IMessageService
{
    public void SendMessage(string message)
    {
        Console.WriteLine(message); // Output the message to the console
    }
}

using Microsoft.Extensions.DependencyInjection;
using System;

// Define a service interface
public interface IMessageService
{
    void SendMessage(string message);
}

// Implement the service interface
public class ConsoleMessageService : IMessageService
{
    public void SendMessage(string message)
    {
        Console.WriteLine(message); // Output the message to the console
    }
}

Imports Microsoft.Extensions.DependencyInjection
Imports System

' Define a service interface
Public Interface IMessageService
	Sub SendMessage(ByVal message As String)
End Interface

' Implement the service interface
Public Class ConsoleMessageService
	Implements IMessageService

	Public Sub SendMessage(ByVal message As String) Implements IMessageService.SendMessage
		Console.WriteLine(message) ' Output the message to the console
	End Sub
End Class

Imports Microsoft.Extensions.DependencyInjection
Imports System

' Define a service interface
Public Interface IMessageService
	Sub SendMessage(ByVal message As String)
End Interface

' Implement the service interface
Public Class ConsoleMessageService
	Implements IMessageService

	Public Sub SendMessage(ByVal message As String) Implements IMessageService.SendMessage
		Console.WriteLine(message) ' Output the message to the console
	End Sub
End Class

El fragmento de código crea una interfaz IMessageService para enviar mensajes, como un contrato sobre cómo deben enviarse los mensajes. La clase ConsoleMessageService implementa esta interfaz utilizando Console.WriteLine para enviar mensajes. Esta separación permite que el concepto de enviar mensajes se cambie independientemente de cómo se envían, haciendo que el sistema sea flexible y manejable.

class Program
{
    static void Main(string[] args)
    {
        // Create a service provider
        var serviceProvider = new ServiceCollection()
            // Register the service implementation
            .AddTransient<IMessageService, ConsoleMessageService>()
            .BuildServiceProvider();

        // Resolve the service
        var messageService = serviceProvider.GetRequiredService<IMessageService>();

        // Use the service to send a message
        messageService.SendMessage("Hello, From Dependency Injection!");
    }
}

class Program
{
    static void Main(string[] args)
    {
        // Create a service provider
        var serviceProvider = new ServiceCollection()
            // Register the service implementation
            .AddTransient<IMessageService, ConsoleMessageService>()
            .BuildServiceProvider();

        // Resolve the service
        var messageService = serviceProvider.GetRequiredService<IMessageService>();

        // Use the service to send a message
        messageService.SendMessage("Hello, From Dependency Injection!");
    }
}

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		' Create a service provider
		Dim serviceProvider = (New ServiceCollection()).AddTransient(Of IMessageService, ConsoleMessageService)().BuildServiceProvider()

		' Resolve the service
		Dim messageService = serviceProvider.GetRequiredService(Of IMessageService)()

		' Use the service to send a message
		messageService.SendMessage("Hello, From Dependency Injection!")
	End Sub
End Class

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		' Create a service provider
		Dim serviceProvider = (New ServiceCollection()).AddTransient(Of IMessageService, ConsoleMessageService)().BuildServiceProvider()

		' Resolve the service
		Dim messageService = serviceProvider.GetRequiredService(Of IMessageService)()

		' Use the service to send a message
		messageService.SendMessage("Hello, From Dependency Injection!")
	End Sub
End Class

Este código configura un serviceProvider para gestionar los servicios. Registra ConsoleMessageService como la implementación para IMessageService, haciéndolo disponible para ser inyectado donde sea necesario. El método Main luego obtiene una instancia de IMessageService del serviceProvider y la utiliza para enviar un mensaje a la consola.

Salida: El programa imprime el mensaje de cadena "¡Hola, desde la Inversión de Dependencias!"

IronPDF: Biblioteca PDF de C#

IronPDF es una potente biblioteca para C# que simplifica el complejo proceso de generación de PDF, ofreciendo una amplia gama de características para la manipulación de PDF, incluyendo la capacidad de generar PDFs desde HTML, operar agregando texto a PDFs y editar PDFs con imágenes, crear documentos seguros, y mucho más.

Uso de IronPDF con inyección de dependencias

Para integrar la biblioteca IronPDF en una aplicación .NET Core aprovechando las características de la inyección de dependencias y los métodos de extensión con Microsoft.Extensions.DependencyInjection, puede proceder de la siguiente manera:

1. Crear una interfaz para definir su servicio de generación de PDF.
2. Implementar la interfaz.
3. Utilizar métodos de extensión para registrar el servicio en el contenedor de inversión de dependencias.
4. Inyectar el servicio en su aplicación según sea necesario.

Definir interfaz

Crear una interfaz para definir su servicio de generación de PDF.

public interface IPdfService
{
    void GeneratePdf(string baseUrl, string query, string filePath);
}

public interface IPdfService
{
    void GeneratePdf(string baseUrl, string query, string filePath);
}

Public Interface IPdfService
    Sub GeneratePdf(baseUrl As String, query As String, filePath As String)
End Interface

Public Interface IPdfService
    Sub GeneratePdf(baseUrl As String, query As String, filePath As String)
End Interface

Interfaz de implementación

Implementar la interfaz usando IronPDF para crear el archivo PDF.

using IronPdf;
using System;
using System.Web;

// Implement the PDF generation interface
public class IronPdfService : IPdfService
{
    public void GeneratePdf(string baseUrl, string query, string filePath)
    {
        License.LicenseKey = "Your-License-Key"; // Set the IronPDF license key
        string encodedQuery = HttpUtility.UrlEncode(query); // Encode the query string
        string fullUrl = $"{baseUrl}?query={encodedQuery}"; // Construct the full URL
        var renderer = new ChromePdfRenderer(); // Create a PDF renderer
        var pdf = renderer.RenderUrlAsPdf(fullUrl); // Render the PDF from the URL
        pdf.SaveAs(filePath); // Save the PDF to the specified file path
        Console.WriteLine($"PDF successfully created from: {fullUrl}");
        Console.WriteLine($"Saved to: {filePath}");
    }
}

using IronPdf;
using System;
using System.Web;

// Implement the PDF generation interface
public class IronPdfService : IPdfService
{
    public void GeneratePdf(string baseUrl, string query, string filePath)
    {
        License.LicenseKey = "Your-License-Key"; // Set the IronPDF license key
        string encodedQuery = HttpUtility.UrlEncode(query); // Encode the query string
        string fullUrl = $"{baseUrl}?query={encodedQuery}"; // Construct the full URL
        var renderer = new ChromePdfRenderer(); // Create a PDF renderer
        var pdf = renderer.RenderUrlAsPdf(fullUrl); // Render the PDF from the URL
        pdf.SaveAs(filePath); // Save the PDF to the specified file path
        Console.WriteLine($"PDF successfully created from: {fullUrl}");
        Console.WriteLine($"Saved to: {filePath}");
    }
}

Imports IronPdf
Imports System
Imports System.Web

' Implement the PDF generation interface
Public Class IronPdfService
	Implements IPdfService

	Public Sub GeneratePdf(ByVal baseUrl As String, ByVal query As String, ByVal filePath As String)
		License.LicenseKey = "Your-License-Key" ' Set the IronPDF license key
		Dim encodedQuery As String = HttpUtility.UrlEncode(query) ' Encode the query string
		Dim fullUrl As String = $"{baseUrl}?query={encodedQuery}" ' Construct the full URL
		Dim renderer = New ChromePdfRenderer() ' Create a PDF renderer
		Dim pdf = renderer.RenderUrlAsPdf(fullUrl) ' Render the PDF from the URL
		pdf.SaveAs(filePath) ' Save the PDF to the specified file path
		Console.WriteLine($"PDF successfully created from: {fullUrl}")
		Console.WriteLine($"Saved to: {filePath}")
	End Sub
End Class

Imports IronPdf
Imports System
Imports System.Web

' Implement the PDF generation interface
Public Class IronPdfService
	Implements IPdfService

	Public Sub GeneratePdf(ByVal baseUrl As String, ByVal query As String, ByVal filePath As String)
		License.LicenseKey = "Your-License-Key" ' Set the IronPDF license key
		Dim encodedQuery As String = HttpUtility.UrlEncode(query) ' Encode the query string
		Dim fullUrl As String = $"{baseUrl}?query={encodedQuery}" ' Construct the full URL
		Dim renderer = New ChromePdfRenderer() ' Create a PDF renderer
		Dim pdf = renderer.RenderUrlAsPdf(fullUrl) ' Render the PDF from the URL
		pdf.SaveAs(filePath) ' Save the PDF to the specified file path
		Console.WriteLine($"PDF successfully created from: {fullUrl}")
		Console.WriteLine($"Saved to: {filePath}")
	End Sub
End Class

Registrar servicio

En su clase Program.cs, configure la inyección de dependencias:

builder.Services.AddSingleton<IPdfService, IronPdfService>();

builder.Services.AddSingleton<IPdfService, IronPdfService>();

net

net

Esta configuración resuelve las dependencias implementando la interfaz IPdfService con IronPDFService, estableciendo un tipo de servicio singleton para la generación de PDF. Luego se referencia a lo largo de la aplicación, asegurando una funcionalidad consistente para la generación de PDFs.

Uso

Inyectar IPdfService en su controlador o servicio y usarlo:

public class MyController : Controller
{
    private readonly IPdfService _pdfService;
    
    public MyController(IPdfService pdfService)
    {
        _pdfService = pdfService;
    }
    
    public IActionResult GeneratePdf()
    {
        string baseUrl = "https://ironpdf.com/";
        string query = "Hello World from IronPDF !";
        string filePath = "Demo.pdf";
        
        // Use the injected PDF service to generate a PDF
        _pdfService.GeneratePdf(baseUrl, query, filePath);
        
        return View();
    }
}

public class MyController : Controller
{
    private readonly IPdfService _pdfService;
    
    public MyController(IPdfService pdfService)
    {
        _pdfService = pdfService;
    }
    
    public IActionResult GeneratePdf()
    {
        string baseUrl = "https://ironpdf.com/";
        string query = "Hello World from IronPDF !";
        string filePath = "Demo.pdf";
        
        // Use the injected PDF service to generate a PDF
        _pdfService.GeneratePdf(baseUrl, query, filePath);
        
        return View();
    }
}

Public Class MyController
    Inherits Controller

    Private ReadOnly _pdfService As IPdfService

    Public Sub New(pdfService As IPdfService)
        _pdfService = pdfService
    End Sub

    Public Function GeneratePdf() As IActionResult
        Dim baseUrl As String = "https://ironpdf.com/"
        Dim query As String = "Hello World from IronPDF !"
        Dim filePath As String = "Demo.pdf"

        ' Use the injected PDF service to generate a PDF
        _pdfService.GeneratePdf(baseUrl, query, filePath)

        Return View()
    End Function
End Class

Public Class MyController
    Inherits Controller

    Private ReadOnly _pdfService As IPdfService

    Public Sub New(pdfService As IPdfService)
        _pdfService = pdfService
    End Sub

    Public Function GeneratePdf() As IActionResult
        Dim baseUrl As String = "https://ironpdf.com/"
        Dim query As String = "Hello World from IronPDF !"
        Dim filePath As String = "Demo.pdf"

        ' Use the injected PDF service to generate a PDF
        _pdfService.GeneratePdf(baseUrl, query, filePath)

        Return View()
    End Function
End Class

Esta configuración asegura que el IronPDFService sea creado y gestionado por el contenedor Microsoft Extensions Dependency Injection. Puede sustituir sin dificultad el servicio de generación de PDF predeterminado ofreciendo una implementación alternativa para la interfaz IPdfService, todo sin alterar el código que lo consume.

Captura de pantalla del archivo PDF

Conclusión

Microsoft.Extensions.DependencyInjection es una herramienta poderosa en .NET 6 para implementar la inyección de dependencias, que promueve el acoplamiento flexible y mejora la testabilidad en las aplicaciones. Al integrar IronPDF, una biblioteca de C# rica en características, los desarrolladores pueden generar fácilmente documentos PDF integrales con un esfuerzo mínimo. La licencia para IronPDF está disponible.