Blazor ASP.NET core dependency injection

var builder = WebApplication.CreateBuilder(args);

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

var builder = WebApplication.CreateBuilder(args);

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

Dopo aver creato una nuova app, esaminare il Startup.ConfigureServices metodo in Startup.cs:

using Microsoft.Extensions.DependencyInjection;

...

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

Il ConfigureServices metodo viene passato a , IServiceCollectionche è un elenco di oggetti descrittore del servizio. I servizi vengono aggiunti nel ConfigureServices metodo fornendo i descrittori del servizio alla raccolta di servizi. L'esempio seguente illustra il concetto con l'interfaccia e la IDataAccess relativa implementazione DataAccessconcreta:

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

Servizi lato client che hanno esito negativo durante la pre-esecuzione del pre-ordinamento

Questa sezione si applica solo ai componenti WebAssembly in Blazor Web Apps.

Blazor Web Appè in genere prerendere componenti WebAssembly sul lato client. Se un'app viene eseguita con un servizio obbligatorio registrato solo nel .Client progetto, l'esecuzione dell'app genera un errore di runtime simile al seguente quando un componente tenta di usare il servizio richiesto durante la pre-esecuzione:

InvalidOperationException: impossibile specificare un valore per {PROPERTY} nel tipo '{ASSEMBLY}}. Client.Pages. {NOME COMPONENTE}'. Nessun servizio registrato di tipo '{SERVICE}'.

Usare uno degli approcci seguenti per risolvere il problema:

• Registrare il servizio nel progetto principale per renderlo disponibile durante il prerendering dei componenti.
• Se il prerendering non è necessario per il componente, disabilitare il prerendering seguendo le indicazioni riportate in ASP.NET modalità di rendering coreBlazor. Se si adotta questo approccio, non è necessario registrare il servizio nel progetto principale.

Per altre informazioni, vedere I servizi sul lato client non riescono a risolvere durante la pre-esecuzione del servizio.

Per l'inserimento di servizi nei componenti, Blazor supporta l'inserimento di costruttori e l'inserimento di proprietà.

Inserimento del costruttore

Dopo l'aggiunta dei servizi alla raccolta di servizi, inserire uno o più servizi nei componenti con inserimento del costruttore. L'esempio seguente inserisce il NavigationManager servizio.

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

Inserimento di proprietà

Inserire i servizi con chiave nei componenti

Blazor supporta l'inserimento di servizi con chiave usando l'attributo [Inject] . Le chiavi consentono di definire l'ambito della registrazione e dell'utilizzo dei servizi quando si usa l'inserimento delle dipendenze. Usare la InjectAttribute.Key proprietà per specificare la chiave per il servizio da inserire:

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

Rilevare gli eliminabili temporanei sul lato client

È possibile aggiungere codice personalizzato a un'app lato Blazor client per rilevare servizi temporanei eliminabili in un'app che deve usare OwningComponentBase. Questo approccio è utile se si è preoccupati che il codice aggiunto all'app in futuro utilizza uno o più servizi eliminabili temporanei, inclusi i servizi aggiunti dalle librerie. Il codice dimostrativo è disponibile nel Blazor repository GitHub degli esempi (come scaricare).

Esaminare quanto segue in .NET 6 o versioni successive dell'esempio BlazorSample_WebAssembly :

• DetectIncorrectUsagesOfTransientDisposables.cs
• Services/TransientDisposableService.cs
• In Program.cs:
  • Lo spazio dei nomi dell'app Services viene fornito all'inizio del file (using BlazorSample.Services;).
  • DetectIncorrectUsageOfTransients viene chiamato immediatamente dopo l'assegnazione di builder da WebAssemblyHostBuilder.CreateDefault.
  • l'oggetto TransientDisposableService è registrato (builder.Services.AddTransient<TransientDisposableService>();).
  • EnableTransientDisposableDetection viene chiamato nell'host predefinito nella pipeline di elaborazione dell'app (host.EnableTransientDisposableDetection();).
• L'app registra il TransientDisposableService servizio senza generare un'eccezione. Tuttavia, il tentativo di risolvere il servizio in TransientService.razor genera un'eccezione InvalidOperationException quando il framework tenta di costruire un'istanza di TransientDisposableService.

Rilevare gli eliminabili temporanei sul lato server

È possibile aggiungere codice personalizzato a un'app lato server per rilevare i servizi temporanei eliminabili sul Blazor lato server in un'app che deve usare OwningComponentBase. Questo approccio è utile se si è preoccupati che il codice aggiunto all'app in futuro utilizza uno o più servizi eliminabili temporanei, inclusi i servizi aggiunti dalle librerie. Il codice dimostrativo è disponibile nel Blazor repository GitHub degli esempi (come scaricare).

Esaminare quanto segue in .NET 8 o versioni successive dell'esempio BlazorSample_BlazorWebApp :

Esaminare quanto segue nelle versioni di .NET 6 o .NET 7 dell'esempio BlazorSample_Server :

