Mammoth.Extensions.DependencyInjection 0.1.1

Mammoth.Extensions.DependencyInjection

Build Status

Introduction

This package provides a set of extensions for the Microsoft.Extensions.DependencyInjection package.

It is intended to use with Microsoft.Extensions.DependencyInjection 8.0.0 and greater, because it relies heavily on the keyed services support introduced in that version.

Installation

dotnet add package Mammoth.Extensions.DependencyInjection

Usage

Decorator

The Decorator extension is used to decorate an existing service with a new implementation. This is useful when you want to add new functionality to an existing service without modifying the original implementation.

The following example demonstrates how to decorate an existing service with a new implementation.

The current implementation requires that the sservice to be decorated implements an interface.

public interface ITestService { }

public class TestService : ITestService { }

public class DecoratorService1 : ITestService
{
	private readonly ITestService _service;

	public DecoratorService1(ITestService service)
	{
		_service = service;
	}
}

public class DecoratorService2 : ITestService
{
	private readonly ITestService _service;

	public DecoratorService2(ITestService service)
	{
		_service = service;
	}
}

services.AddTransient<ITestService, TestService>();
services.Decorate<IService, DecoratorService1>(); // innermost decorator
services.Decorate<IService, DecoratorService2>(); // outermost decorator

This extensins works with all kinds of Service Descriptors (Singleton, Scoped, Transient, Keyed, etc).

DependsOn (requires Keyed Services support)

The DependsOn registration extensions are used to register a service that depends on specific instances of other services.

The following example demonstrates how to register a service that depends on specific instances of other services.

public interface ITestService { }

public class TestService : ITestService { }

public class DependentService
{
	private readonly ITestService _service;

	public DependentService(ITestService service)
	{
		_service = service;
	}
}

services.AddTransient<ITestService, TestService>("one");
services.AddTransient<ITestService, TestService>("two");
services.AddTransient<DependentService>(dependsOn: new Dependency[] {
  Parameter.ForKey("service").Eq("one")
});

Internally, the DependsOn extensions create a factory function that resolves the required services and creates the dependent service instances.

The current syntax is limited to some common use case and it's very similar to the one offered by Castle.Windsor from which we took inspiration:

• inject a specific instance of a service that will be resolved:

  services.AddTransient<DependentService>(dependsOn: new Dependency[] {
    Parameter.ForKey("service").Eq("one")
  });
  

• inject a value:

  services.AddTransient<DependentService>(dependsOn: new Dependency[] {
    Dependency.OnValue("dep", "val1")
  });
  

This extensins works with all kinds of Service Descriptors (Singleton, Scoped, Transient, Keyed, etc).

Registration Helpers

A series of extentions and helpers methods to check is a component was registered and to inspect the assemblies looking for services to be registered.

Checks

Helper methods to check if a service was registered or a ServiceDescript exists.

ServiceCollection

• GetServiceDescriptors
• IsServiceRegistered
• IsTransientServiceRegistered
• IsScopedServiceRegistered
• IsSingletonServiceRegistered

ServiceProvider

To use the following extensions you need to build the ServiceProvider using our ServiceProviderFactory.

It will inject some support services that are used to keep tracks of the registered services.

new HostBuilder().UseServiceProviderFactory(new ServiceProviderFactory());

// - or -

var serviceProvider = ServiceProviderFactory.CreateServiceProvider(serviceCollection);

You can then use the following extensions:

• IsServiceRegistered
• GetAllServices: resolves all keyed and non-keyed services of a given service type

Inspectors

The AssemblyInspector class is used to inspect the assemblies looking for services to be registered.

It is once again inspired by the syntax used in Castle.Windsor to inspect and register services.

It looks for classes and offers a series of methods that are pretty self explanatory to output ServiceDescriptos that will be registered in the ServiceCollection.

It also supports the DependsOn registration extensions:

serviceCollection.Add(
  new AssemblyInspector()
	.FromAssemblyContaining<ServiceWithKeyedDep>()
	.BasedOn<ServiceWithKeyedDep>()
	.WithServiceSelf()
	.LifestyleSingleton(dependsOn: new Dependency[]
	{
	  Parameter.ForKey("keyedService").Eq("one")
    })
);