Question

I’m using Windsor 3.1.0 and instantiating a component with LifestyleTransient using Typed Factory. As it is said in the refered page I have to release every object I get from the factory. However I’m in the scenario that looks like this

class MyTypedFactory
{
    MyTransientCommand CreateCommand();
    void Release(MyTransientCommand command);
}

class MyTransientCommand
{
    public void Execute() { }
}

class ClassA
{
    public ClassB CommandPopulator { get; set; }

    public void Foo()
    {
        List<MyTransientCommand> commands = new List<MyTransientCommand>();

        CommandsPopulator.Commands = commands;

        for (int i=0; i<100; ++i)
        {
            CommandsPopulator.Bar();
        }

        foreach (MyTransientCommand command in commands)
        {
            command.Execute();
        }
    }
}

class ClassB
{
    public MyTypedFactory Factory { get; set; }

    List<MyTransientCommand> Commands { get; set; }

    public void Bar()
    {
        Commands.Add(Factory.CreateCommand());
    }
}

This may look overcomplicated but it illustrates object flow in my code. Here the external class (ClassB) populates commands queue with commands created by the typed factory.

Releasing those objects when they are no longer needed (after the Execute loop) with the factory becomes whole problem. I can do release in the loop but it’s not safe to exceptions of the release method itself.

class ClassA
{
    public MyTypedFactory Factory { get; set; }

    ...

    public void Foo()
    {
        ...
        foreach (MyTransientCommand command in commands)
        {
            command.Execute();
        }

        foreach (MyTransientCommand command in commands)
        {
            Factory.Release(command);
        }
    }
}

If one of the Release calls throws the rest of objects would not be released and will make a memory leak (I know this should not happend but I try to defend from this kind of stuff).

Is it ok to release MyTransientCommand right after it has been created in ClassB.Bar? It won’t be freed by GC until the ClassA.Foo method returns because it holds references to the collection of commands objects.

Is it ok to release MyTransientCommand in ClassB.Bar if MyTransientCommand.Execute makes WCF client calls and WCF client is set up with Windsor? Or more generally if MyTransientCommand.Execute uses other components supplied by Windsor?

P.S. The code in the problem looks artificial and unnatural and it is. That’s because the algorithm has to have side-effects: changing state of data in the database within the transaction has to raise WCF calls under some circumstances. Those calls has to be made after the transaction completes not during the transaction.

Answer 1

No, it’s not ok to release components before it’s going to be used. Windsor tracks lifetime of nested components, so releasing root component may generally release it’s children. And I want to avoid using a component with potentially invalid state.

So I ended up with the following way of releasing commands

class ClassA
{
    public MyTypedFactory Factory { get; set; }
    public ClassB CommandPopulator { get; set; }

    public void Foo()
    {
        List<MyTransientCommand> commands = new List<MyTransientCommand>();

        try
        {
            CommandsPopulator.Commands = commands;

            for (int i=0; i<100; ++i)
            {
                CommandsPopulator.Bar();
            }

            foreach (MyTransientCommand command in commands)
            {
                command.Execute();
            }
        }
        finally
        {
            foreach (MyTransientCommand command in commands)
            {
                try
                {
                    Factory.Release(command);
                }
                catch (Exception exception)
                {
                    Log(exception);
                }
            }
        }
    }
}

That way I’m sure that if exception occurs when using CommandsPopulator or executing commands, all commands still to be released. Also each command is released in a try/catch block in order to prevent exception thrown from one Release breaking the loop.

Hopefully Windsor follows no-throw semantics for releasing objects with Typed Factory or the chances for exception to occur are very low.