Este tutorial mostra como usar a DI (injeção de dependência) no .NET. Com as Extensões da Microsoft, a DI é gerenciada adicionando serviços e configurando-os em um IServiceCollection. A interface IHost expõe a instância IServiceProvider, que atua como um contêiner de todos os serviços registrados.
Neste tutorial, você aprenderá a:
Criar um aplicativo de console do .NET que usa injeção de dependência
Familiaridade com a criação de novos aplicativos .NET e a instalação de pacotes NuGet.
Crie um novo aplicativo de console
Usando o comando dotnet new ou um novo assistente de projeto do IDE, crie um novo aplicativo de console .NET chamado ConsoleDI.Example. Adicione o pacote NuGet Microsoft.Extensions.Hosting ao projeto.
Seu novo arquivo de projeto de aplicativo do console deve ser semelhante ao seguinte:
Neste exemplo, o pacote NuGet Microsoft.Extensions.Hosting é necessário para compilar e executar o aplicativo. Alguns metapacotes podem conter o pacote Microsoft.Extensions.Hosting, caso em que não é necessária uma referência de pacote explícita.
Adicionar interfaces
Neste aplicativo de exemplo, você aprenderá como a injeção de dependência lida com o tempo de vida do serviço. Você criará diversas interfaces que representam tempos de vida de serviço diferentes. Adicione as seguintes interfaces ao diretório raiz do projeto:
IReportServiceLifetime.cs
using Microsoft.Extensions.DependencyInjection;
namespace ConsoleDI.Example;
public interface IReportServiceLifetime
{
Guid Id { get; }
ServiceLifetime Lifetime { get; }
}
A interface IReportServiceLifetime define o seguinte:
Uma propriedade Guid Id que representa o identificador exclusivo do serviço.
Uma propriedade ServiceLifetime que representa o tempo de vida do serviço.
IExampleTransientService.cs
using Microsoft.Extensions.DependencyInjection;
namespace ConsoleDI.Example;
public interface IExampleTransientService : IReportServiceLifetime
{
ServiceLifetime IReportServiceLifetime.Lifetime => ServiceLifetime.Transient;
}
IExampleScopedService.cs
using Microsoft.Extensions.DependencyInjection;
namespace ConsoleDI.Example;
public interface IExampleScopedService : IReportServiceLifetime
{
ServiceLifetime IReportServiceLifetime.Lifetime => ServiceLifetime.Scoped;
}
IExampleSingletonService.cs
using Microsoft.Extensions.DependencyInjection;
namespace ConsoleDI.Example;
public interface IExampleSingletonService : IReportServiceLifetime
{
ServiceLifetime IReportServiceLifetime.Lifetime => ServiceLifetime.Singleton;
}
Todas as subinterfaces de IReportServiceLifetime implementam IReportServiceLifetime.Lifetime explicitamente com um padrão. Por exemplo, IExampleTransientService implementa IReportServiceLifetime.Lifetime explicitamente com o valor ServiceLifetime.Transient.
Adicionar implementações padrão
Todas as implementações de exemplo inicializam as respectivas propriedades Id com o resultado de Guid.NewGuid(). Adicione ao diretório raiz do projeto as seguintes classes de implementação padrão para os diversos serviços:
Cada implementação é definida como internal sealed e implementa a interface correspondente. Por exemplo, ExampleSingletonService implementa IExampleSingletonService.
Adicionar um serviço que requer uma DI
Adicione a seguinte classe de relator de tempo de vida do serviço, que atua como um serviço para o aplicativo de console:
ServiceLifetimeReporter.cs
namespace ConsoleDI.Example;
internal sealed class ServiceLifetimeReporter(
IExampleTransientService transientService,
IExampleScopedService scopedService,
IExampleSingletonService singletonService)
{
public void ReportServiceLifetimeDetails(string lifetimeDetails)
{
Console.WriteLine(lifetimeDetails);
LogService(transientService, "Always different");
LogService(scopedService, "Changes only with lifetime");
LogService(singletonService, "Always the same");
}
private static void LogService<T>(T service, string message)
where T : IReportServiceLifetime =>
Console.WriteLine(
$" {typeof(T).Name}: {service.Id} ({message})");
}
O ServiceLifetimeReporter define um construtor que requer cada uma das interfaces de serviço mencionadas, ou seja, IExampleTransientService, IExampleScopedService e IExampleSingletonService. O objeto expõe um único método que permite ao consumidor realizar um relato sobre o serviço com um determinado parâmetro lifetimeDetails. Quando invocado, o método ReportServiceLifetimeDetails registra o identificador exclusivo de cada serviço com a respectiva mensagem de tempo de vida. As mensagens de log ajudam a visualizar o tempo de vida do serviço.
Registrar serviços para a DI
Atualize Program.cs com o seguinte código:
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using ConsoleDI.Example;
HostApplicationBuilder builder = Host.CreateApplicationBuilder(args);
builder.Services.AddTransient<IExampleTransientService, ExampleTransientService>();
builder.Services.AddScoped<IExampleScopedService, ExampleScopedService>();
builder.Services.AddSingleton<IExampleSingletonService, ExampleSingletonService>();
builder.Services.AddTransient<ServiceLifetimeReporter>();
using IHost host = builder.Build();
ExemplifyServiceLifetime(host.Services, "Lifetime 1");
ExemplifyServiceLifetime(host.Services, "Lifetime 2");
await host.RunAsync();
static void ExemplifyServiceLifetime(IServiceProvider hostProvider, string lifetime)
{
using IServiceScope serviceScope = hostProvider.CreateScope();
IServiceProvider provider = serviceScope.ServiceProvider;
ServiceLifetimeReporter logger = provider.GetRequiredService<ServiceLifetimeReporter>();
logger.ReportServiceLifetimeDetails(
$"{lifetime}: Call 1 to provider.GetRequiredService<ServiceLifetimeReporter>()");
Console.WriteLine("...");
logger = provider.GetRequiredService<ServiceLifetimeReporter>();
logger.ReportServiceLifetimeDetails(
$"{lifetime}: Call 2 to provider.GetRequiredService<ServiceLifetimeReporter>()");
Console.WriteLine();
}
Cada método de extensão services.Add{LIFETIME}<{SERVICE}> adiciona (e possivelmente configura) serviços. Recomendamos que os aplicativos sigam essa convenção. Não coloque métodos de extensão no namespace Microsoft.Extensions.DependencyInjection, a menos que você esteja criando um pacote oficial da Microsoft. Métodos de extensão definidos no namespace Microsoft.Extensions.DependencyInjection:
São exibidos no IntelliSense sem a necessidade de blocos adicionais de using.
Reduza o número de instruções using necessárias nas classes Program ou Startup em que esses métodos de extensão normalmente são chamados.
Neste aplicativo de exemplo, você criou diversas interfaces e implementações correspondentes. Cada um desses serviços é identificado exclusivamente e emparelhado com um ServiceLifetime. O aplicativo de exemplo demonstra o registro de implementações de serviço em uma interface e como registrar classes puras sem interfaces de suporte. Ele também demonstra como as dependências definidas como parâmetros do construtor são resolvidas no runtime.
Ao executar o aplicativo, ele exibe uma saída semelhante à seguinte:
// Sample output:
// Lifetime 1: Call 1 to provider.GetRequiredService<ServiceLifetimeReporter>()
// IExampleTransientService: d08a27fa-87d2-4a06-98d7-2773af886125 (Always different)
// IExampleScopedService: 402c83c9-b4ed-4be1-b78c-86be1b1d908d (Changes only with lifetime)
// IExampleSingletonService: a61f1ff4-0b14-4508-bd41-21d852484a7b (Always the same)
// ...
// Lifetime 1: Call 2 to provider.GetRequiredService<ServiceLifetimeReporter>()
// IExampleTransientService: b43d68fb-2c7b-4a9b-8f02-fc507c164326 (Always different)
// IExampleScopedService: 402c83c9-b4ed-4be1-b78c-86be1b1d908d (Changes only with lifetime)
// IExampleSingletonService: a61f1ff4-0b14-4508-bd41-21d852484a7b (Always the same)
//
// Lifetime 2: Call 1 to provider.GetRequiredService<ServiceLifetimeReporter>()
// IExampleTransientService: f3856b59-ab3f-4bbd-876f-7bab0013d392 (Always different)
// IExampleScopedService: bba80089-1157-4041-936d-e96d81dd9d1c (Changes only with lifetime)
// IExampleSingletonService: a61f1ff4-0b14-4508-bd41-21d852484a7b (Always the same)
// ...
// Lifetime 2: Call 2 to provider.GetRequiredService<ServiceLifetimeReporter>()
// IExampleTransientService: a8015c6a-08cd-4799-9ec3-2f2af9cbbfd2 (Always different)
// IExampleScopedService: bba80089-1157-4041-936d-e96d81dd9d1c (Changes only with lifetime)
// IExampleSingletonService: a61f1ff4-0b14-4508-bd41-21d852484a7b (Always the same)
Na saída do aplicativo, você pode ver que:
Os serviços Transient são sempre diferentes e uma nova instância é criada a cada recuperação de serviço.
Os serviços Scoped mudam somente com um novo escopo, mas são a mesma instância em um escopo.
Os serviços Singleton são sempre os mesmos e uma nova instância é criada somente uma vez.
A fonte deste conteúdo pode ser encontrada no GitHub, onde você também pode criar e revisar problemas e solicitações de pull. Para obter mais informações, confira o nosso guia para colaboradores.
Comentários do .NET
O .NET é um projeto código aberto. Selecione um link para fornecer comentários:
Entenda e implemente a injeção de dependência em um aplicativo ASP.NET Core. Use o contêiner de serviço interno do ASP.NET Core para gerenciar dependências. Registre serviços com o contêiner de serviço.