Injeção de dependência Blazor no ASP.NET Core

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddRazorComponents()
    .AddInteractiveServerComponents();

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddRazorPages();
builder.Services.AddServerSideBlazor();
builder.Services.AddSingleton<WeatherForecastService>();

Após criar um novo aplicativo, examine o método Startup.ConfigureServices em Startup.cs:

using Microsoft.Extensions.DependencyInjection;

...

public void ConfigureServices(IServiceCollection services)
{
    ...
}

O método ConfigureServices é passado por um IServiceCollection, que é uma lista de objetos descritores de serviço. Os serviços são adicionados no método ConfigureServices, fornecendo descritores de serviço à coleção de serviços. O exemplo a seguir demonstra o conceito com a interface IDataAccess e sua implementação DataAccess concreta:

public void ConfigureServices(IServiceCollection services)
{
    services.AddSingleton<IDataAccess, DataAccess>();
}

Serviços do lado do cliente que falham durante a pré-renderização

Esta seção se aplica somente a componentes do WebAssembly em Blazor Web App.

Os Blazor Web Apps normalmente pré-renderizam componentes WebAssembly do lado do cliente. Se um aplicativo for executado com um serviço necessário registrado apenas no projeto .Client, a execução do aplicativo resultará em um erro de runtime semelhante ao seguinte quando um componente tentar usar o serviço necessário durante a pré-renderização:

InvalidOperationException: não é possível fornecer um valor para {PROPERTY} no tipo '{ASSEMBLY}}.Client.Pages.{COMPONENT NAME}'. Não há nenhum serviço registrado do tipo '{SERVICE}'.

Use ou das seguintes abordagens para resolver esse problema:

• Registre o serviço no projeto principal para torná-lo disponível durante a pré-renderização do componente.
• Se a pré-renderização não for necessária para o componente, desabilite-o seguindo as diretrizes em ASP.NET Core Blazor modos de renderização. Se você adotar essa abordagem, não precisará registrar o serviço no projeto principal.

Para obter mais informações, confira Serviços do lado do cliente não resolvidos durante a pré-renderização.

Para serviços de injeção em componentes, o Blazor dá suporte à injeção de construtor e à injeção de propriedade.

Injeção de construção

Depois que os serviços forem adicionados à coleção de serviços, injete um ou mais serviços em componentes com a injeção do construtor. O exemplo a seguir injeta o serviço NavigationManager.

ConstructorInjection.razor:

@page "/constructor-injection"

<button @onclick="HandleClick">
    Take me to the Counter component
</button>

ConstructorInjection.razor.cs:

using Microsoft.AspNetCore.Components;

public partial class ConstructorInjection(NavigationManager navigation)
{
    private void HandleClick()
    {
        navigation.NavigateTo("/counter");
    }
}

Injeção de propriedade

Injetar serviços com chave em componentes

Blazor dá suporte à injeção de serviços chave usando o atributo [Inject]. As chaves permitem o escopo do registro e do consumo de serviços ao usar a injeção de dependência. Use a propriedade InjectAttribute.Key para especificar a chave do serviço a ser injetado:

[Inject(Key = "my-service")]
public IMyService MyService { get; set; }

@page "/time-travel"
@inject ITimeTravel TimeTravel1
@inherits OwningComponentBase

<h1><code>OwningComponentBase</code> Example</h1>

<ul>
    <li>TimeTravel1.DT: @TimeTravel1?.DT</li>
    <li>TimeTravel2.DT: @TimeTravel2?.DT</li>
</ul>

@code {
    private ITimeTravel TimeTravel2 { get; set; } = default!;

    protected override void OnInitialized()
    {
        TimeTravel2 = ScopedServices.GetRequiredService<ITimeTravel>();
    }
}

@page "/time-travel"
@inject ITimeTravel TimeTravel1
@inherits OwningComponentBase

<h1><code>OwningComponentBase</code> Example</h1>

