Sparcpoint.Extensions.DependencyInjection 1.6.14

Sparcpoint.Extensions.DependencyInjection

Decoration and child service extensions for Microsoft.Extensions.DependencyInjection

Installation

Package Manager Console

Install-Package Sparcpoint.Extensions.DependencyInjection

.NET Core CLI

dotnet add package Sparcpoint.Extensions.DependencyInjection

Usage

This library adds three extension methods to IServiceCollection

• Decorate - Allows usage of the decorator pattern with Microsoft DI.
• WithChildServices - Allows an isolated scope of service injection for a parent service.
• DecorateWithChildServices (Alias Decorate) - Allows usage of the decorator pattern (including child services) with Microsoft DI.

Examples

Decoration

Decoration allows for extending functionality of a class without changing the interface or the original implementation. Instead, you wrap instances of implementations that provide common functionality.

An example might be that you have a service that sends and receives from an endpoint called DefaultEndpointClient : IEndpointClient. You would like to introduce logging and performance measurements. However, you know if you add it directly to your implementation, you cannot use those again. Instead, you decorate IEndpointClient with a LoggedEndpointClient : IEndpointClient and a MeasurePerformanceClient : IEndpointClient, both of which take a IEndpointClient into its constructor. Now you have

LoggedEndpointClient → MeasurePerformanceClient → DefaultEndpointClient

chained together decorating the inner services.

See Decorator Pattern

/*
 * Basic Usage
 * The most common usage of decorators
 */
ServiceCollection services = new();

// Add the root service
services.AddSingleton<IService, ServiceImplementation>();

// Decorate all services currently registered
services.Decorate<IService, LoggingImplementation>();

// Build the provider
IServiceProvider provider = services.BuildServiceProvider();

// When we provide the service, we will receive ServiceDecorator first, 
// while the inner service will be the ServiceImplementation
// LoggingImplementation -> ServiceImplementation -> IService
var instance = provider.GetRequiredService<IService>();

/*
 * Open Generic Usage
 * We can also decorate open generics
 */
ServiceCollection services = new();

// Add the root service
services.AddSingleton<IEventProcessor<ServiceEvent>, DefaultEventProcessor<ServiceEvent>>();

// Decorate all services currently registered
services.Decorate(typeof(IEventProcessor<>), typeof(MeasurePerformanceProcessor<>));

// Build the provider
IServiceProvider provider = services.BuildServiceProvider();

// Like the basic use case, we have decorated the previously registered services
// MeasurePerformanceProcessor<ServiceEvent> -> DefaultEventProcessor<ServiceEvent> -> IEventProcessor<ServiceEvent>
var instance = provider.GetRequiredService<IEventProcessor<ServiceEvent>>();

Child Services

Child Services allow for certain instances of services to be built with an isolated set of registered services separated from the main provider. This allows for sub-services to be different as needed from implementation to implementation

/*
 * Basic Usage
 */

ServiceCollection services = new();

// This service is registered with the root provider.
services.AddSingleton<IMessageBus, InMemoryServiceBus>();
services.WithChildServices<DefaultAccountService>(child => 
{
  // All services in this container will be used to create the DefaultAccountService
  // Extra services are ignored
  services.AddSingleton<IMessageBus>(p => new AzureServiceBus("connectionString"));
});

var provider = services.BuildServiceProvider();

// This will return a DefaultAccountService with an AzureServiceBus implementation
// DefaultAccountService -> AzureServiceBus
var accountService = provider.GetRequiredService<DefaultAccountService>();

// This will return the "default" implementation of InMemoryServiceBus
var messageBus = provider.GetRequiredService<IMessageBus>();

/*
 * Setting the Parent's Lifetime
 * By default, a parent is setup as a Singleton. If you need
 * a different lifetime, it is specified as a parameter on
 * WithChildServices(...)
 */

 // DefaultAccountService will have a Transient lifetime
 // and will be created on every provide of this service
services.WithChildServices<DefaultAccountService>(child => 
{
  services.AddSingleton<IMessageBus>(p => new AzureServiceBus("connectionString"));
}, lifetime: ServiceLifetime.Transient);

/*
 * Decoration Example
 * Sometimes you may not want to simply replace the parent service
 * Instead, you may want to decorate it
 */

ServiceCollection services = new();

// This service is registered with the root provider.
services.AddSingleton<IMessageBus, InMemoryServiceBus>();
services.WithChildServices<DefaultAccountService>(child => 
{
  services.Decorate<IMessageBus, LoggedMessageBus>();
});

var provider = services.BuildServiceProvider();

// This will return a DefaultAccountService with a LoggedMessageBus implementation
// DefaultAccountService -> LoggedMessageBus -> InMemoryServiceBus
var accountService = provider.GetRequiredService<DefaultAccountService>();

// This will return the "default" implementation of InMemoryServiceBus
var messageBus = provider.GetRequiredService<IMessageBus>();

Decorate w/ Child Services

Like above, we can also decorate while injecting child services, as necessary.

Caveat: This can only be used with a closed implementation. Open-generics are NOT supported.

/*
 * Basic Usage
 */
ServiceCollection services = new();

// Add the root service
services.AddSingleton<IService, ServiceImplementation>();

// Decorate all services currently registered (w/ Child Services)
services.DecorateWithChildServices<IService, LoggingImplementation>(child => 
{
  child.AddSingleton<IOtherService, OtherServiceImplementation>();
});

/*
 * Alternate Syntax
 */
ServiceCollection services = new();

// Add the root service
services.AddSingleton<IService, ServiceImplementation>();

// Decorate all services currently registered (w/ Child Services)
services.Decorate<IService, LoggingImplementation>(child => 
{
  child.AddSingleton<IOtherService, OtherServiceImplementation>();
});