ASP.NET Kernafhankelijkheidsinjectie 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>();

Nadat u een nieuwe app hebt gemaakt, bekijkt u de Startup.ConfigureServices methode in Startup.cs:

using Microsoft.Extensions.DependencyInjection;

...

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

De ConfigureServices-methode krijgt een IServiceCollection doorgegeven, wat een lijst is van servicedescriptor-objecten. Services worden toegevoegd in de ConfigureServices methode door servicebeschrijvingen aan de servicecollectie te verstrekken. In het volgende voorbeeld ziet u het concept met de IDataAccess interface en de concrete implementatie DataAccess:

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

Services aan de clientzijde die mislukken tijdens het prerendering

Deze sectie is alleen van toepassing op WebAssembly-onderdelen in Blazor Web Apps.

Blazor Web Appnormaliter worden WebAssembly-componenten aan de clientkant vooraf gerenderd. Als een app wordt uitgevoerd met een vereiste service die alleen is geregistreerd in het .Client project, resulteert het uitvoeren van de app in een runtimefout die vergelijkbaar is met het volgende wanneer een onderdeel de vereiste service probeert te gebruiken tijdens het voorbereiden:

InvalidOperationException: Kan geen waarde opgeven voor {PROPERTY} voor het type {ASSEMBLY}}. Client.Pages. {COMPONENT NAME}'. Er is geen geregistreerde service van het type {SERVICE}.

Gebruik een van de volgende methoden om dit probleem op te lossen:

• Registreer de service in het hoofdproject om deze beschikbaar te maken tijdens het voorbereiden van onderdelen.
• Als prerendering niet vereist is voor het onderdeel, schakelt u prerendering uit door de richtlijnen in ASP.NET Core-rendermodi Blazorte volgen. Als u deze aanpak gebruikt, hoeft u de service niet te registreren in het hoofdproject.

Zie Services aan de clientzijde kunnen niet worden omgezet tijdens het prerendering voor meer informatie.

Voor het injecteren van services in onderdelen ondersteunt Blazorconstructorinjectie en eigenschapsinjectie.

Constructorinjectie

Nadat de services aan de serviceverzameling zijn toegevoegd, kunt u een of meer services in de componenten injecteren met behulp van constructorinjectie. In het volgende voorbeeld wordt de NavigationManager service geïnjecteerd.

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

Eigenschapsinjectie

Diensten met sleutels in componenten invoegen

Blazor ondersteunt het injecteren van keyed services met behulp van het [Inject] kenmerk. Met sleutels kunt u het bereik van de registratie en het verbruik van services bepalen bij het gebruik van afhankelijkheidsinjectie. Gebruik de InjectAttribute.Key eigenschap om de sleutel voor de service op te geven die moet worden geïnjecteerd:

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

Tijdelijke wegwerpjes aan de clientzijde detecteren

Aangepaste code kan worden toegevoegd aan een app aan de clientzijde Blazor om tijdelijke wegwerpservices te detecteren in een app die moet worden gebruikt OwningComponentBase. Deze aanpak is handig als u zich zorgen maakt dat code die in de toekomst aan de app wordt toegevoegd, een of meer tijdelijke wegwerpservices verbruikt, inclusief services die zijn toegevoegd door bibliotheken. Demonstratiecode is beschikbaar in de Blazor GitHub-voorbeeldopslagplaats (downloaden).

Controleer het volgende in .NET 6 of nieuwere versies van het BlazorSample_WebAssembly voorbeeld:

• DetectIncorrectUsagesOfTransientDisposables.cs
• Services/TransientDisposableService.cs
• In Program.cs:
  • De naamruimte van Services de app wordt boven aan het bestand (using BlazorSample.Services;) opgegeven.
  • DetectIncorrectUsageOfTransients wordt onmiddellijk aangeroepen nadat de opdracht aan builder is toegewezen van WebAssemblyHostBuilder.CreateDefault.
  • De TransientDisposableService is geregistreerd (builder.Services.AddTransient<TransientDisposableService>();).
  • EnableTransientDisposableDetection wordt aangeroepen op de ingebouwde host in de verwerkingspijplijn van de app (host.EnableTransientDisposableDetection();).
• De app registreert de TransientDisposableService service zonder een uitzondering te genereren. Als u echter probeert de service in TransientService.razor te resolved, werpt het framework een InvalidOperationException wanneer het framework probeert een instantie van TransientDisposableService te construeren.

Tijdelijke wegwerpartikelen aan serverzijde detecteren

Aangepaste code kan worden toegevoegd aan een serverzijde app Blazor om wegwerpbare tijdelijke services aan de serverzijde te detecteren in een app die gebruik moet maken van OwningComponentBase. Deze aanpak is handig als u zich zorgen maakt dat code die in de toekomst aan de app wordt toegevoegd, een of meer tijdelijke wegwerpservices verbruikt, inclusief services die zijn toegevoegd door bibliotheken. Demonstratiecode is beschikbaar in de Blazor GitHub-voorbeeldopslagplaats (downloaden).

Controleer het volgende in .NET 8 of nieuwere versies van het BlazorSample_BlazorWebApp voorbeeld:

Controleer het volgende in .NET 6- of .NET 7-versies van het BlazorSample_Server voorbeeld:

• DetectIncorrectUsagesOfTransientDisposables.cs
• Services/TransitiveTransientDisposableDependency.cs:
• In Program.cs:
  • De naamruimte van Services de app wordt boven aan het bestand (using BlazorSample.Services;) opgegeven.
  • DetectIncorrectUsageOfTransients wordt aangeroepen op de host-builder (builder.DetectIncorrectUsageOfTransients();).
  • De TransientDependency dienst is geregistreerd (builder.Services.AddTransient<TransientDependency>();).
  • De TransitiveTransientDisposableDependency is geregistreerd voor ITransitiveTransientDisposableDependency (builder.Services.AddTransient<ITransitiveTransientDisposableDependency, TransitiveTransientDisposableDependency>();).