<ul>
    <li>TimeTravel1.DT: @TimeTravel1?.DT</li>
    <li>TimeTravel2.DT: @TimeTravel2?.DT</li>
</ul>

@code {
    private ITimeTravel TimeTravel2 { get; set; } = default!;

    protected override void OnInitialized()
    {
        TimeTravel2 = ScopedServices.GetRequiredService<ITimeTravel>();
    }
}

Detectar descartáveis transitórios do lado do cliente

O código personalizado pode ser adicionado a um aplicativo Blazor do lado do cliente para detectar serviços transitórios descartáveis em um aplicativo que deve usar OwningComponentBase. Essa abordagem é útil se você estiver preocupado que o código adicionado ao aplicativo no futuro consuma um ou mais serviços descartáveis transitórios, incluindo serviços adicionados por bibliotecas. O código de demonstração está disponível no Blazor repositório GitHub de amostras (como baixar).

Inspecione o seguinte no .NET 6 ou versões posteriores do exemplo BlazorSample_WebAssembly:

• DetectIncorrectUsagesOfTransientDisposables.cs
• Services/TransientDisposableService.cs
• Em: Program.cs
  • O namespace do aplicativo Services é fornecido na parte superior do arquivo (using BlazorSample.Services;).
  • DetectIncorrectUsageOfTransients é chamado imediatamente após builder ser atribuído de WebAssemblyHostBuilder.CreateDefault.
  • O TransientDisposableService está registrado (builder.Services.AddTransient<TransientDisposableService>();).
  • EnableTransientDisposableDetection é chamado no host interno no pipeline de processamento do aplicativo (host.EnableTransientDisposableDetection();).
• O aplicativo registra o serviço TransientDisposableService sem abrir uma exceção. No entanto, a tentativa de resolver o serviço em TransientService.razor lança um InvalidOperationException quando a estrutura tenta construir uma instância do TransientDisposableService.

Detectar descartáveis transitórios do lado do servidor

O código personalizado pode ser adicionado a um aplicativo Blazor do lado do servidor para detectar serviços transitórios descartáveis do lado do servidor em um aplicativo que deve usar OwningComponentBase. Essa abordagem é útil se você estiver preocupado que o código adicionado ao aplicativo no futuro consuma um ou mais serviços descartáveis transitórios, incluindo serviços adicionados por bibliotecas. O código de demonstração está disponível no Blazor repositório GitHub de amostras (como baixar).

Inspecione o seguinte no .NET 8 ou versões posteriores do exemplo BlazorSample_BlazorWebApp:

Inspecione o seguinte nas versões .NET 6 ou 7 do exemplo BlazorSample_Server:

• DetectIncorrectUsagesOfTransientDisposables.cs
• Services/TransitiveTransientDisposableDependency.cs:
• Em: Program.cs
  • O namespace do aplicativo Services é fornecido na parte superior do arquivo (using BlazorSample.Services;).
  • DetectIncorrectUsageOfTransients é chamado no construtor de host (builder.DetectIncorrectUsageOfTransients();).
  • O serviço TransientDependency é registrado (builder.Services.AddTransient<TransientDependency>();).
  • O TransitiveTransientDisposableDependency é registrado para ITransitiveTransientDisposableDependency (builder.Services.AddTransient<ITransitiveTransientDisposableDependency, TransitiveTransientDisposableDependency>();).
• O aplicativo registra o serviço TransientDependency sem abrir uma exceção. No entanto, a tentativa de resolver o serviço em TransientService.razor lança um InvalidOperationException quando a estrutura tenta construir uma instância do TransientDependency.

Registros de serviços transitórios para manipuladores IHttpClientFactory/HttpClient

Os registros de serviço transitórios para manipuladores IHttpClientFactory/HttpClient são recomendados. Se o aplicativo contiver manipuladores IHttpClientFactory/HttpClient e usar o IRemoteAuthenticationBuilder<TRemoteAuthenticationState,TAccount> para adicionar suporte à autenticação, os seguintes descartáveis transitórios para autenticação no lado do cliente também serão descobertos, o que é esperado e pode ser ignorado:

