Effortlessly Resolving Circular Dependencies in .NET with SmartInject

Introduction

Dependency Injection (DI) is a common technique to achieve Inversion of Control (IoC) between classes and their dependencies. However, developers may encounter a System.InvalidOperationException related to circular dependencies. This article introduces a convenient solution: SmartInject, a NuGet package that simplifies dependency injection in .NET by employing lazy loading to handle circular dependencies. Check it out on NuGet.

Background

When dealing with classes that depend on each other, a circular dependency is created, leading to an infinite loop during object instantiation. This scenario typically requires refactoring to resolve, but SmartInject provides an efficient workaround by implementing lazy loading. With SmartInject, dependencies are resolved in a deferred manner, eliminating the circular dependency issue without the need for major code restructuring.

Using the Code

Consider a scenario where Something depends on SomethingElse, and vice versa:

public class Something
{
    public Something(SomethingElse somethingElse) { /*...*/ }
}

public class SomethingElse
{
    public SomethingElse(Something something) { /*...*/ }
}

This typical arrangement would throw a System.InvalidOperationException due to a circular dependency. With SmartInject, you can restructure the code as follows:

public class Something : ISomething
{
    private readonly Lazy<ISomethingElse> _somethingElse;
    public Something(Lazy<ISomethingElse> somethingElse)
    {
        _somethingElse = somethingElse;
    }
}

public class SomethingElse : ISomethingElse
{
    private readonly Lazy<ISomething> _something;
    public SomethingElse(Lazy<ISomething> something)
    {
        _something = something;
    }
}

With the Lazy<T> class, SmartInject ensures that instances are not created until they are needed, effectively breaking the circular dependency loop. Services can be registered using SmartInject’s specialized methods:

builder.Services.AddLazySingleton<ISomething, Something>();

SmartInject also supports other service lifetimes, providing flexibility for various application needs. You can choose from the following registration methods, based on your requirements:

// For singleton lifetime
builder.Services.AddLazySingleton<ISomething, Something>();

// For transient lifetime
builder.Services.AddLazyTransient<ISomething, Something>();

// For scoped lifetime
builder.Services.AddLazyScoped<ISomething, Something>();

Each method corresponds to a different service lifetime, allowing you to select the most appropriate one for your application's architecture and performance needs. For additional details, explore the SmartInject source code on GitHub.

Points of Interest

The SmartInject package offers an elegant solution to handle circular dependencies without requiring significant code restructuring. It introduces a deferred instantiation approach, improving the application's startup performance while integrating seamlessly with the .NET DI framework.

History

• 3^rd October, 2023: This is the initial publication of this trick. Future updates and improvements to the SmartInject package or related tricks will be documented in subsequent revisions.