Can you use Autofac's Owned with a marker interface?

Question

I want to use Autofac to create a new instance of one or several WCF channels for a given unit of work. I'd like to use the command pattern to represent units of work, i.e. a given command class is injected with the channel(s) it needs and implements a bunch of related operations.

I tried the following:

interface IUnitOfWork
{

}

class FooCall : IUnitOfWork
{
    readonly BarChannel _channel;

    public FooCall(BarChannel channel)
    {
        Console.WriteLine($"FooCall({new {channel}})");
        _channel = channel;
    }

    public string Foo()
    {
        return "FOO";
    }
}

class BarChannel
{
    public BarChannel()
    {
        Console.WriteLine("BarChannel()");
    }
}

class FooService
{
    Func<Owned<FooCall>> _helperFn;

    public FooService(Func<Owned<FooCall>> helperFn)
    {
        _helperFn = helperFn;
    }

    public void CallFoo()
    {
        using (var helper = _helperFn())
        {
            Console.WriteLine($"CallFoo(), helper={helper}");
            helper.Value.Foo();
        }
    }
}

class Program
{
    static void Main(string[] args)
    {
        var builder = new ContainerBuilder();
        builder.RegisterType<BarChannel>().InstancePerOwned<IUnitOfWork>();
        builder.RegisterType<FooCall>().AsImplementedInterfaces().AsSelf();
        builder.RegisterType<FooService>();

        using (var scope = builder.Build().BeginLifetimeScope())
        {
            Console.WriteLine("call 1");
            scope.Resolve<FooService>().CallFoo();
            Console.WriteLine("call 2");
            scope.Resolve<FooService>().CallFoo();
        }
    }
}

In short: a service method creates an owned unit of work; the unit of work is injected with a per-owned channel that it calls. The code sample should show two channel instances being created.

Except that it seems that the lifetime scope created for owned dependencies is only tagged with the type as which the dependency was resolved - i.e. as FooCall, not as IUnitOfWork. If I register BarChannel as InstancePerOwned<FooCall>, the code works; as is, registered as InstancePerOwned<IUnitOfWork>, it fails to resolve FooService since it can't find a matching lifetime scope. Am I missing something or is what I want to do not possible with Autofac? I'd rather not have to register all my WCF channels as instance-per-owned for every command class, that seems like it would get pretty verbose. Another workaround would be using instance-per-depedency and resolving a Func directly, but that won't let me say compose units of work while reusing channels and their dependencies between them.

Answer 1

The problem is that InstancePerOwned<T> is really just a special case of InstancePerMatchingLifetimeScope(params object[] lifetimeScopeTag), where the scope is tagged with something like typeof(T). As it stands, there needs to be a direct link between the tag provided there and the one attached to the scope when attempting to resolve, which is always set to the type of whatever's inside that specific Owned<> dependency. There's no additional logic to imply relations between types at that point, it's just a direct match on the tags.

However, InstancePerMatchingLifetimeScope does allow multiple tags to be specified, so it's possible to do something like:

builder.RegisterType<BarChannel>()
    .InstancePerMatchingLifetimeScope(new TypedService(typeof(FooCall)),new TypedService(typeof(AnotherUnitOfWork))); 

To wrap this up a bit more neatly you could use:

private static IEnumerable<Type> GetTypesImplementingInterface<TInterface>()
{
    return AppDomain.CurrentDomain.GetAssemblies()
        .SelectMany(s => s.GetTypes())
        .Where(p => typeof(TInterface).IsAssignableFrom(p));
}

and then a new extension method:

public static class AutofacRegistrationBuilderExtensions
{
    public static IRegistrationBuilder<TLimit, TActivatorData, TRegistrationStyle> InstancePerOwned<TLimit, TActivatorData, TRegistrationStyle>(
        this IRegistrationBuilder<TLimit, TActivatorData, TRegistrationStyle> builder, IEnumerable<Type> serviceTypes)
    {
        return builder.InstancePerMatchingLifetimeScope(serviceTypes.Select(s => new TypedService(s)).ToArray());
    }
}

The usage would then just be:

builder.RegisterType<BarChannel>().InstancePerOwned(GetTypesImplementingInterface<IUnitOfWork>());

I'm not sure if the last part there would be worth pulling into Autofac itself, but I guess if it did then it might be better to combine the two methods above together and retrieve the list of types applicable from existing registrations, e.g. something like

InstancePerOwnedImplementing<TInterface>();

Alternatively, it would probably be a bit messy to extend the matching scope logic to check the relationship between types at resolution time, since not all tags are of the type Type.