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: Für {PROPERTY} des Typs '{ASSEMBLY}}.Client.Pages.{COMPONENT NAME}' kann kein Wert angegeben 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 die Voreinstellung für die Komponente nicht erforderlich ist, deaktivieren Sie die Voreinstellung, indem Sie den Anweisungen in Prerender ASP.NET Core-Komponenten Razorfolgen. Wenn Sie diesen Ansatz übernehmen, müssen Sie den Dienst nicht im Hauptprojekt registrieren.

Weitere Informationen finden Sie im Abschnitt Client-side services fail to resolve during prerendering des Prerendering-Artikels, der später in der Blazor Dokumentation erscheint.

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

Konstruktorinjektion

Nachdem die Dienste der Dienstsammlung hinzugefügt wurden, injizieren Sie einen oder mehrere Dienste per Konstruktorinjektion in Komponenten. 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

Dienstinjektion über eine Top-Level-Importdatei (_Imports.razor)

Dieser Abschnitt gilt nur für Blazor Web Apps.

Eine Importdatei auf oberster Ebene im Ordner Components (Components/_Imports.razor) fügt ihre Verweise in alle Komponenten in der Ordnerhierarchie ein, die die App-Komponente (App.razor) enthält. Die App Komponente wird immer statisch gerendert, auch wenn die Voreinstellung einer Seitenkomponente deaktiviert ist. Daher führt das Einfügen von Diensten über die Importdatei der obersten Ebene dazu, zwei Instanzen des Diensts in Seitenkomponenten aufzulösen.

Um dieses Szenario zu beheben, fügen Sie den Dienst in eine neue Importdatei ein, die im Ordner Pages (Components/Pages/_Imports.razor) platziert wird. Von diesem Speicherort aus wird der Dienst nur einmal in Seitenkomponenten aufgelöst.

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, bei der Abhängigkeitsinjektion die Registrierung und Nutzung von Diensten einzugrenzen. 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>();
    }
}

Clientseitige temporäre Wegwerfobjekte erkennen

Benutzerdefinierter Code kann einer clientseitigen Blazor-App hinzugefügt werden, um transiente Einwegdienste in einer App zu erkennen, für die OwningComponentBase verwendet werden sollte. Dieser Ansatz ist nützlich, wenn Sie befürchten, dass Code, der der App künftig hinzugefügt wird, einen oder mehrere transiente disposable Dienste verwendet, einschließlich Diensten, 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 auf dem erstellten Host in der Verarbeitungspipeline der Anwendung 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.

Erkennen serverseitiger kurzlebiger Disposable-Objekte

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 künftig hinzugefügt wird, einen oder mehrere transiente disponierbare Dienste verwendet, auch solche, 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 im Host-Builder 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:

• Entkommentieren Sie die Zeilen für transiente Disposable-Objekte in Program.cs.

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

  - && (c.Name != "TransientService")
  

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

Die Blazor-Beispiel-Apps im BlazorGitHub-Repository „samples“ (Herunterladen) zeigen, wie sich transiente Disposable-Objekte im Code erkennen lassen. Führen Sie die Beispiel-App aus, und navigieren Sie zur TransientService-Komponente unter /transient-service.

Schaltkreisaktivitätshandler bieten einen Ansatz für den Zugriff auf bereichsbezogene Blazor Dienste aus anderen Nicht-Abhängigkeitsinjektionen (DI)-Blazor Bereichen.

Vor der Veröffentlichung von ASP.NET Core in .NET 8 erforderte der Zugriff auf Dienste mit auf den Circuit begrenztem Gültigkeitsbereich aus anderen Dependency-Injection-Bereichen einen benutzerdefinierten Basiskomponententyp. 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;
    }
}

Rufen Sie AddCircuitServicesAccessor in der Datei Program der App auf:

builder.Services.AddCircuitServicesAccessor();

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

Ein Beispiel dafür, wie Sie aus einem mit eingerichteten Blazor auf AuthenticationStateProvider zugreifen, finden Sie beim Ansatz mit dem Circuit Activity Handler in DelegatingHandler.

Es kann Situationen geben, in denen eine Razor-Komponente asynchrone Methoden aufruft, die Code in einem anderen DI-Scope 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 HttpClient erstellte IHttpClientFactory-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 abschließend in Startup.ConfigureServices von Startup.csBlazorServiceAccessor als bereichsbezogenen Dienst hinzu:

services.AddScoped<BlazorServiceAccessor>();

• Abhängigkeitsinjektion in ASP.NET Core
• IDisposableAnleitung für temporäre und gemeinsam genutzte Instanzen
• Dependency Injection in Ansichten in ASP.NET Core
• Primäre Konstruktoren (C#-Leitfaden)

• Abhängigkeitsinjektion in ASP.NET Core
• IDisposableAnleitung für temporäre und gemeinsam genutzte Instanzen
• Dependency Injection in Ansichten in ASP.NET Core