• De app registreert de TransientDependency service zonder een uitzondering te genereren. Als u echter probeert de service in TransientService.razor te resolved, werpt het framework een InvalidOperationException wanneer het framework probeert een instantie van TransientDependency te construeren.

Tijdelijke serviceregistraties voor IHttpClientFactory/HttpClient verwerkers

Tijdelijke serviceregistraties voor IHttpClientFactory/HttpClient handlers worden aanbevolen. Als de app IHttpClientFactory/HttpClient handlers bevat en de IRemoteAuthenticationBuilder<TRemoteAuthenticationState,TAccount> ondersteuning voor authenticatie toevoegt, worden ook de volgende tijdelijke elementen voor authenticatie aan de clientzijde gedetecteerd. Dit wordt verwacht en kan worden genegeerd.

• BaseAddressAuthorizationMessageHandler
• AuthorizationMessageHandler

Er worden ook andere gevallen IHttpClientFactory/HttpClient ontdekt. Deze gevallen kunnen ook worden genegeerd.

In de Blazor voorbeeld-apps in de Blazor GitHub-opslagplaats met voorbeelden (hoe te downloaden) wordt de code gedemonstreerd om tijdelijke disposables te detecteren. De code wordt echter gedeactiveerd omdat de voorbeeld-apps handlers bevatten IHttpClientFactory/HttpClient .

Om de demonstratiecode te activeren en de werking te bekijken:

• Verwijder de opmerkingen bij de tijdelijke wegwerplijnen in Program.cs.

• Verwijder de voorwaardelijke controle in NavLink.razor die voorkomt dat het TransientService component wordt weergegeven in de navigatiezijbalk van de app.

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

• Voer de voorbeeld-app uit en navigeer naar het TransientService onderdeel op /transient-service.

Circuitactiviteit-handlers bieden een benadering voor toegang tot scoped Blazor services vanuit andere scopes die geen gebruik maken van afhankelijkheidsinjectie (DI), zoals scopes die zijn gemaakt met behulp van Blazor.

Voordat ASP.NET Core in .NET 8 werd uitgebracht, vereiste het gebruik van een aangepast basisonderdeeltype om toegang te krijgen tot services binnen het groepenbereik van andere afhankelijkheidsinjectiebereiken. Bij circuitactiviteitshandlers is een aangepast basisonderdeeltype niet vereist, zoals in het volgende voorbeeld wordt gedemonstreert:

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

Roep AddCircuitServicesAccessor aan in het Program bestand van de app.

builder.Services.AddCircuitServicesAccessor();

Krijg toegang tot de diensten met circuit-scope door de CircuitServicesAccessor te injecteren waar dit nodig is.

Zie voor een voorbeeld dat laat zien hoe u toegang krijgt tot de AuthenticationStateProvider vanuit een op DelegatingHandler gebaseerde configuratie met behulp van IHttpClientFactory, ASP.NET Core-server en Blazor Web App aanvullende beveiligingsscenario's.

Het kan voorkomen dat een Razor onderdeel asynchrone methoden aanroept die code uitvoeren in een ander DI-bereik. Zonder de juiste aanpak hebben deze DI-bereiken geen toegang tot Blazor's services, zoals IJSRuntime en Microsoft.AspNetCore.Components.Server.ProtectedBrowserStorage.

Bijvoorbeeld, exemplaren die zijn gemaakt met behulp van HttpClient, hebben hun eigen DI-servicebereik IHttpClientFactory. Als gevolg hiervan kunnen HttpMessageHandler-instanties die zijn geconfigureerd op de HttpClient, de Blazor-services niet rechtstreeks injecteren.

Maak een klasse BlazorServiceAccessor die een AsyncLocal definieert, welke de BlazorIServiceProvider voor de huidige asynchrone context opslaat. Een BlazorServiceAccessor instantie kan worden verkregen binnen een ander DI-servicecontext om toegang te krijgen tot Blazor-services.

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

Als u de waarde automatisch BlazorServiceAccessor.Services wilt instellen wanneer een async onderdeelmethode wordt aangeroepen, maakt u een aangepast basisonderdeel waarmee de drie primaire asynchrone toegangspunten opnieuw worden geïmplementeerd in Razor onderdeelcode:

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

In de volgende klasse ziet u de implementatie voor het basisonderdeel.

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

Alle componenten die CustomComponentBase uitbreiden, hebben BlazorServiceAccessor.Services automatisch ingesteld op IServiceProvider in het huidige Blazor DI-bereik.

Voeg ten slotte in het Program bestand de BlazorServiceAccessor als een scoped service toe:

builder.Services.AddScoped<BlazorServiceAccessor>();

Voeg ten slotte in Startup.ConfigureServices van Startup.cs de BlazorServiceAccessor als een scoped service toe.

services.AddScoped<BlazorServiceAccessor>();

• Service-injectie via een importbestand op het hoogste niveau (_Imports.razor) in Blazor Web Apps
• Afhankelijkheidsinjectie in ASP.NET Core
• IDisposable richtlijnen voor tijdelijke en gedeelde exemplaren
• Invoeging van afhankelijkheden in weergaven in ASP.NET Core
• Primaire constructors (C#-handleiding)

• Afhankelijkheidsinjectie in ASP.NET Core
• IDisposable richtlijnen voor tijdelijke en gedeelde exemplaren
• Invoeging van afhankelijkheden in weergaven in ASP.NET Core