• BaseAddressAuthorizationMessageHandler
• AuthorizationMessageHandler

Outras instâncias de IHttpClientFactory/HttpClient também são descobertas. Essas instâncias também podem ser ignoradas.

Os aplicativos de amostra Blazor no Blazor repositório GitHub de amostras (como baixar) demonstram o código para detectar descartáveis transitórios. No entanto, o código está desativado porque os aplicativos de amostra incluem os manipuladores IHttpClientFactory/HttpClient.

Para ativar o código de demonstração e testemunhar sua operação:

• Remova a marca de comentário das linhas descartáveis transitórias em Program.cs.

• Remova a verificação condicional em NavLink.razor que impede que o componente TransientService seja exibido na barra lateral de navegação do aplicativo:

  - else if (name != "TransientService")
  + else
  

• Execute o aplicativo de amostra e navegue até o TransientService componente em /transient-service.

Os manipuladores de atividade de circuito fornecem uma abordagem para acessar serviços Blazor com escopo de outros escopos de DI (injeção de dependência de injeção) de não Blazor, como escopos criados usando IHttpClientFactory.

Antes do lançamento do ASP.NET Core no .NET 8, acessar serviços de escopo de circuito de outras escopos de injeção de dependência exigia o uso de um tipo de componente base personalizado. Com manipuladores de atividade de circuito, um tipo de componente base personalizado não é necessário, como demonstra o exemplo a seguir:

public class CircuitServicesAccessor
{
    static readonly AsyncLocal<IServiceProvider> blazorServices = new();

    public IServiceProvider? Services
    {
        get => blazorServices.Value;
        set => blazorServices.Value = value;
    }
}

public class ServicesAccessorCircuitHandler(
    IServiceProvider services, CircuitServicesAccessor servicesAccessor) 
    : CircuitHandler
{
    public override Func<CircuitInboundActivityContext, Task> CreateInboundActivityHandler(
        Func<CircuitInboundActivityContext, Task> next) => 
            async context =>
            {
                servicesAccessor.Services = services;
                await next(context);
                servicesAccessor.Services = null;
            };
}

public static class CircuitServicesServiceCollectionExtensions
{
    public static IServiceCollection AddCircuitServicesAccessor(
        this IServiceCollection services)
    {
        services.AddScoped<CircuitServicesAccessor>();
        services.AddScoped<CircuitHandler, ServicesAccessorCircuitHandler>();

        return services;
    }
}

Acesse os serviços com escopo de circuito injetando o CircuitServicesAccessor onde for necessário.

Para obter um exemplo que mostra como acessar o AuthenticationStateProvider de uma DelegatingHandler configuração usando IHttpClientFactoryo , consulte ASP.NET Cenários de segurança adicionais e Blazor Web App do lado do servidor Core.

Pode haver momentos em que um componente Razor invoca métodos assíncronos que executam código em um escopo de DI diferente. Sem a abordagem correta, esses escopos de DI não têm acesso aos serviços de Blazor, como IJSRuntime e Microsoft.AspNetCore.Components.Server.ProtectedBrowserStorage.

Por exemplo, instâncias HttpClient criadas usando IHttpClientFactory têm seu próprio escopo de serviço DI. Como resultado, as instâncias HttpMessageHandler configuradas no HttpClient não são capazes de injetar serviços Blazor diretamente.

Crie uma classe BlazorServiceAccessor que define um AsyncLocal, que armazena o BlazorIServiceProvider para o contexto assíncrono atual. Uma instância BlazorServiceAccessor pode ser adquirida de dentro de um escopo diferente de serviço DI para acessar serviços Blazor.

BlazorServiceAccessor.cs:

internal sealed class BlazorServiceAccessor
{
    private static readonly AsyncLocal<BlazorServiceHolder> s_currentServiceHolder = new();

