What is the Dependency Inversion Principle, how is it different from dependency injection, and how do you apply it in a layered .NET application?

1. The "inversion", visually

Flow of control (runtime):   PlaceOrderHandler  ──calls──▶  VendorGateway  ──▶  vendor API

Without DIP (source deps):   Application  ──▶  Infrastructure  ──▶  Vendor SDK

With DIP (source deps):      Application (owns IPaymentGateway)  ◀──  Infrastructure (VendorGateway : IPaymentGateway)
                             Host references both and composes them

Control still flows outward at runtime; source dependencies now point inward. That's the inversion.

2. Origin

Robert C. Martin (1996) stated it as: (A) high-level modules should not depend on low-level modules; both should depend on abstractions; (B) abstractions should not depend on details; details should depend on abstractions. The "plug-in" framing in Clean Architecture (the database and web are plug-ins to the business rules) is the same idea at system level.

3. Composition root

// Shop.Api/Program.cs: the only place that knows concrete types
builder.Services.AddScoped<PlaceOrderHandler>();
builder.Services.AddHttpClient<IPaymentGateway, VendorGateway>(c =>
    c.BaseAddress = new Uri(builder.Configuration["Payments:BaseUrl"]!));
builder.Services.AddDbContext<ShopDb>(o => o.UseSqlServer(builder.Configuration.GetConnectionString("Shop")));
builder.Services.AddScoped<IOrderRepository, EfOrderRepository>();

Application code never calls IServiceProvider.GetService (service locator): dependencies arrive through constructors, so they're visible and testable.

4. Architecture tests

[Fact]
public void Application_does_not_depend_on_infrastructure()
{
    var result = Types.InAssembly(typeof(PlaceOrderHandler).Assembly)
        .ShouldNot().HaveDependencyOnAny("Shop.Infrastructure", "Stripe", "Microsoft.EntityFrameworkCore")
        .GetResult();
    Assert.True(result.IsSuccessful, string.Join(", ", result.FailingTypeNames ?? []));
}

(Using NetArchTest; ArchUnitNET offers similar rules.)

5. Lifetimes still matter

Inverting doesn't remove DI lifetime bugs:

• A singleton depending on a scoped service (e.g. DbContext) is a captive dependency: stale data and thread-safety bugs.
• ValidateScopes and ValidateOnBuild (on by default in Development) catch many of these at startup.
• Typed HttpClients are transient by design; don't capture them in singletons.

6. Testing benefits

7. Pitfalls of over-inversion

• IDateTimeWrapper, IStringHelper, IListFactory: interfaces for stable things.
• A generic repository over DbContext that exposes IQueryable everywhere: the abstraction doesn't hide anything.
• Ports that mirror vendor APIs one-to-one: the vendor's model leaks anyway.

8. Try it yourself

1. Create App, Infra and Host projects; put IPaymentGateway in App, implement it in Infra, wire it in Host.
2. Add the architecture test above and try adding an Infra reference to App to see it fail.
3. Write an application test with an in-memory fake gateway.
4. Write an adapter test with WireMock.Net simulating the vendor.
5. Register a scoped service into a singleton and observe ValidateScopes catching it.

In a real solution each block below is its own project. They are shown in one snippet with block-scoped namespaces so it compiles as a single file (two file-scoped namespace X; declarations in one file are a compile error).

using System.Net.Http.Json;

// ---- Application project (owns the port) ----
namespace Shop.Application
{
    public sealed record PaymentResult(bool Success, string Reference);

    public interface IPaymentGateway
    {
        Task<PaymentResult> ChargeAsync(Guid orderId, decimal amountAud, CancellationToken ct);
    }

    public sealed class PlaceOrderHandler(IPaymentGateway payments)
    {
        public async Task<string> HandleAsync(Guid orderId, decimal total, CancellationToken ct)
        {
            var result = await payments.ChargeAsync(orderId, total, ct);
            return result.Success ? $"Paid ({result.Reference})" : "Payment declined";
        }
    }
}

// ---- Infrastructure project (adapter, references Application) ----
namespace Shop.Infrastructure
{
    using Shop.Application;

    public sealed class CardVendorGateway(HttpClient http) : IPaymentGateway
    {
        public async Task<PaymentResult> ChargeAsync(Guid orderId, decimal amountAud, CancellationToken ct)
        {
            // Vendor-specific request and mapping live only here.
            using var response = await http.PostAsJsonAsync("charges",
                new { reference = orderId, amount_cents = (int)(amountAud * 100), currency = "aud" }, ct);
            return new PaymentResult(response.IsSuccessStatusCode, orderId.ToString("N"));
        }
    }
}

// ---- Host project (Program.cs wires them together) ----
// builder.Services.AddScoped<PlaceOrderHandler>();
// builder.Services.AddHttpClient<IPaymentGateway, CardVendorGateway>(c =>
//     c.BaseAddress = new Uri(builder.Configuration["Payments:BaseUrl"]!));