• DetectIncorrectUsagesOfTransientDisposables.cs
• Services/TransitiveTransientDisposableDependency.cs:
• In Program.cs:
  • Lo spazio dei nomi dell'app Services viene fornito all'inizio del file (using BlazorSample.Services;).
  • DetectIncorrectUsageOfTransients viene chiamato sul generatore host (builder.DetectIncorrectUsageOfTransients();).
  • Il TransientDependency servizio è registrato (builder.Services.AddTransient<TransientDependency>();).
  • L'oggetto TransitiveTransientDisposableDependency è registrato per ITransitiveTransientDisposableDependency (builder.Services.AddTransient<ITransitiveTransientDisposableDependency, TransitiveTransientDisposableDependency>();).
• L'app registra il TransientDependency servizio senza generare un'eccezione. Tuttavia, il tentativo di risolvere il servizio in TransientService.razor genera un'eccezione InvalidOperationException quando il framework tenta di costruire un'istanza di TransientDependency.

Registrazioni di servizi temporanei per IHttpClientFactory/HttpClient i gestori

È consigliabile registrare i servizi temporanei per IHttpClientFactory/HttpClient i gestori. Se l'app contiene IHttpClientFactory/HttpClient gestori e usa IRemoteAuthenticationBuilder<TRemoteAuthenticationState,TAccount> per aggiungere il supporto per l'autenticazione, vengono individuati anche gli eliminabili temporanei seguenti per l'autenticazione lato client, che è previsto e possono essere ignorati:

• BaseAddressAuthorizationMessageHandler
• AuthorizationMessageHandler

Vengono individuate anche altre istanze di IHttpClientFactory/HttpClient . Queste istanze possono anche essere ignorate.

Le Blazor app di esempio nel Blazor repository GitHub di esempi (come scaricare) illustrano il codice per rilevare eliminazioni temporanee. Tuttavia, il codice viene disattivato perché le app di esempio includono IHttpClientFactory/HttpClient gestori.

Per attivare il codice dimostrativo e verificare l'operazione:

• Rimuovere il commento dalle linee eliminabili temporanee in Program.cs.

• Rimuovere il controllo NavLink.razor condizionale che impedisce la visualizzazione del TransientService componente nella barra laterale di spostamento dell'app:

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

• Eseguire l'app di esempio e passare al TransientService componente in /transient-service.

I gestori di attività del circuito forniscono un approccio per l'accesso ai servizi con Blazor ambito da altriBlazor ambiti di inserimento delle dipendenze (DI), ad esempio gli ambiti creati usando IHttpClientFactory.

Prima del rilascio di ASP.NET Core in .NET 8, accedere ai servizi con ambito circuito da altri ambiti di inserimento delle dipendenze necessari usando un tipo di componente di base personalizzato. Con i gestori di attività del circuito, non è necessario un tipo di componente di base personalizzato, come illustrato nell'esempio seguente:

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

Accedere ai servizi con ambito circuito inserendo dove CircuitServicesAccessor è necessario.

Per un esempio che illustra come accedere AuthenticationStateProvider a da una DelegatingHandler configurazione usando IHttpClientFactory, vedere Scenari di sicurezza aggiuntivi sul lato server ASP.NET CoreBlazor.

In alcuni casi un Razor componente richiama metodi asincroni che eseguono codice in un ambito di inserimento delle dipendenze diverso. Senza l'approccio corretto, questi ambiti di inserimento delle dipendenze non hanno accesso ai Blazorservizi di , ad esempio IJSRuntime e Microsoft.AspNetCore.Components.Server.ProtectedBrowserStorage.

Ad esempio, HttpClient le istanze create con IHttpClientFactory hanno un proprio ambito di servizio di inserimento delle dipendenze. Di conseguenza, HttpMessageHandler le istanze configurate in HttpClient non sono in grado di inserire Blazor direttamente i servizi.

Creare una classe BlazorServiceAccessor che definisce un AsyncLocaloggetto , che archivia l'oggetto BlazorIServiceProvider per il contesto asincrono corrente. È possibile acquisire un'istanza BlazorServiceAccessor dall'interno di un ambito di servizio di inserimento delle dipendenze diverso per accedere ai Blazor servizi.

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

Per impostare automaticamente il valore di BlazorServiceAccessor.Services quando viene richiamato un async metodo componente, creare un componente di base personalizzato che implementi nuovamente i tre punti di ingresso asincroni primari nel Razor codice del componente:

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

La classe seguente illustra l'implementazione per il componente di 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;
        }
    }
}

Tutti i componenti che CustomComponentBase si estendono automaticamente sono BlazorServiceAccessor.Services impostati su IServiceProvider nell'ambito di inserimento delle dipendenze corrente Blazor .

Infine, nel Program file aggiungere come BlazorServiceAccessor servizio con ambito:

builder.Services.AddScoped<BlazorServiceAccessor>();

Infine, in Startup.ConfigureServices di Startup.csaggiungere come BlazorServiceAccessor servizio con ambito:

services.AddScoped<BlazorServiceAccessor>();

• Inserimento del servizio tramite un file di importazione di primo livello (_Imports.razor) in Blazor Web Apps
• Inserimento delle dipendenze in ASP.NET Core
• IDisposable indicazioni per le istanze temporanee e condivise
• Inserimento di dipendenze in viste in ASP.NET Core
• Costruttori primari (Guida per C#)

• Inserimento delle dipendenze in ASP.NET Core
• IDisposable indicazioni per le istanze temporanee e condivise
• Inserimento di dipendenze in viste in ASP.NET Core