ApacheTech.Common.DependencyInjection 2.3.1

Minimal Dependency Injection

This is a minimal implementation of the Microsoft.Extensions.DependencyInjection package, including the ActivatorUtilities class.

Allows for Singleton and Transient services to be registered with an IOC container. Scoped services have not been implemented.

This is designed as a very lightweight, and minimalistic, solution, but this may come at a cost. This package does not include many of the safety measures and fallbacks that the full package contains. It was written from the ground up, other than the ActivatorUtilities class. Therefore, it might not play well with third-party IOC wrappers like AutoFac or CastleWindsor. It should not be seen as a replacement for Microsoft.Extensions.DependencyInjection.

The original purpose of this package was to act as an IOC container for game mods, where a full enterprise level package simply comes with too much bloat. This is ideal for those kinds of scenarios, when you just need a quick and simple IOC container, without all the bloat.

Acknowledgement

Inspired by Nick Chapsas' video tutorial on bespoke dependency injection solutions.

https://www.youtube.com/watch?v=NSVZa4JuTl8

Overview

This repository provides a compact, focused implementation of dependency injection primitives suitable for small applications, tools and game mods where the official Microsoft dependency injection package would be overly heavy.

Key components include:

• IServiceCollection - a lightweight service collection interface.
• ServiceCollection - a simple list-backed implementation of IServiceCollection.
• ServiceDescriptor - describes a service registration (service type, implementation, factory and lifetime).
• ActivatorUtilities - helpers to instantiate types using constructor injection from an IServiceProvider.
• Attribute-based registration helpers in the Annotation namespace: SingletonAttribute, TransientAttribute, and scanning helpers to register annotated types from assemblies.

This project is intentionally small and dependency-light. It aims to provide the core features most commonly needed for composition and injection without the additional complexity of the full Microsoft implementation.

Features

• Register transient and singleton services using descriptors or extension methods.
• Register instances and factories for custom construction logic.
• Mix explicit constructor arguments with container-resolved services using ActivatorUtilities.
• Scan assemblies and register types annotated with SingletonAttribute or TransientAttribute.
• Lightweight, zero-dependency implementation intended for constrained environments.

Important Notes and Limitations

• Scoped services are not implemented.
• This implementation does not include all the diagnostics, fallback behaviour or extension points present in the official Microsoft DI.
• Behaviour may differ from the official DI in edge cases - test carefully before replacing the official DI in production systems.
• There is no guarantee of compatibility with third-party IOC containers or wrappers.

Quick Start

The library exposes a simple API surface for registering services and creating instances. The code below demonstrates common tasks.

1. Add Services to a ServiceCollection:

var services = new ApacheTech.Common.DependencyInjection.ServiceCollection();

// Register concrete type as singleton
services.TryAddSingleton<MyService>();

// Register service with implementation
services.TryAddTransient(typeof(IMyService), typeof(MyService));

// Register using factory
services.TryAddSingleton(typeof(IMyService), sp => new MyService(sp.GetService(typeof(IOther))));

2. Resolve Services via an IServiceProvider:

This repository provides a minimal set of IServiceProvider extension helpers. How you obtain a runtime service provider instance depends on your composition root or hosting environment. The examples below use the extension helpers for resolution where a provider is available.

IServiceProvider provider = /* obtain provider from your composition root */;
var svc = provider.GetRequiredService<MyService>();

3. Create Instances with ActivatorUtilities:

// Create an instance of a type and let the container satisfy constructor dependencies
var instance = ActivatorUtilities.CreateInstance(provider, typeof(MyType), someExplicitArg);

// Generic helper
var typed = ActivatorUtilities.CreateInstance<MyType>(provider, someExplicitArg);

// Get service or create instance if not registered
var maybe = ActivatorUtilities.GetServiceOrCreateInstance(provider, typeof(MyOtherType));

API Details

This section documents the public API surface in more detail and includes short examples showing common usages.

ServiceDescriptor

ServiceDescriptor represents a registration. It records the service type, the implementation type or instance, an optional factory, and the service lifetime.

Common factory methods and constructors are shown in the table below.

ServiceDescriptor also exposes GetImplementationType() which is useful to determine the concrete implementation type for a descriptor when inspecting or composing descriptors.

IServiceCollection and ServiceCollection

IServiceCollection is a minimal contract that extends IList<ServiceDescriptor>. ServiceCollection is the list-backed default implementation.

Common collection operations and helpers are shown in the table below.

Note: Add is unconditional, while TryAdd is conditional on the absence of a registration for the same ServiceType.

Use TryAdd or TryAddEnumerable when adding descriptors from scanning to ensure idempotent behaviour.

ServiceCollectionDescriptorExtensions

This static class contains convenience helpers for common registration patterns. Key helpers are shown below.

ActivatorUtilities

ActivatorUtilities provides helpers for creating instances where some constructor arguments are supplied explicitly and others are resolved from an IServiceProvider.

If a class has a constructor marked with ActivatorUtilitiesConstructor then that constructor is preferred when selecting which constructor to use.

Annotations and Assembly Scanning

The library provides a small set of attributes to support declarative registration. The table below summarises the attributes and how to discover annotated types.

To register annotated types, use the AddAnnotatedServicesFromAssembly extension methods on IServiceCollection.

Example:

[Singleton(typeof(IMyService))]
public class MyService : IMyService { }

[Transient]
public class OtherService { }

Register annotated types from an assembly:

var services = new ApacheTech.Common.DependencyInjection.ServiceCollection();
services.AddAnnotatedServicesFromAssembly(typeof(MyService));

This will create ServiceDescriptor instances based on the attributes and add them to the collection.

Service Provider Extension Helpers

The project includes a small set of IServiceProvider extension helpers in ServiceProviderExtensions to make consuming services easier.