Dependency Injection in .NET Framework and .NET Core

Dependency Injection (DI) is a design pattern that plays a pivotal role in enhancing the modularity and testability of software. In the context of .NET development, both .NET Framework and .NET Core (now .NET 5 and beyond) embrace Dependency Injection to simplify the management of object dependencies.

Introduction

Dependency Injection (DI) is a design pattern that plays a pivotal role in enhancing the modularity and testability of software. In the context of .NET development, both .NET Framework and .NET Core (now .NET 5 and beyond) embrace Dependency Injection to simplify the management of object dependencies.

In this blog, we'll embark on a journey to understand Dependency Injection in both frameworks, unraveling its concepts and implementation nuances through insightful code snippets.

What is Dependency Injection?

Dependency Injection is a pattern where the responsibility of creating and managing dependencies of a class is shifted to an external entity, typically known as the IoC (Inversion of Control) container. This enables loose coupling between components, making the code more modular, maintainable, and testable.

Dependency Injection in .NET Framework

In the .NET Framework, dependency injection can be achieved using various third-party IoC containers like Unity, Autofac, or StructureMap. Let's illustrate a simple example using Unity.

Setting up Unity Container in .NET Framework

// Install Unity NuGet package
// Install-Package Unity

using System;
using Microsoft.Practices.Unity;

class Program
{
    static void Main()
    {
        // Create Unity container
        IUnityContainer container = new UnityContainer();

        // Register types
        container.RegisterType<ILogger, ConsoleLogger>();

        // Resolve dependency
        var service = container.Resolve<MyService>();
        service.PerformAction();
    }
}

// Interfaces and classes
public interface ILogger
{
    void Log(string message);
}

public class ConsoleLogger : ILogger
{
    public void Log(string message)
    {
        Console.WriteLine($"Logging: {message}");
    }
}

public class MyService
{
    private readonly ILogger logger;

    // Constructor injection
    public MyService(ILogger logger)
    {
        this.logger = logger;
    }

    public void PerformAction()
    {
        logger.Log("Action performed!");
    }
}

Dependency Injection in .NET Core

.NET Core (and its successor, .NET 5 and beyond) integrates dependency injection natively into the framework. The built-in IServiceCollection and IServiceProvider interfaces streamline the registration and resolution of dependencies.

Using Dependency Injection in .NET Core

using System;
using Microsoft.Extensions.DependencyInjection;

class Program
{
    static void Main()
    {
        // Create service collection
        var services = new ServiceCollection();

        // Register types
        services.AddTransient<ILogger, ConsoleLogger>();
        services.AddTransient<MyService>();

        // Build service provider
        var serviceProvider = services.BuildServiceProvider();

        // Resolve dependency
        var service = serviceProvider.GetService<MyService>();
        service.PerformAction();
    }
}

// Interfaces and classes
public interface ILogger
{
    void Log(string message);
}

public class ConsoleLogger : ILogger
{
    public void Log(string message)
    {
        Console.WriteLine($"Logging: {message}");
    }
}

public class MyService
{
    private readonly ILogger logger;

    // Constructor injection
    public MyService(ILogger logger)
    {
        this.logger = logger;
    }

    public void PerformAction()
    {
        logger.Log("Action performed!");
    }
}

Key Differences

1. .NET Framework

   • Requires third-party IoC containers.
   • Popular choices include Unity, Autofac, and StructureMap.

2. .NET Core and Beyond

   • Native support for dependency injection.
   • Uses IServiceCollection and IServiceProvider.
   • Embraces a clean and concise syntax.

Conclusion

Whether you're working with .NET Framework or .NET Core, integrating Dependency Injection into your application architecture can significantly enhance code quality, maintainability, and testability. While the .NET Framework relies on third-party IoC containers, .NET Core and its successors provide a seamless and native DI experience.

Understanding and applying Dependency Injection principles empower developers to build modular, flexible, and scalable software systems in the ever-evolving landscape of .NET development. Happy coding!