using Autofac;

using Autofac.Builder;

using Autofac.Core;

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

​

namespace AUtofacTest

{

    public class Program

    {

        public static void Main()

        {

            // Older system

            var serviceResolver = new MyResolver();

​

            // Newer System

            var autofacBuilder = new ContainerBuilder();

            autofacBuilder.RegisterSource(new AutofacServiceProviderRegistrationSource(serviceResolver));

            var ioc = autofacBuilder.Build();

​

            // Old system resovles services it knows about

            var myService = serviceResolver.GetService(typeof(IMyService));

            // new system works - resolves from older system, and also types it knows about

            var myNewService = ioc.Resolve<IMyService>();

            System.Console.WriteLine("Types Found!");

        }   

    }

    public class AutofacServiceProviderRegistrationSource : IRegistrationSource

    {

        private readonly MyResolver serviceProvider;

​

        public AutofacServiceProviderRegistrationSource(MyResolver serviceProvider)

        {

            this.serviceProvider = serviceProvider;

        }

​

        public IEnumerable<IComponentRegistration> RegistrationsFor(Service service, Func<Service, IEnumerable<IComponentRegistration>> registrationAccessor)

        {

            // Already in new system? Does our system have it?

            var swt = service as IServiceWithType;

            if (registrationAccessor(service).Any() || swt == null || !serviceProvider.SupportedServices.Any(s => s == swt.ServiceType))

                return Enumerable.Empty<IComponentRegistration>();

​

            // register the resolver call with the container - marked externally owned so Autofac does not maintain Dipose lifetime - old system managed lifetime itself

            var registration = RegistrationBuilder.ForDelegate(swt.ServiceType, (c, p) => serviceProvider.GetService(swt.ServiceType)).ExternallyOwned().CreateRegistration();

            return new[] { registration };

        }

​

        public bool IsAdapterForIndividualComponents

        {

            get { return false; }

        }

    }

​

    public class MyResolver : IServiceProvider

    {

        private Dictionary<Type, Type> registeredTypes = new Dictionary<Type, Type>();

​

        public MyResolver()

        {

            registeredTypes[typeof(IMyService)] = typeof(MyService);

        }

​

        public List<Type> SupportedServices { get { return registeredTypes.Keys.ToList(); } }

​

        public object GetService(Type serviceType)

        {

            Type requiredType;

            if (!registeredTypes.TryGetValue(serviceType, out requiredType))

                return null;

​

            return Activator.CreateInstance(requiredType);

        }

    }

​

    public interface IMyService

    {

    }

​

    public class MyService : IMyService

    {

    }

}

​