Inserción de dependencias de Blazor de 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>();

Después de crear una aplicación, examine el método Startup.ConfigureServices en Startup.cs:

using Microsoft.Extensions.DependencyInjection;

...

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

Al método ConfigureServices se le pasa una interfaz IServiceCollection, que es una lista de objetos de descriptor de servicio. Para agregar los servicios al método ConfigureServices, se proporcionan descriptores de servicio a la colección de servicios. En el ejemplo siguiente se muestra el concepto con la interfaz IDataAccess y su implementación concreta de DataAccess:

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

Los servicios del lado cliente no se resuelven durante la representación previa

Esta sección solo se aplica a componentes WebAssembly en Blazor Web App.

Blazor Web App normalmente representa previamente los componentes WebAssembly del lado cliente. Si una aplicación se ejecuta con un servicio obligatorio registrado solo en el proyecto .Client, la ejecución de la aplicación genera un error en tiempo de ejecución similar al siguiente cuando un componente intenta usar el servicio obligatorio durante la representación previa:

InvalidOperationException: no se puede proporcionar un valor para {PROPIEDAD} en el tipo "{ENSAMBLADO}}. Client.Pages. {NOMBRE DEL COMPONENTE}". No hay ningún servicio registrado de tipo "{SERVICIO}".

Para resolver este problema, use uno de los enfoques siguientes:

• Registre el servicio en el proyecto principal para que esté disponible durante la representación previa del componente.
• Si la representación previa no es necesaria para el componente, deshabilítela con las instrucciones de Modos de representación de ASP.NET Core Blazor. Si adopta este enfoque, no es necesario registrar el servicio en el proyecto principal.

Para más información, vea Los servicios del lado cliente no se resuelven durante la representación previa.

Para insertar servicios en componentes, Blazor admite la inserción de constructores y la inserción de propiedades.

Inserción de constructores

Una vez agregados los servicios a la colección de servicios, inserte uno o varios servicios en componentes con la inyección de constructor. En el ejemplo siguiente se inserta el servicio 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");
    }
}

Inserción de propiedades

Inserción de servicios con clave en componentes

Blazor admite la inserción de servicios con clave mediante el atributo [Inject]. Las claves permiten determinar el ámbito del registro y el consumo de servicios al usar la inserción de dependencias. Use la propiedad InjectAttribute.Key para especificar la clave del servicio que se va a insertar:

[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>();
    }
}

Detección de descartables transitorios del lado del cliente

El código personalizado se puede agregar a una aplicación Blazor del lado del cliente para detectar servicios transitorios descartables en una aplicación que debe usar OwningComponentBase. Este enfoque es útil si le preocupa que el código agregado a la aplicación en el futuro consuma uno o varios servicios descartables transitorios, incluidos los servicios agregados por las bibliotecas. El código de demostración está disponible en el Blazorrepositorio de GitHub de ejemplos de (cómo descargar).

Inspeccione lo siguiente en .NET 6 o versiones posteriores del ejemplo BlazorSample_WebAssembly:

• DetectIncorrectUsagesOfTransientDisposables.cs
• Services/TransientDisposableService.cs
• En: Program.cs
  • El espacio de nombres Services de la aplicación se proporciona en la parte superior del archivo (using BlazorSample.Services;).
  • DetectIncorrectUsageOfTransients se llama inmediatamente después de asignar builder desde WebAssemblyHostBuilder.CreateDefault.
  • TransientDisposableService está registrado (builder.Services.AddTransient<TransientDisposableService>();).
  • EnableTransientDisposableDetection se llama a en el host integrado en la canalización de procesamiento de la aplicación (host.EnableTransientDisposableDetection();).
• La aplicación registra el servicio TransientDisposableService sin iniciar una excepción. Sin embargo, al intentar resolver el servicio en TransientService.razor, se produce InvalidOperationException cuando el marco intenta construir una instancia de TransientDisposableService.

Detectar desechables transitorios del lado del servidor

El código personalizado se puede agregar a una aplicación Blazor del lado del servidor para detectar servicios transitorios descartables del lado del servidor en una aplicación que debe usar OwningComponentBase. Este enfoque es útil si le preocupa que el código agregado a la aplicación en el futuro consuma uno o varios servicios descartables transitorios, incluidos los servicios agregados por las bibliotecas. El código de demostración está disponible en el Blazorrepositorio de GitHub de ejemplos de (cómo descargar).

Inspeccione lo siguiente en .NET 8 o versiones posteriores del ejemplo BlazorSample_BlazorWebApp:

Inspeccione lo siguiente en las versiones de .NET 6 o .NET 7 del ejemplo BlazorSample_Server:

• DetectIncorrectUsagesOfTransientDisposables.cs
• Services/TransitiveTransientDisposableDependency.cs:
• En: Program.cs
  • El espacio de nombres Services de la aplicación se proporciona en la parte superior del archivo (using BlazorSample.Services;).
  • Se llama a DetectIncorrectUsageOfTransients en el generador de hosts (builder.DetectIncorrectUsageOfTransients();).
  • El servicio TransientDependency está registrado (builder.Services.AddTransient<TransientDependency>();).
  • TransitiveTransientDisposableDependency está registrado para ITransitiveTransientDisposableDependency (builder.Services.AddTransient<ITransitiveTransientDisposableDependency, TransitiveTransientDisposableDependency>();).
