Abhängigkeitsinjektion in ASP.NET Core Blazor

var builder = WebApplication.CreateBuilder(args);

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

var builder = WebApplication.CreateBuilder(args);

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

Nachdem Sie eine neue App erstellt haben, sehen Sie sich die Startup.ConfigureServices-Methode in Startup.cs an:

using Microsoft.Extensions.DependencyInjection;

...

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

Der Methode ConfigureServices wird ein IServiceCollection-Objekt übergeben, das eine Liste von Dienstdeskriptorobjekten ist. Dienste werden in der ConfigureServices-Methode durch Bereitstellung von Dienstdeskriptoren in der Dienstsammlung hinzugefügt. Das folgende Beispiel veranschaulicht das Konzept mit der IDataAccess-Schnittstelle und seiner konkreten Implementierung DataAccess:

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

Clientseitige Dienste, bei denen beim Prerendering ein Fehler auftritt

Dieser Abschnitt gilt nur für WebAssembly-Komponenten in Blazor Web Apps.

Blazor Web Apps führen in der Regel das Prerendering für clientseitige WebAssembly-Komponenten durch. Die Ausführung einer App mit einem erforderlichen Dienst, der nur im .Client-Projekt registriert ist, kann zu einem Laufzeitfehler ähnlich dem folgenden führen, wenn eine Komponente versucht, den erforderlichen Dienst während des Prerenderingvorgangs zu verwenden:

InvalidOperationException: Es kann kein Wert für {EIGENSCHAFT} für den Typ '{ASSEMBLY}}.Client.Pages.{KOMPONENTENNAME}' bereitgestellt werden. Es gibt keinen registrierten Dienst vom Typ '{DIENST}'.

Verwenden Sie einen der folgenden Ansätze, um das Problem zu beheben:

• Registrieren Sie den Dienst im Hauptprojekt, um ihn während des Prerenderingvorgangs für die Komponente verfügbar zu machen.
• Wenn für die Komponente kein Prerendering erforderlich ist, deaktivieren Sie das Prerendering, indem Sie die Anleitung im Artikel ASP.NET Core – Blazor-Rendermodi ausführen. Wenn Sie diesen Ansatz übernehmen, müssen Sie den Dienst nicht im Hauptprojekt registrieren.

Weitere Informationen finden Sie unter Clientseitige Dienste können während des Prerendering nicht aufgelöst werden.

Zum Einfügen von Diensten in Komponenten unterstützt Blazor Konstrukturinjektion und Eigenschafteninjektion.

Constructor Injection

Nachdem die Dienste zur Dienstsammlung hinzugefügt wurden, können Sie einen oder mehrere Dienste in Komponenten mit Konstruktorinjektion einfügen. Im folgenden Beispiel wird der Dienst NavigationManager eingefügt.

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

Eigenschaftsinjektion

Einfügen von schlüsselbasierten Diensten in Komponenten

Blazor unterstützt das Einfügen schlüsselbasierter Dienste mithilfe des [Inject]-Attributs. Schlüssel ermöglichen es, Bereiche für die Registrierung und für den Verbrauch von Diensten bei Verwendung der Abhängigkeitsinjektion festzulegen. Verwenden Sie die InjectAttribute.Key-Eigenschaft, um den Schlüssel für den Dienst anzugeben, der eingefügt werden soll:

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

Erkennung clientseitiger vorübergehender Elemente, die verworfen werden können

Benutzerdefinierter Code kann einer clientseitigen Blazor-App hinzugefügt werden, um verwerfbare vorübergehende Dienste in einer App zu erkennen, die OwningComponentBase verwenden sollte. Dieser Ansatz ist nützlich, wenn Sie befürchten, dass Code, der der App in Zukunft hinzugefügt wird, vorübergehende verwerfbare Dienste nutzt, einschließlich der Dienste, die von Bibliotheken hinzugefügt werden. Democode ist im Blazor-Beispiele-Repository auf GitHub verfügbar (Downloadanleitung).

Überprüfen Sie Folgendes in .NET 6 oder höheren Versionen des BlazorSample_WebAssembly-Beispiels:

