Serviceregistratie

In dit artikel worden groepen services en door framework geleverde services geregistreerd. Het biedt ook informatie over de serviceregistratie-extensiemethoden die .NET biedt.

Registreren van groepen services met extensiemethoden

.NET maakt gebruik van een conventie voor het registreren van een groep gerelateerde services. De conventie is om één Add{GROUP_NAME} extensiemethode te gebruiken om alle services te registreren die zijn vereist voor een frameworkfunctie. Met de AddOptions extensiemethode worden bijvoorbeeld alle services geregistreerd die vereist zijn voor het gebruik van opties.

Door framework geleverde services

Wanneer u een van de beschikbare host- of app-builder-patronen gebruikt, worden standaardwaarden toegepast en worden services geregistreerd door het framework. Bekijk enkele van de populairste host- en app-builder-patronen:

• Host.CreateDefaultBuilder()
• Host.CreateApplicationBuilder()
• WebHost.CreateDefaultBuilder()
• WebApplication.CreateBuilder()
• WebAssemblyHostBuilder.CreateDefault
• MauiApp.CreateBuilder

Nadat u een opbouwfunctie hebt gemaakt op basis van een van deze API's, zijn de IServiceCollection services gedefinieerd door het framework, afhankelijk van de manier waarop u de host hebt geconfigureerd. Voor apps op basis van de .NET-sjablonen kan het framework honderden services registreren.

De volgende tabel bevat een klein voorbeeld van deze framework-geregistreerde services:

Registratiemethoden

Het framework biedt methoden voor serviceregistratie-extensies die nuttig zijn in specifieke scenario's:

Voor meer informatie over verwijdering van typen, zie Verwijdering van diensten.

Het registreren van een service met alleen een implementatietype is gelijk aan het registreren van die service met hetzelfde implementatie- en servicetype. Denk bijvoorbeeld aan de volgende code:

services.AddSingleton<ExampleService>();

Dit komt overeen met het registreren van de service bij zowel de service als de implementatie van dezelfde typen:

services.AddSingleton<ExampleService, ExampleService>();

Deze equivalentie is waarom meerdere implementaties van een service niet kunnen worden geregistreerd met behulp van de methoden die geen expliciet servicetype gebruiken. Met deze methoden kunnen meerdere exemplaren van een service worden geregistreerd, maar ze hebben allemaal hetzelfde type implementatie.

Elk van de serviceregistratiemethoden kan worden gebruikt om meerdere service-exemplaren van hetzelfde servicetype te registreren. In het volgende voorbeeld wordt AddSingleton twee keer aangeroepen met IMessageWriter als servicetype. De tweede aanroep van AddSingleton overschrijft de vorige wanneer het als IMessageWriter wordt opgelost en wordt aan de vorige toegevoegd wanneer meerdere services worden opgelost via IEnumerable<IMessageWriter>. Services worden weergegeven in de volgorde waarin ze zijn geregistreerd wanneer ze via IEnumerable<{SERVICE}>worden opgelost.

using ConsoleDI.IEnumerableExample;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;

HostApplicationBuilder builder = Host.CreateApplicationBuilder(args);

builder.Services.AddSingleton<IMessageWriter, ConsoleMessageWriter>();
builder.Services.AddSingleton<IMessageWriter, LoggingMessageWriter>();
builder.Services.AddSingleton<ExampleService>();

using IHost host = builder.Build();

_ = host.Services.GetService<ExampleService>();

await host.RunAsync();

De voorgaande voorbeeldbroncode registreert twee implementaties van de IMessageWriter.

using System.Diagnostics;

namespace ConsoleDI.IEnumerableExample;

public sealed class ExampleService
{
    public ExampleService(
        IMessageWriter messageWriter,
        IEnumerable<IMessageWriter> messageWriters)
    {
        Trace.Assert(messageWriter is LoggingMessageWriter);

        var dependencyArray = messageWriters.ToArray();
        Trace.Assert(dependencyArray[0] is ConsoleMessageWriter);
        Trace.Assert(dependencyArray[1] is LoggingMessageWriter);
    }
}

Hiermee ExampleService worden twee constructorparameters gedefinieerd: één IMessageWriter, en een IEnumerable<IMessageWriter>. De single IMessageWriter is de laatste implementatie die moet worden geregistreerd, terwijl de IEnumerable<IMessageWriter> implementatie alle geregistreerde implementaties vertegenwoordigt.

Het framework biedt TryAdd{LIFETIME} ook uitbreidingsmethoden, waarmee de service alleen wordt geregistreerd als er nog geen implementatie is geregistreerd.

In het volgende voorbeeld wordt de aanroep om te AddSingleton registreren ConsoleMessageWriter als een implementatie voor IMessageWriter. De aanroep heeft TryAddSingleton geen effect omdat IMessageWriter er al een geregistreerde implementatie is:

services.AddSingleton<IMessageWriter, ConsoleMessageWriter>();
services.TryAddSingleton<IMessageWriter, LoggingMessageWriter>();

Het TryAddSingleton heeft geen effect, omdat deze al is toegevoegd en het 'proberen' mislukt. De ExampleService beweringen zijn:

public class ExampleService
{
    public ExampleService(
        IMessageWriter messageWriter,
        IEnumerable<IMessageWriter> messageWriters)
    {
        Trace.Assert(messageWriter is ConsoleMessageWriter);
        Trace.Assert(messageWriters.Single() is ConsoleMessageWriter);
    }
}

Voor meer informatie, zie:

• TryAdd
• TryAddTransient
• TryAddScoped
• TryAddSingleton

De TryAddEnumerable(ServiceDescriptor) -methoden registreren de service alleen als er nog geen implementatie van hetzelfde type is. Meerdere services worden omgezet via IEnumerable<{SERVICE}>. Voeg bij het registreren van services een instantie toe als er nog geen van dezelfde typen is toegevoegd. Bibliotheekauteurs gebruiken TryAddEnumerable om te voorkomen dat er meerdere kopieën van een implementatie in de container worden geregistreerd.

In het volgende voorbeeld wordt de eerste aanroep om te TryAddEnumerable registreren MessageWriter als een implementatie voor IMessageWriter1. De tweede oproep registreert zich MessageWriter voor IMessageWriter2. De derde aanroep heeft geen effect omdat IMessageWriter1 er al een geregistreerde implementatie van MessageWriter:

public interface IMessageWriter1 { }
public interface IMessageWriter2 { }

public class MessageWriter : IMessageWriter1, IMessageWriter2
{
}

services.TryAddEnumerable(ServiceDescriptor.Singleton<IMessageWriter1, MessageWriter>());
services.TryAddEnumerable(ServiceDescriptor.Singleton<IMessageWriter2, MessageWriter>());
services.TryAddEnumerable(ServiceDescriptor.Singleton<IMessageWriter1, MessageWriter>());

Serviceregistratie is orderonafhankelijk, behalve bij het registreren van meerdere implementaties van hetzelfde type.

IServiceCollection is een verzameling ServiceDescriptor objecten. In het volgende voorbeeld ziet u hoe u een service registreert door een ServiceDescriptorservice te maken en toe te voegen:

string secretKey = Configuration["SecretKey"];
var descriptor = new ServiceDescriptor(
    typeof(IMessageWriter),
    _ => new DefaultMessageWriter(secretKey),
    ServiceLifetime.Transient);

services.Add(descriptor);

De ingebouwde Add{LIFETIME} methoden gebruiken dezelfde benadering. Zie bijvoorbeeld de broncode AddScoped.