In Autofac, how do I propagate Keys through Adapters

Question

I'm using the adapter support in Autofac to convert multiple types to a desired type. I also want to preserve the keys/names/metadata attached to the adapter input types, so that they exist with the same values on the adapter output types - this is needed for using IIndex<,> to resolve instances by name.

I can't figure out how to propagate the keys/names/metadata through the adapter function, since the adapter function runs during component construction, and the metadata needs to be propagated when the container is built.

Here's an example xunit test, which fails:

/// <summary>
/// Unit test to figure out how to propagate keys through adapters.
/// </summary>
public sealed class AutofacAdapterTest
{

public class A
{
    public A(string key)
    {
        Key = key;
    }

    public string Key { get; private set; }
}


public class B
{
    public B(string name)
    {
        Name = name;
    }

    public string Name { get; private set; }
}


public class C : B
{
    public C(string name)
        : base(name)
    {}
}

public class LookerUpper
{
    private readonly IIndex<string, B> _bIndex;

    public LookerUpper(IIndex<string, B> bIndex)
    {
        _bIndex = bIndex;
    }

    public B LookupByName(string name)
    {
        return _bIndex[name];
    }
}

[Fact]
public void TestPropagateKeysThroughAdapters()
{
    var builder = new ContainerBuilder();

    // Register named types
    builder.RegisterType<A>().Named<A>("A").WithParameter("key", "A");
    builder.RegisterType<B>().Named<B>("B").WithParameter("name", "B");
    builder.RegisterType<C>().Named<C>("C").Named<B>("C").WithParameter("name", "C");

    // Adapter to convert an A to a B, since it's not a subclass
    builder.RegisterAdapter<A, B>((c, a) => new B(a.Key));

    // Register LookerUpper, which is the only top-level type that needs to be autowired
    builder.RegisterType<LookerUpper>();

    var container = builder.Build();
    var lookerUpper = container.Resolve<LookerUpper>();

    // Test expected results
    Assert.Equal("A", lookerUpper.LookupByName("A").Name);
    Assert.IsType<B>(lookerUpper.LookupByName("A")); // A should have been adapted to a B

    Assert.Equal("B", lookerUpper.LookupByName("B").Name);
    Assert.IsType<B>(lookerUpper.LookupByName("B"));

    Assert.Equal("C", lookerUpper.LookupByName("C").Name);
    Assert.IsType<C>(lookerUpper.LookupByName("C"));

    Assert.Throws<ComponentNotRegisteredException>(() => lookerUpper.LookupByName("D"));
}

}

The statement lookerUpper.LookupByName("A") fails with a ComponentNotRegisteredException, because the name value "A" is not propagated through the adapter function (which adapts A -> B ). If the first two lines of Asserts are commented out, the rest of the test works as expected.

It seems the capabilities of the `RegisterAdapter` are limited in this scenario when you are using `Named` registrations... if you don't mind to repeat the names during the registration you can manually wire up your adapter with `builder.Register(c => new B(c.ResolveNamed("A").Key)).Named("A");`... if you replace your current `builder.RegisterAdapter` line with the previous registration it makes your test pass. — nemesv, Jan 08 '14 at 06:03
Thanks nemesv - I was aware I could do that, but wanted to know if there's a way I could do that without manually wiring up adaptation for each type. My real use case has a number of alternate classes in a hierarchy and adapter functions, so it would be better if I didn't have to perform explicit wiring. I'm currently looking into implementing an `IRegistrationSource` similar to the one used to create adapters... and I'm debating whether that's worth the work vs manual wiring. — crimbo, Jan 08 '14 at 15:28

score 1 · Accepted Answer · answered Jan 09 '14 at 00:43

I found a workable solution to this problem by using Autofac Metadata instead of Autofac keys or names. For the call to RegisterAdapter<TFrom, TTo>(Func<TFrom,TTo>), metadata is propagated from the IComponentRegistration for TFrom to the IComponentRegistration for TTo; however the keys/names are not propagated. The omission of keys may be a bug or by design, I'll file a bug with autofac to figure out which is the case and follow up.

The unfortunate part about using metadata is I can't use an IIndex<string, B> constructor parameter, so I had to use an IEnumerable<Meta<Lazy<B>>> parameter and create my own dictionary of string -> Lazy<B> to provide similiar functionality to IIndex. Here's the code that works:

/// <summary>
/// Unit test to figure out how to propagate keys through adapters.
/// </summary>
public sealed class AutofacAdapterTest
{
    internal const string LookupKey = "lookup";

    public class A
    {
        public A(string key)
        {
            Key = key;
        }

        public string Key { get; private set; }
    }

    public class B
    {
        public B(string name)
        {
            Name = name;
        }

        public string Name { get; private set; }
    }

    public class C : B
    {
        public C(string name)
            : base(name)
        {}
    }

    public class LookerUpper
    {
        private readonly IDictionary<string, Lazy<B>> _bLookup;

        public LookerUpper(IEnumerable<Meta<Lazy<B>>> bMetas)
        {
            _bLookup = bMetas.ToDictionary(meta => meta.Metadata[LookupKey].ToString(), meta => meta.Value);
        }

        public B LookupByName(string name)
        {
            return _bLookup[name].Value;
        }
    }

    [Fact]
    public void TestPropagateKeysThroughAdapters()
    {
        var builder = new ContainerBuilder();

        // Register types that will be looked up; attach metadata for the lookup key
        builder.Register((c) => new A("A")).WithMetadata(LookupKey, "A");
        builder.Register((c) => new B("B")).WithMetadata(LookupKey, "B");
        builder.Register((c) => new C("C")).AsSelf().As<B>().WithMetadata(LookupKey, "C");

        // Adapter to convert an A to a B, since it's not a subclass
        builder.RegisterAdapter<A, B>((c, a) => new B(a.Key));

        // Register LookerUpper, which is the only top-level type that needs to be autowired
        builder.RegisterType<LookerUpper>();

        var container = builder.Build();

        var lookerUpper = container.Resolve<LookerUpper>();

        // Test expected results
        Assert.Equal("A", lookerUpper.LookupByName("A").Name);
        Assert.IsType<B>(lookerUpper.LookupByName("A")); // A should have been adapted to a B

        Assert.Equal("B", lookerUpper.LookupByName("B").Name);
        Assert.IsType<B>(lookerUpper.LookupByName("B"));

        Assert.Equal("C", lookerUpper.LookupByName("C").Name);
        Assert.IsType<C>(lookerUpper.LookupByName("C"));

        Assert.Throws<KeyNotFoundException>(() => lookerUpper.LookupByName("D"));
    }
}

It should also be possible to create an IRegistrationSource and some extension methods that extend what is done in RegisterAdapter<TFrom, TTo>, such that the keys in TFrom are propagated to TTo - that would be an ideal solution, but potentially more work to maintain, so I'll probably stick with this.

Here's the issue I submitted to autofac: https://code.google.com/p/autofac/issues/detail?id=482 — crimbo, Jan 09 '14 at 17:29

score 1 · Answer 2 · answered Feb 27 '15 at 07:57

1

It was fixed in Autofac version 3.5.1.

Link to the bug
Link to the fix

answered Feb 27 '15 at 07:57

Alexandr Nikitin

7,258
2
34
42

In Autofac, how do I propagate Keys through Adapters

2 Answers2