• La aplicación registra el servicio TransientDependency sin iniciar una excepción. Sin embargo, al intentar resolver el servicio en TransientService.razor, se produce InvalidOperationException cuando el marco intenta construir una instancia de TransientDependency.

Se recomiendan los registros de servicio transitorios para los controladores IHttpClientFactory/HttpClient

Se recomiendan los registros de servicio transitorios para los controladores IHttpClientFactory/HttpClient. Si la aplicación contiene controladores IHttpClientFactory/HttpClient y usa IRemoteAuthenticationBuilder<TRemoteAuthenticationState,TAccount> para agregar compatibilidad con la autenticación, también se detectan los siguientes descartables transitorios para la autenticación del lado del cliente. Este es un comportamiento esperado y se puede omitir:

• BaseAddressAuthorizationMessageHandler
• AuthorizationMessageHandler

También se detectan otras instancias de IHttpClientFactory/HttpClient. Estas instancias también se pueden omitir.

Las Blazoraplicaciones de Blazorejemplo en el repositorio de GitHub (cómo descargar) muestran el código para detectar descartables transitorios. Sin embargo, el código se desactiva porque las aplicaciones de ejemplo incluyen controladores IHttpClientFactory/HttpClient.

Para activar el código de demostración y ver su operación:

• Quite la marca de comentario de las líneas descartables transitorias en Program.cs.

• Quite la comprobación condicional NavLink.razor que impide que el componente TransientService se muestre en la barra lateral de navegación de la aplicación:

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

• Ejecute la aplicación de ejemplo y vaya al componente de TransientService en /transient-service.

Los controladores de actividad de circuito proporcionan un enfoque para acceder a los servicios de Blazor con ámbito desde otros ámbitos de inserción de dependencias (DI) que no son de Blazor, como los ámbitos creados mediante IHttpClientFactory.

Antes del lanzamiento de ASP.NET Core en .NET 8, para acceder a los servicios con ámbito de circuito desde otros ámbitos de inserción de dependencias era necesario usar un tipo de componente base personalizado. Con los controladores de actividad de circuito no se requiere un tipo de componente base personalizado, como se muestra en el ejemplo siguiente:

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;
    }
}

Acceda a los servicios con ámbito de circuito mediante la inserción de CircuitServicesAccessor donde sea necesario.

Para ver un ejemplo que muestra cómo acceder a AuthenticationStateProvider desde una configuración DelegatingHandler mediante IHttpClientFactory, consulte Escenarios de seguridad adicionales de Blazor de ASP.NET Core del lado del servidor.

Puede haber ocasiones en las que un componente Razor invoque métodos asincrónicos que ejecuten código en un ámbito de inserción de dependencias distinto. Sin el enfoque correcto, estos ámbitos de inserción de dependencias no tienen acceso a los servicios de Blazor, como IJSRuntime y Microsoft.AspNetCore.Components.Server.ProtectedBrowserStorage.

Por ejemplo, las instancias de HttpClient creadas con IHttpClientFactory tienen su propio ámbito de servicio de inserción de dependencias. Como resultado, las instancias de HttpMessageHandler configuradas en HttpClient no pueden insertar servicios de Blazor directamente.

Cree una clase BlazorServiceAccessor que defina un objeto AsyncLocal, que almacena el objeto IServiceProvider de Blazor para el contexto asincrónico actual. Una instancia de BlazorServiceAccessor puede adquirirse desde dentro de un ámbito de servicio de inserción de dependencias distinto para acceder a los servicios de 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 establecer el valor de BlazorServiceAccessor.Services de forma automática cuando se invoque un método de componente async, cree un componente base personalizado que reimplemente los tres puntos de entrada asincrónicos principales en el código del componente Razor:

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

En la clase siguiente se muestra la implementación del 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;
        }
    }
}

Los componentes que extienden CustomComponentBase de forma automática tienen el valor BlazorServiceAccessor.Services establecido en IServiceProvider en el ámbito de inserción de dependencias Blazor actual.

Por último, en el archivo Program, agregar el BlazorServiceAccessor como un servicio de alcance:

builder.Services.AddScoped<BlazorServiceAccessor>();

Por último, en Startup.ConfigureServices de Startup.cs, agregue BlazorServiceAccessor como servicio con ámbito:

services.AddScoped<BlazorServiceAccessor>();

• Inserción de servicio a través de un archivo de importación de nivel superior (_Imports.razor) en Blazor Web App
• Inserción de dependencias en ASP.NET Core
• Instrucciones de IDisposable para instancias transitorias y compartidas
• Inserción de dependencias en vistas de ASP.NET Core
• Constructores principales (Guía de C#)

• Inserción de dependencias en ASP.NET Core
• Instrucciones de IDisposable para instancias transitorias y compartidas
• Inserción de dependencias en vistas de ASP.NET Core