Autofac Registration Examples for Resolving specific types

Test.cs

using Autofac;
using Autofac.Core;
using Microsoft.VisualStudio.TestTools.UnitTesting;

namespace Testage
{
    [TestClass]
    public abstract class ConcernForResolvingLoggers
    {
        protected ContainerBuilder Builder;
        private IContainer _container;

        [TestInitialize]
        public void SetUp()
        {
            Builder = new ContainerBuilder();
            Context();
            _container = Builder.Build();
        }

        protected abstract void Context();

        [TestMethod]
        public void ResolvesTheCorrectLogger()
        {
            Assert.IsInstanceOfType(_container.Resolve<HasLogger1>().Logger, typeof (Logger1));
            Assert.IsInstanceOfType(_container.Resolve<HasLogger2>().Logger, typeof (Logger2));
        }
    }

    [TestClass]
    public class WithParameter : ConcernForResolvingLoggers
    {
        protected override void Context()
        {
            Builder
                .RegisterType<Logger1>()
                .AsImplementedInterfaces()
                .AsSelf()
                .InstancePerLifetimeScope();

            Builder
                .RegisterType<Logger2>()
                .AsImplementedInterfaces()
                .AsSelf()
                .InstancePerLifetimeScope();

            Builder
                .RegisterType<HasLogger1>()
                .WithParameter(new ResolvedParameter((p, c) => p.ParameterType.IsAssignableTo<ILogger>(), (p, c) => c.Resolve<Logger1>()))
                .AsSelf()
                .InstancePerLifetimeScope();

            Builder
                .RegisterType<HasLogger2>()
                .WithParameter(new ResolvedParameter((p, c) => p.ParameterType.IsAssignableTo<ILogger>(), (p, c) => c.Resolve<Logger2>()))
                .AsSelf()
                .InstancePerLifetimeScope();
        }
    }

    [TestClass]
    public class Named : ConcernForResolvingLoggers
    {
        protected override void Context()
        {
            Builder
                .RegisterType<Logger1>()
                .Named<ILogger>("Log1")
                .InstancePerLifetimeScope();

            Builder
                .RegisterType<Logger2>()
                .Named<ILogger>("Log2")
                .AsSelf()
                .InstancePerLifetimeScope();

            Builder
                .Register(c => new HasLogger1(c.ResolveNamed<ILogger>("Log1")))
                .AsSelf()
                .InstancePerLifetimeScope();

            Builder.Register(c => new HasLogger2(c.ResolveNamed<ILogger>("Log2")))
                .AsSelf()
                .InstancePerLifetimeScope();
        }
    }

    [TestClass]
    public class Keyed : ConcernForResolvingLoggers
    {
        protected override void Context()
        {
            Builder
                .RegisterType<Logger1>()
                .Keyed<ILogger>(typeof (Logger1)).AsSelf()
                .InstancePerLifetimeScope();

            Builder
                .RegisterType<Logger2>()
                .Keyed<ILogger>(typeof (Logger2))
                .AsSelf()
                .InstancePerLifetimeScope();

            Builder
                .Register(c => new HasLogger1(c.ResolveKeyed<ILogger>(typeof (Logger1))))
                .AsSelf()
                .InstancePerLifetimeScope();

            Builder.Register(c => new HasLogger2(c.ResolveKeyed<ILogger>(typeof (Logger2))))
                .AsSelf()
                .InstancePerLifetimeScope();
        }
    }

    public interface ILogger
    {
    }

    public class Logger2 : ILogger
    {
    }

    public class Logger1 : ILogger
    {
    }

    public class HasLogger1
    {
        private readonly ILogger _logger;

        public HasLogger1(ILogger logger)
        {
            _logger = logger;
        }

        public ILogger Logger
        {
            get { return _logger; }
        }
    }

    public class HasLogger2
    {
        private readonly ILogger _logger;

        public HasLogger2(ILogger logger)
        {
            _logger = logger;
        }

        public ILogger Logger
        {
            get { return _logger; }
        }
    }
}