• DetectIncorrectUsagesOfTransientDisposables.cs
• Services/TransientDisposableService.cs
• In: Program.cs
  • Der Services-Namespace der App wird oben in der Datei bereitgestellt (using BlazorSample.Services;).
  • DetectIncorrectUsageOfTransients wird unmittelbar aufgerufen, nachdem builder von WebAssemblyHostBuilder.CreateDefault zugewiesen wurde.
  • TransientDisposableService ist registriert (builder.Services.AddTransient<TransientDisposableService>();).
  • EnableTransientDisposableDetection wird für den integrierten Host in der Verarbeitungspipeline der App aufgerufen (host.EnableTransientDisposableDetection();).
• Die App registriert den Dienst TransientDisposableService, ohne eine Ausnahme zu auslösen. Beim Versuch, den Dienst in TransientService.razor aufzulösen, wird jedoch InvalidOperationException ausgelöst, wenn das Framework versucht, eine Instanz von TransientDisposableService zu erstellen.

Erkennung serverseitiger vorübergehender Elemente, die verworfen werden können

Benutzerdefinierter Code kann einer serverseitigen Blazor-App hinzugefügt werden, um serverseitige vorübergehende Dienste in einer App zu erkennen, die OwningComponentBase verwenden sollte. Dieser Ansatz ist nützlich, wenn Sie befürchten, dass Code, der der App in Zukunft hinzugefügt wird, vorübergehende verwerfbare Dienste nutzt, einschließlich der Dienste, die von Bibliotheken hinzugefügt werden. Democode ist im Blazor-Beispiele-Repository auf GitHub verfügbar (Downloadanleitung).

Überprüfen Sie Folgendes in .NET 8 oder höheren Versionen des BlazorSample_BlazorWebApp-Beispiels:

Überprüfen Sie Folgendes in .NET 6 oder .NET 7 des BlazorSample_Server-Beispiels:

• DetectIncorrectUsagesOfTransientDisposables.cs
• Services/TransitiveTransientDisposableDependency.cs:
• In: Program.cs
  • Der Services-Namespace der App wird oben in der Datei bereitgestellt (using BlazorSample.Services;).
  • DetectIncorrectUsageOfTransients wird für den Host-Generator aufgerufen (builder.DetectIncorrectUsageOfTransients();).
  • Der TransientDependency-Dienst ist registriert (builder.Services.AddTransient<TransientDependency>();).
  • TransitiveTransientDisposableDependency ist für ITransitiveTransientDisposableDependency registriert (builder.Services.AddTransient<ITransitiveTransientDisposableDependency, TransitiveTransientDisposableDependency>();).
• Die App registriert den Dienst TransientDependency, ohne eine Ausnahme zu auslösen. Beim Versuch, den Dienst in TransientService.razor aufzulösen, wird jedoch InvalidOperationException ausgelöst, wenn das Framework versucht, eine Instanz von TransientDependency zu erstellen.

Vorübergehende Dienstregistrierungen für IHttpClientFactory/HttpClient-Handler

Für IHttpClientFactory/HttpClient-Handler werden vorübergehende Dienstregistrierungen empfohlen. Wenn die App IHttpClientFactory/HttpClient-Handler enthält und zum Hinzufügen der Unterstützung für die Authentifizierung IRemoteAuthenticationBuilder<TRemoteAuthenticationState,TAccount> verwendet, werden auch die folgenden vorübergehenden verwerfbaren Elemente für die clientseitige Authentifizierung erkannt. Dies wird erwartet und kann ignoriert werden:

• BaseAddressAuthorizationMessageHandler
• AuthorizationMessageHandler

Andere Instanzen von IHttpClientFactory/HttpClient werden ebenfalls erkannt. Diese Instanzen können auch ignoriert werden.

Die Blazor-Beispiel-Apps im Blazor-Beispiele-Repository auf GitHub (Downloadanleitung) veranschaulichen den Code zum Erkennen von vorübergehend verwerfbaren Diensten. Der Code ist jedoch deaktiviert, da die Beispiel-Apps IHttpClientFactory/HttpClient-Handler enthalten.

So können Sie den Democode aktivieren und seine Ausführung sehen:

• Heben Sie die Auskommentierung der Zeilen für die vorübergehend verwerfbaren Dienste in Program.cs auf.