    public IServiceProvider? Services
    {
        get => s_currentServiceHolder.Value?.Services;
        set
        {
            if (s_currentServiceHolder.Value is { } holder)
            {
                // Clear the current IServiceProvider trapped in the AsyncLocal.
                holder.Services = null;
            }

            if (value is not null)
            {
                // Use object indirection to hold the IServiceProvider in an AsyncLocal
                // so it can be cleared in all ExecutionContexts when it's cleared.
                s_currentServiceHolder.Value = new() { Services = value };
            }
        }
    }

    private sealed class BlazorServiceHolder
    {
        public IServiceProvider? Services { get; set; }
    }
}

Para definir o valor de BlazorServiceAccessor.Services automaticamente quando um método de componente async é invocado, crie um componente base personalizado que implementa novamente os três pontos de entrada assíncronos primários no código do componente Razor:

• IComponent.SetParametersAsync
• IHandleEvent.HandleEventAsync
• IHandleAfterRender.OnAfterRenderAsync

A classe a seguir demonstra a implementação do componente base.

CustomComponentBase.cs:

using Microsoft.AspNetCore.Components;

public class CustomComponentBase : ComponentBase, IHandleEvent, IHandleAfterRender
{
    private bool hasCalledOnAfterRender;

    [Inject]
    private IServiceProvider Services { get; set; } = default!;

    [Inject]
    private BlazorServiceAccessor BlazorServiceAccessor { get; set; } = default!;

    public override Task SetParametersAsync(ParameterView parameters)
        => InvokeWithBlazorServiceContext(() => base.SetParametersAsync(parameters));

    Task IHandleEvent.HandleEventAsync(EventCallbackWorkItem callback, object? arg)
        => InvokeWithBlazorServiceContext(() =>
        {
            var task = callback.InvokeAsync(arg);
            var shouldAwaitTask = task.Status != TaskStatus.RanToCompletion &&
                task.Status != TaskStatus.Canceled;

            StateHasChanged();

            return shouldAwaitTask ?
                CallStateHasChangedOnAsyncCompletion(task) :
                Task.CompletedTask;
        });

    Task IHandleAfterRender.OnAfterRenderAsync()
        => InvokeWithBlazorServiceContext(() =>
        {
            var firstRender = !hasCalledOnAfterRender;
            hasCalledOnAfterRender |= true;

            OnAfterRender(firstRender);

            return OnAfterRenderAsync(firstRender);
        });

    private async Task CallStateHasChangedOnAsyncCompletion(Task task)
    {
        try
        {
            await task;
        }
        catch
        {
            if (task.IsCanceled)
            {
                return;
            }

            throw;
        }

        StateHasChanged();
    }

    private async Task InvokeWithBlazorServiceContext(Func<Task> func)
    {
        try
        {
            BlazorServiceAccessor.Services = Services;
            await func();
        }
        finally
        {
            BlazorServiceAccessor.Services = null;
        }
    }
}

Todos os componentes que estendem CustomComponentBase automaticamente definiram BlazorServiceAccessor.Services para o IServiceProvider no escopo DI Blazor atual.

Por fim, no arquivo Program, adicione o BlazorServiceAccessor como um serviço com escopo:

builder.Services.AddScoped<BlazorServiceAccessor>();

Por fim, em Startup.ConfigureServices de Startup.cs, adicione o BlazorServiceAccessor como um serviço com escopo:

services.AddScoped<BlazorServiceAccessor>();

• Injeção de serviço por meio de um arquivo de importação de nível superior (_Imports.razor) em Blazor Web Apps
• Injeção de dependência no ASP.NET Core
• Diretrizes do IDisposable para instâncias transitórias e compartilhadas
• Injeção de dependência em exibições no ASP.NET Core
• Construtores primários (Guia C#)

• Injeção de dependência no ASP.NET Core
• Diretrizes do IDisposable para instâncias transitórias e compartilhadas
• Injeção de dependência em exibições no ASP.NET Core