Windsor castle Injecting properties of constructed object

by

This is an old question but Google led me here recently so thought I would share my solution lest it help someone looking for something like StructureMap’s BuildUp method for Windsor.

I found that I could add this functionality myself relatively easily. Here is an example which just injects dependencies into an object where it finds a null Interface-typed property. You could extend the concept further of course to look for a particular attribute etc:

public static void InjectDependencies(this object obj, IWindsorContainer container)
{
    var type = obj.GetType();
    var properties = type.GetProperties(BindingFlags.Public | BindingFlags.Instance);
    foreach (var property in properties)
    {
        if (property.PropertyType.IsInterface)
        {
            var propertyValue = property.GetValue(obj, null);
            if (propertyValue == null)
            {
                var resolvedDependency = container.Resolve(property.PropertyType);
                property.SetValue(obj, resolvedDependency, null);
            }
        }
    }
}

Here is a simple unit test for this method:

[TestFixture]
public class WindsorContainerExtensionsTests
{
    [Test]
    public void InjectDependencies_ShouldPopulateInterfacePropertyOnObject_GivenTheInterfaceIsRegisteredWithTheContainer()
    {
        var container = new WindsorContainer();
        container.Register(Component.For<IService>().ImplementedBy<ServiceImpl>());

        var objectWithDependencies = new SimpleClass();
        objectWithDependencies.InjectDependencies(container);

        Assert.That(objectWithDependencies.Dependency, Is.InstanceOf<ServiceImpl>());
    }

    public class SimpleClass
    {
        public IService Dependency { get; protected set; }
    }

    public interface IService
    {
    }

    public class ServiceImpl : IService
    {
    }
}

More Related Contents:

  1. Ioc/DI – Why do I have to reference all layers/assemblies in application’s entry point?
  2. Why not use an IoC container to resolve dependencies for entities/business objects?
  3. Comparing Castle Windsor, Unity and StructureMap
  4. Resolving HttpControllerContext with Castle Windsor
  5. Is there a pattern for initializing objects created via a DI container
  6. Why do I need an IoC container as opposed to straightforward DI code? [closed]
  7. What is a composition root in the context of dependency injection?
  8. Why does one use dependency injection?
  9. Dependency Injection vs Factory Pattern
  10. Inversion of Control vs Dependency Injection
  11. Inversion of Control < Dependency Injection [closed]
  12. Dependency injection through constructors or property setters?
  13. How do I effectively design my application where most classes depend on ILogger?
  14. Avoiding all DI antipatterns for types requiring asynchronous initialization
  15. When to use PerThreadLifetimeManager?
  16. Which Dependency Injection Tool Should I Use? [closed]
  17. When are .NET Core dependency injected instances disposed?
  18. How to extend a component with dependency injection?
  19. Meaning of bean discovery mode annotated in CDI 1.1
  20. Property Injection in ASP.NET Core
  21. Dagger @Reusable scope vs @Singleton
  22. What is the purpose of the getter methods in Components in Dagger 2?
  23. How can I register a generic decorator using Castle Windsor?
  24. MEF (Managed Extensibility Framework) vs IoC/DI
  25. ASP.Net Core Call a controller from another controller
  26. When to use Dependency Injection
  27. Passing constructor arguments when using StructureMap
  28. Net Core Dependency Injection for Non-Controller
  29. How to integrate IoC Membership provider with ASP.NET MVC
  30. How do I handle classes with static methods with Ninject?

Leave a Comment