What is a dependency relationship between classes, and how is it different from association? Explain how dependencies appear in C# code, why direction matters (Dependency Inversion Principle), and how dependency injection manages them.

1. Types of coupling via dependencies

From loosest to tightest:

1. Data coupling — passing simple values.
2. Stamp coupling — passing a whole object when only a part is used.
3. Control coupling — passing flags that tell the callee what to do.
4. Common coupling — sharing global/static state.
5. Content coupling — reaching into another class's internals.

Good design keeps dependencies at the data/stamp level, through narrow interfaces.

2. Stable Dependencies and Acyclic Dependencies

Robert C. Martin's package principles:

• Acyclic Dependencies Principle: no cycles between components/projects. .NET enforces this at project level (project references can't be circular), but cycles between namespaces or folders inside one project can still exist.
• Stable Dependencies Principle: depend in the direction of stability — volatile code (UI, infrastructure) depends on stable code (domain), not the reverse.
• Stable Abstractions Principle: stable components should be abstract (interfaces, domain models) so they can be extended without modification.

Architecture tests (NetArchTest, ArchUnitNET) can enforce "Domain must not reference Infrastructure" in CI.

3. DI container mechanics in .NET

• Registrations build a ServiceCollection of ServiceDescriptors; BuildServiceProvider creates resolvers (compiled expression or IL-emitted factories for speed).
• Constructor selection: the constructor with the most resolvable parameters.
• Scopes: ASP.NET Core creates one per request; scoped services are disposed at the end. Resolving scoped services from the root provider (e.g. in a singleton) is a captive dependency bug — ValidateScopes and ValidateOnBuild (default in Development) detect it.
• .NET 8 added keyed services ([FromKeyedServices("stripe")]) for multiple implementations of one interface.
• Avoid the service locator anti-pattern (IServiceProvider injected everywhere): it hides dependencies and defers failures to run time.

4. Dependencies on time, randomness and environment

Common hidden dependencies and their abstractions:

5. Dependencies in UML and code metrics

UML shows dependencies as dashed arrows with stereotypes («use», «create», «call»). Visual Studio's code metrics report class coupling (number of unique types a class depends on); values above ~30 for a class are a smell. NDepend and Rider's dependency diagrams visualise project and namespace dependencies.

6. When not to invert

You don't need an interface for every dependency. Stable, pure dependencies (the BCL, Money value objects, domain services without I/O) can be used directly. Invert dependencies at volatility and I/O boundaries: databases, external APIs, messaging, time, file system.

Try it yourself

1. Search your codebase for DateTime.Now, new HttpClient, File. and static service calls; list hidden dependencies.
2. Add NetArchTest rules ensuring the domain project doesn't reference EF Core or ASP.NET Core.
3. Enable ValidateOnBuild and fix any captive dependencies.
4. Replace DateTime.UtcNow with TimeProvider in one service and write a month-end test.

// Application layer owns the abstractions (dependency inversion)
public interface IInvoiceRepository
{
    Task<IReadOnlyList<Invoice>> GetDueAsync(DateOnly asOf, CancellationToken ct);
}

public interface IEmailSender
{
    Task SendAsync(string to, string subject, string body, CancellationToken ct);
}

// Policy class: all dependencies explicit, none created inside
public sealed class InvoiceRunner(IInvoiceRepository invoices, IEmailSender email, TimeProvider clock)
{
    public async Task<int> RunAsync(CancellationToken ct)
    {
        var today = DateOnly.FromDateTime(clock.GetLocalNow().DateTime);   // no DateTime.Now
        int sent = 0;
        foreach (var invoice in await invoices.GetDueAsync(today, ct))
        {
            await email.SendAsync(invoice.Email, $"Invoice {invoice.Number}", Format(invoice), ct);
            sent++;
        }
        return sent;
    }

    private static string Format(Invoice i) => $"Amount due: {i.Amount:C}";   // pure helper: fine as static
}

public sealed record Invoice(string Number, string Email, decimal Amount);

// Infrastructure implements the abstraction
public sealed class SqlInvoiceRepository(AppDb db) : IInvoiceRepository
{
    public async Task<IReadOnlyList<Invoice>> GetDueAsync(DateOnly asOf, CancellationToken ct) =>
        await db.Invoices.Where(i => i.DueDate <= asOf)
                         .Select(i => new Invoice(i.Number, i.Email, i.Amount))
                         .ToListAsync(ct);
}

// Composition root
builder.Services.AddSingleton(TimeProvider.System);
builder.Services.AddScoped<IInvoiceRepository, SqlInvoiceRepository>();
builder.Services.AddTransient<IEmailSender, SmtpEmailSender>();
builder.Services.AddScoped<InvoiceRunner>();

// Test: control time without waiting for month end
// var clock = new FakeTimeProvider(new DateTimeOffset(2026, 10, 31, 9, 0, 0, TimeSpan.FromHours(11)));