Refactoring Legacy Monoliths to DI

In this lesson, you will learn how to systematically break down tightly coupled legacy monoliths by introducing Dependency Injection (DI) without forcing a complete system rewrite.

Refactoring a legacy monolith—often characterized by static calls, new keyword instantiation, and global state—is a high-risk operation. The goal is to migrate to DI using a phased, "strangler" approach to ensure the application remains stable throughout the transition.

Phase 1: Dependency Extraction

Instead of changing the entire architecture, start by identifying a single service that is difficult to test or modify. Do not remove the static calls immediately. Instead, move the logic into an interface-based service. In your legacy class, implement a "Constructor Injection" pattern while keeping a default constructor to maintain backward compatibility:

public class LegacyOrderProcessor
{
    private readonly IInventoryService _inventory;

    // Maintain for legacy callers
    public LegacyOrderProcessor() : this(new LegacyInventoryService()) { }

    // New injection point for testability and DI container usage
    public LegacyOrderProcessor(IInventoryService inventory)
    {
        _inventory = inventory;
    }
}

Phase 2: Interface-Driven Decoupling

By providing an overloaded constructor, you allow new, DI-aware parts of your system to pass in injected dependencies, while existing legacy code continues to function via the parameterless constructor.

Phase 3: Registration and Migration

Once the internal logic is moved to an interface, you can register IInventoryService in your IServiceCollection. As you continue this process, the "center of gravity" of your application shifts toward the DI container. Eventually, you can replace the parameterless constructors with direct injection, slowly pruning the legacy instantiation logic until the monolith is fully composed via the container.

This incremental approach minimizes the risk of breaking widespread dependencies. You aren't refactoring the entire codebase at once; you are wrapping legacy dependencies in interfaces and gradually shifting the responsibility of object creation to the container.

Key Takeaway: Use constructor overloading to bridge the gap between legacy static instantiation and modern DI, allowing you to refactor your monolith one service at a time.