Microsoft.Extensions .DependencyInjection .NET 9 (Trabalhando com PDF)

Contêiner de Injeção de Dependência

1. Registro de serviço: As dependências são registradas em um contêiner de injeção de dependência (DI), normalmente na raiz de composição do aplicativo. Esses registros especificam como o contêiner deve criar e gerenciar as dependências.

2. Resolução de Dependências: Quando um componente solicita uma dependência, o contêiner de Injeção de Dependência (DI) resolve a dependência criando uma instância de um tipo registrado que utiliza um método de extensão.

Tipos de Injeção de Dependência

• Injeção de Construtor: Os serviços registrados são fornecidos a uma classe por meio de seu construtor, que é a forma mais comum e recomendada de Injeção de Dependência.
• Injeção de método: Os serviços são resolvidos e passados ​​como parâmetros para um método.
• Injeção de propriedades: Serviços singleton ou serviços com um tempo de vida definido podem ser atribuídos a propriedades de classe. No entanto, essa abordagem é menos comum e frequentemente considerada inferior à injeção de dependência por construtor, pois pode introduzir dependências ocultas.

Entendendo os tempos de vida na Injeção de Dependência (DI): Escopo, Transiente e Singleton

1. Com escopo: Dependências com escopo são criadas uma vez por solicitação ou escopo de vida útil, o que significa que o contêiner fornece a mesma instância dentro de uma única solicitação ou operação. Essa consistência é particularmente útil em aplicações web, onde dependências com escopo ajudam a manter uma dependência estável ao longo de uma requisição web.
2. Transitório: Dependências transitórias são instanciadas cada vez que são solicitadas ao contêiner. Isso implica que uma nova instância de uma dependência transitória é gerada sempre que necessário. Normalmente, as dependências transitórias são usadas para serviços ou componentes leves e sem estado.
3. Singleton: Dependências singleton são instanciadas apenas uma vez e compartilhadas durante toda a vida útil da aplicação. Isso garante que a mesma instância de uma dependência singleton seja usada para todas as requisições durante a execução da aplicação. As dependências singleton são normalmente empregadas para serviços ou componentes com estado que precisam ser universalmente acessíveis em toda a aplicação.

Instalando o pacote Microsoft.Extensions.DependencyInjection

Install-Package Microsoft.Extensions.DependencyInjection

Exemplo: Injeção de Dependência Básica

Neste exemplo, vamos criar um aplicativo de exemplo (aplicativo de console) no qual utilizaremos um provedor de serviços para resolver serviços e injetá-los em nosso 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

O trecho de código cria uma interface IMessageService para envio de mensagens, como um contrato sobre como as mensagens devem ser enviadas. A classe ConsoleMessageService implementa esta interface usando Console.WriteLine para enviar mensagens. Essa separação permite que o conceito de envio de mensagens seja alterado independentemente da forma como são enviadas, tornando o sistema flexível e gerenciável.

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

Este código configura um provedor de serviços para gerenciar serviços. Ele registra o ConsoleMessageService como a implementação do IMessageService , tornando-o disponível para ser injetado onde for necessário. O método Main recupera uma instância de IMessageService do provedor de serviços e a utiliza para enviar uma mensagem ao console.

Saída: O programa imprime a mensagem "Olá, da Injeção de Dependência!"

IronPDF: Biblioteca PDF em C

IronPDF é uma poderosa biblioteca para C# que simplifica o complexo processo de geração de PDFs, oferecendo uma ampla gama de recursos para manipulação de PDFs, incluindo a capacidade de gerar PDFs a partir de HTML , adicionar texto a PDFs e editar PDFs com imagens , criar documentos seguros e muito mais.

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

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

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

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

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(ByVal 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

Conclusão

Microsoft.Extensions.DependencyInjection é uma ferramenta poderosa no .NET 6 para implementar injeção de dependência, o que promove baixo acoplamento e melhora a testabilidade em aplicações. Ao integrar o IronPDF, uma biblioteca C# rica em recursos, os desenvolvedores podem gerar facilmente documentos PDF abrangentes com o mínimo esforço. O licenciamento do IronPDF está disponível.