• Entfernen Sie die bedingte Überprüfung in NavLink.razor, die verhindert, dass die TransientService-Komponente in der Navigationsseitenleiste der App angezeigt wird:

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

• Führen Sie die Beispiel-App aus, und navigieren Sie zur TransientService-Komponente unter /transient-service.

Leitungsaktivitätshandler bieten auch einen Ansatz für den Zugriff auf bereichsbezogene Blazor-Dienste aus anderen, Blazor-fremden DI-Bereichen (Dependency Injection, Abhängigkeitsinjektion), etwa mithilfe von IHttpClientFactory erstellten Bereichen.

Vor der Veröffentlichung von ASP.NET Core in NET 8 war für den Zugriff auf Dienste im Leitungsbereich aus anderen Abhängigkeitsinjektionsbereichen ein benutzerdefinierter Basiskomponententyp erforderlich. Mit Leitungsaktivitätshandlern ist kein benutzerdefinierter Basiskomponententyp erforderlich, wie im folgenden Beispiel veranschaulicht:

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

Greifen Sie auf die Dienste im Leitungsbereich zu, indem Sie CircuitServicesAccessor dort einfügen, wo es erforderlich ist.

Ein Beispiel, das zeigt, wie Sie über einen mithilfe von IHttpClientFactory eingerichteten delegierenden Handler (DelegatingHandler) auf AuthenticationStateProvider zugreifen, finden Sie unterserverseitige zusätzliche Sicherheitsszenarios für ASP.NET Core Blazor.

Es kann vorkommen, dass eine Razor-Komponente asynchrone Methoden aufruft, die Code in einem anderen DI-Bereich (Dependency Injection, Abhängigkeitsinjektion) ausführen. Ohne den richtigen Ansatz haben diese DI-Bereiche keinen Zugriff auf die Dienste von Blazor (z. B IJSRuntime und Microsoft.AspNetCore.Components.Server.ProtectedBrowserStorage).

Mit IHttpClientFactory erstellte HttpClient-Instanzen verfügen beispielsweise über einen eigenen DI-Dienstbereich. Daher können HttpMessageHandler-Instanzen, die für den HttpClient konfiguriert sind, Blazor-Dienste nicht direkt injizieren.

Erstellen Sie eine BlazorServiceAccessor-Klasse, die eine AsyncLocal-Instanz zum Speichern des BlazorIServiceProvider für den aktuellen asynchronen Kontext definiert. Eine BlazorServiceAccessor-Instanz kann innerhalb eines anderen DI-Dienstbereichs abgerufen werden, um auf Blazor-Dienste zuzugreifen.

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

Um den Wert von BlazorServiceAccessor.Services automatisch festzulegen, wenn eine async-Komponentenmethode aufgerufen wird, erstellen Sie eine benutzerdefinierte Basiskomponente, die die drei primären asynchronen Einstiegspunkte erneut im Razor-Komponentencode implementiert:

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

Die folgende Klasse veranschaulicht die Implementierung für die Basiskomponente.

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

Für alle Komponenten, die CustomComponentBase erweitern, ist BlazorServiceAccessor.Services automatisch auf den IServiceProvider im aktuellen Blazor-DI-Bereich festgelegt.

Fügen Sie abschließend in der Program-Datei den BlazorServiceAccessor als bereichsbezogenen Dienst hinzu:

builder.Services.AddScoped<BlazorServiceAccessor>();

Fügen Sie zum Schluss in Startup.ConfigureServices von Startup.cs BlazorServiceAccessor als bereichsbezogenen Dienst hinzu:

services.AddScoped<BlazorServiceAccessor>();

• Dienstinjektion über eine Importdatei der obersten Ebene (_Imports.razor) in Blazor Web Apps
• Abhängigkeitsinjektion in ASP.NET Core
• IDisposable-Anleitung für vorübergehende and freigegebene Instanzen
• Dependency Injection in Ansichten in ASP.NET Core
• Primäre Konstruktoren (C#-Leitfaden)

• Abhängigkeitsinjektion in ASP.NET Core
• IDisposable-Anleitung für vorübergehende and freigegebene Instanzen
• Dependency Injection in Ansichten in ASP.NET Core