C# Online Compiler | .NET Fiddle

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
	{
	}
}

 
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