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

När du har skapat en ny app undersöker du Startup.ConfigureServices metoden i Startup.cs:

using Microsoft.Extensions.DependencyInjection;

...

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

Metoden ConfigureServices skickas en IServiceCollection, vilket är en lista över objekt för tjänstbeskrivare. Tjänster läggs till i ConfigureServices metoden genom att tillhandahålla tjänstbeskrivningar till tjänstsamlingen. I följande exempel visas konceptet med IDataAccess gränssnittet och dess konkreta implementering DataAccess:

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

Tjänster på klientsidan som misslyckas under prerendering

Det här avsnittet gäller endast WebAssembly-komponenter i Blazor Web Apps.

Blazor Web Apps normalt sett prerenderar klient-sidan dessa WebAssembly-komponenter. Om en app körs med en obligatorisk tjänst som endast är registrerad i .Client projektet resulterar körningen av appen i ett körningsfel som liknar följande när en komponent försöker använda den nödvändiga tjänsten under förinläsningen:

InvalidOperationException: Det går inte att ange ett värde för {PROPERTY} på typen {ASSEMBLY}}. Client.Pages. {KOMPONENTNAMN}'. Det finns ingen registrerad tjänst av typen {SERVICE}.

Använd någon av följande metoder för att lösa problemet:

• Registrera tjänsten i huvudprojektet för att göra den tillgänglig under komponentförbeläsningen.
• Om förrendering inte krävs för komponenten inaktiverar du prerendering genom att följa riktlinjerna i Prerender ASP.NET Core-komponenterRazor. Om du använder den här metoden behöver du inte registrera tjänsten i huvudprojektet.

Mer information finns i avsnittet Om tjänster på klientsidan inte kan lösas under prerendering i artikeln Prerendering , som visas senare i dokumentationen Blazor .

För att mata in tjänster i komponenter, Blazor stöder konstruktorinmatning och egenskapsinmatning.

Konstruktorinjektion

När tjänster har lagts till i tjänstsamlingen matar du in en eller flera tjänster i komponenter med konstruktorinmatning. I följande exempel matas tjänsten NavigationManager in.

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

Egenskapsinmatning

Tjänstinmatning via en importfil på toppnivå (_Imports.razor)

Det här avsnittet gäller endast Blazor Web Apps.

En importfil på den översta nivån i mappen Components (Components/_Imports.razor) matar in sina referenser i alla komponenter i mapphierarkin, som innehåller komponenten App (App.razor). Komponenten App återges alltid statiskt även om prerendering av en sidkomponent är inaktiverad. Genom att mata in tjänster via den översta importfilen kan du därför lösa två instanser av tjänsten i sidkomponenter.

Åtgärda det här scenariot genom att mata in tjänsten i en ny importfil som placeras i mappen Pages (Components/Pages/_Imports.razor). Från denna plats löses tjänsten bara en gång för sidkomponenterna.

Mata in nyckelade tjänster i komponenter

Blazor stöder inmatning av nyckelade tjänster med hjälp av attributet [Inject] . Nycklar möjliggör begränsning av registrering och konsumtion av tjänster när du använder dependency injection. Använd egenskapen InjectAttribute.Key för att ange nyckeln för tjänsten som ska matas in:

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

Identifiera tillfälliga engångsartiklar på klientsidan

Anpassad kod kan läggas till i en app på klientsidan Blazor för att identifiera disponibla tillfälliga tjänster i en app som ska använda OwningComponentBase. Den här metoden är användbar om du är orolig för att kod som läggs till i appen i framtiden förbrukar en eller flera tillfälliga disponibla tjänster, inklusive tjänster som läggs till av bibliotek. Demonstrationskod är tillgänglig på Blazor GitHub-exempellagringsplatsen (så här laddar du ned).

Granska följande i .NET 6 eller senare versioner av BlazorSample_WebAssembly exemplet:

• DetectIncorrectUsagesOfTransientDisposables.cs
• Services/TransientDisposableService.cs
• I Program.cs:
  • Appens Services namnområde finns överst i filen (using BlazorSample.Services;).
  • DetectIncorrectUsageOfTransients anropas omedelbart efter att builder har tilldelats från WebAssemblyHostBuilder.CreateDefault.
  • TransientDisposableService är registrerad (builder.Services.AddTransient<TransientDisposableService>();).
  • EnableTransientDisposableDetection anropas på den inbyggda värden i appens bearbetningspipeline (host.EnableTransientDisposableDetection();).
• Appen registrerar TransientDisposableService tjänsten utan att utlösa ett undantag. Men om du försöker lösa tjänsten i TransientService.razor genereras en InvalidOperationException när ramverket försöker konstruera en instans av TransientDisposableService.

Identifiera tillfälliga objekt för borttagning på serversidan

Anpassad kod kan läggas till en serverside Blazor app för att identifiera tillfälliga disponibla tjänster på serversidan i en app som ska använda OwningComponentBase. Den här metoden är användbar om du är orolig för att kod som läggs till i appen i framtiden förbrukar en eller flera tillfälliga disponibla tjänster, inklusive tjänster som läggs till av bibliotek. Demonstrationskod är tillgänglig på Blazor GitHub-exempellagringsplatsen (så här laddar du ned).

Granska följande i .NET 8 eller senare versioner av BlazorSample_BlazorWebApp exemplet:

Granska följande i .NET 6- eller .NET 7-versioner av BlazorSample_Server exemplet:

• DetectIncorrectUsagesOfTransientDisposables.cs
• Services/TransitiveTransientDisposableDependency.cs:
• I Program.cs:
  • Appens Services namnområde finns överst i filen (using BlazorSample.Services;).
  • DetectIncorrectUsageOfTransients anropas på värdverktyget (builder.DetectIncorrectUsageOfTransients();).
  • Tjänsten TransientDependency är registrerad (builder.Services.AddTransient<TransientDependency>();).
  • TransitiveTransientDisposableDependency är registrerad för ITransitiveTransientDisposableDependency (builder.Services.AddTransient<ITransitiveTransientDisposableDependency, TransitiveTransientDisposableDependency>();).
• Appen registrerar TransientDependency tjänsten utan att utlösa ett undantag. Men om du försöker lösa tjänsten i TransientService.razor genereras en InvalidOperationException när ramverket försöker konstruera en instans av TransientDependency.

Tillfälliga tjänstregistreringar för IHttpClientFactory/HttpClient hanterare

Tillfälliga tjänstregistreringar för IHttpClientFactory/HttpClient hanterare rekommenderas. Om appen innehåller IHttpClientFactory/HttpClient hanterare och använder IRemoteAuthenticationBuilder<TRemoteAuthenticationState,TAccount> för att lägga till stöd för autentisering identifieras även följande tillfälliga engångsartiklar för autentisering på klientsidan, vilket förväntas och kan ignoreras:

• BaseAddressAuthorizationMessageHandler
• AuthorizationMessageHandler

Andra instanser av IHttpClientFactory/HttpClient identifieras också. Dessa fall kan också ignoreras.

Exempelapparna BlazorBlazor i GitHub-exempellagringsplatsen (hur du laddar ned) visar koden för att identifiera tillfälliga engångsartiklar. Koden inaktiveras dock eftersom exempelapparna innehåller IHttpClientFactory/HttpClient hanterare.

Så här aktiverar du demonstrationskoden och bevittnar dess åtgärd:

• Avkommentera de tillfälliga disponibla linjerna i Program.cs.

• Ta bort det villkorsbaserade testet i NavLink.razor som förhindrar att komponenten TransientService visas i appens navigeringssidofält.

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

• Kör exempelappen och navigera till komponenten TransientService på /transient-service.

Kretsaktivitetshanterare tillhandahåller en metod för att komma åt avgränsade Blazor tjänster från andra icke-DI omfång, såsom omfång skapade med Blazor.

Innan släppet av ASP.NET Core i .NET 8 krävde åtkomst till tjänster med kretsområde från andra beroendeinjiceringomfång att man använder en anpassad baskomponenttyp. Med kretsaktivitetshanterare krävs ingen anpassad baskomponenttyp, vilket visas i följande exempel:

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

Anropa AddCircuitServicesAccessor i appens Program fil:

builder.Services.AddCircuitServicesAccessor();

Få åtkomst till de kretsomfattande tjänsterna genom att injicera dem där de CircuitServicesAccessor behövs.

Ett exempel som visar hur du kommer åt AuthenticationStateProvider från en DelegatingHandler-konfiguration med hjälp av IHttpClientFactory finns i ASP.NET Core-serversidan och Blazor Web App ytterligare säkerhetsscenarier.

Det kan finnas tillfällen när en Razor komponent anropar asynkrona metoder som kör kod i ett annat DI-omfång. Utan korrekt angreppssätt har dessa DI-omfång inte åtkomst till Blazors tjänster, såsom IJSRuntime och Microsoft.AspNetCore.Components.Server.ProtectedBrowserStorage.

Till exempel HttpClient har instanser som skapats med hjälp av IHttpClientFactory sitt eget DI-tjänstomfång. Det innebär att HttpMessageHandler instanser som konfigurerats på HttpClient inte kan injicera Blazor tjänster direkt.

Skapa en klass BlazorServiceAccessor som definierar en AsyncLocal, som lagrar BlazorIServiceProvider för den aktuella asynkrona kontexten. En BlazorServiceAccessor instans kan hämtas från ett annat DI-tjänstomfång för att få åtkomst till Blazor tjänster.

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

Om du vill ange värdet BlazorServiceAccessor.Services för automatiskt när en async komponentmetod anropas skapar du en anpassad baskomponent som implementerar om de tre primära asynkrona startpunkterna i Razor komponentkoden:

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

Följande klass visar implementeringen för baskomponenten.

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

Alla komponenter som utökar CustomComponentBase får automatiskt BlazorServiceAccessor.Services angivet till IServiceProvider i det aktuella DI-scope Blazor.

Lägg slutligen till Program som en begränsad tjänst i BlazorServiceAccessor filen:

builder.Services.AddScoped<BlazorServiceAccessor>();

Lägg slutligen till Startup.ConfigureServices som en begränsad tjänst i i :Startup.csBlazorServiceAccessor

services.AddScoped<BlazorServiceAccessor>();

• Beroendeinmatning i ASP.NET Core
• IDisposable vägledning för tillfälliga och delade instanser
• Beroendeinjektion i vyer i ASP.NET Core
• Primära konstruktorer (C#-guide)

• Beroendeinmatning i ASP.NET Core
• IDisposable vägledning för tillfälliga och delade instanser
• Beroendeinjektion i vyer i ASP.NET Core