Property Injection in Unity Container

Property Injection in Unity Container

1. Introduction Property injection is a form of dependency injection that allows the Unity container to automatically inject dependencies into properties of an object. With property injection, you can define the dependencies of a class using properties instead of constructor parameters. The Unity container takes care of resolving and injecting the dependencies into the properties at runtime.

2. Configuring Property Injection To enable property injection in Unity Container, you need to follow these steps:

Step 1: Register the types in the container using the appropriate registration methods such as RegisterType or RegisterInstance.

Step 2: Specify the properties to be injected using the Dependency attribute.

3. Code Example Here's an example that demonstrates property injection in Unity Container:

csharp
using Unity;
using Unity.Injection;

public class MyService
{
    [Dependency]
    public ILogger Logger { get; set; }

    public void DoSomething()
    {
        Logger.Log("Doing something...");
    }
}

public interface ILogger
{
    void Log(string message);
}

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

class Program
{
    static void Main(string[] args)
    {
        IUnityContainer container = new UnityContainer();

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

        // Resolve the object with property injection
        var service = container.Resolve<MyService>();

        // Use the object
        service.DoSomething();

        // Output: "Doing something..."
    }
}

4. Explanation In the above example, we have a MyService class that depends on an ILogger interface. Instead of passing the ILogger dependency through the constructor, we use property injection by applying the [Dependency] attribute to the Logger property.

In the Main method, we create an instance of the Unity container. Then we register the ILogger interface to the ConsoleLogger implementation using the RegisterType method.

Next, we resolve an instance of MyService from the container using the Resolve method. The Unity container automatically resolves the dependency for the Logger property and injects an instance of ConsoleLogger into it.

Finally, we can use the MyService object, and when we call the DoSomething method, it uses the injected ILogger instance to log the message.

By using property injection, we can easily configure and manage dependencies in our objects, allowing for more flexibility and decoupling of components in the application.

Conclusion Property injection in Unity Container provides a convenient way to inject dependencies into properties of objects. It simplifies the configuration and management of dependencies, promoting loose coupling and enhancing the flexibility of your application.