internal class UserRepository : IUserRepository
	{
		private ModelDataContext _dataManager;

		public UserRepository(ModelDataContext DataContext)
		{
			_dataManager = DataContext;
		}
..........................................

private static void ConfigureIoC()
        {
            var builder = new ContainerBuilder();
            builder.RegisterControllers(Assembly.GetExecutingAssembly());

            // register repositories
            builder.RegisterType<UserRepository>().As<IUserRepository>().InstancePerHttpRequest();

            IContainer container = builder.Build();
            DependencyResolver.SetResolver(new AutofacDependencyResolver(container)); 
        }

public class DataManager
	{
		private ModelDataContextWrapper _dataContext;
		public DataManager()
		{
			_dataContext = new ModelDataContextWrapper();
		}

        private IUserRepository _userRepository;
        public IUserRepository Users;
		{
			get 
			{
				if (null == _userRepository)
					_userRepository = new UserRepository(_dataContext);

				return _userRepository;
			}
		}

public interface IDataManager: IDisposable
    {
        ModelDataContextWrapper Get();
    
        IUserRepository Users { get; }
}
public class DataManager: IDataManager, IDisposable
	{
		private ModelDataContextWrapper _dataContext;
		public DataManager()
		{
			Get();
		}
private IUserRepository _userRepository;
        public IUserRepository Users
        {
            get
            {
                if (null == _userRepository)
                    _userRepository = DependencyResolver.Current.GetService<IUserRepository>();

                return _userRepository;
            }
        }

public ModelDataContextWrapper Get()
        {
            return _dataContext ?? (_dataContext = new ModelDataContextWrapper());
        }

public class DataManager : IDataManager
	{		
                public DataManager(IUserRepository repository)
		{
                        _userRepository = repository;  // ДА!
		}

        private IUserRepository _userRepository;

public interface IDataManager: IDisposable
    {
        ModelDataContextWrapper Get();
    
        IUserRepository Users { get; }
        RoleRepository Roles { get; }
        CDMRepository CDMs { get; }
        CommandRepository Commands { get; }
        AuditRepository Audits { get; }
        MonitoringRepository Monitorings { get; }
        SettingRepository Settings { get; }

        void SubmitChanges();
    }

public class DatabaseFactory : IDisposable, IDatabaseFactory
    {
        private ModelDataContextWrapper _entityContext;
        public ModelDataContextWrapper Get()
        {
            return _entityContext ?? (_entityContext = new ModelDataContextWrapper());
        }

        public void Dispose()
        {
            if (null != _entityContext)
                _entityContext.Dispose();
        }
    }

builder.RegisterType<ModelDataContextWrapper>().As<IDatabaseFactory>().InstancePerLifetimeScope();

public ModelDataContextWrapper Get()
        {
            return _entityContext ?? (_entityContext = new ModelDataContextWrapper());
        }

 private static void ConfigureIoC()
        {
            var builder = new ContainerBuilder();
            builder.RegisterControllers(Assembly.GetExecutingAssembly());

            builder.RegisterType<ModelDataContextWrapper>().InstancePerLifetimeScope();
            builder.RegisterType<DataManager>().As<IDataManager>().InstancePerHttpRequest();
            builder.RegisterType<UserRepository>().As<IUserRepository>().InstancePerHttpRequest();

            IContainer container = builder.Build();
            DependencyResolver.SetResolver(new AutofacDependencyResolver(container)); 
        }

        public class DataManager : IDataManager
	{		
                public DataManager(IUserRepository repository)
		{
                        _userRepository = repository;
		}

        private IUserRepository _userRepository;
 }

        public class UserController : Controller
	{
		private IDataManager _dataManager;

        public UserController(IDataManager DataManager)
		{
            _dataManager = DataManager;
		}
}

internal class ControllerFactory: DefaultControllerFactory
	{
		protected override IController GetControllerInstance(System.Web.Routing.RequestContext RequestContext, Type ControllerType)
		{
			if (ControllerType == null) return null;

			return Activator.CreateInstance(ControllerType, new DataManager()) as Controller;
		}
	}

			var users = _dataManager.Users.GetUsers((int)user.ProviderUserKey);

public Controller(IRepository<User> userRepository)
		{
            _dataManager = DataManager;
		}

public Controller(IRepository<User> userRepository, IRepository<Audit> auditRepository)
		{
            _dataManager = DataManager;
		}

return Activator.CreateInstance(ControllerType, new ADM.Monitoring.Models.DataManager()) as Controller;

builder.Register(s => new ControllerFactory()).As<IControllerFactory>();

 public ControllerFactory()
        {
            List<IController> lstControllers = DependencyResolver.Current.GetServices<IController>().ToList();
            _controllerMap = new Dictionary<string, Func<RequestContext, IController>>();

            foreach (Controller contr in lstControllers)
            {
                string ctrName = contr.ControllerContext.RouteData.Values["Controller"].ToString();
                _controllerMap.Add(ctrName, c => contr);
            }
        }

 if ()
            {
                ControllerBuilder.Current.SetControllerFactory(new ControllerFactory());
            }
            else
            {
                ControllerBuilder.Current.SetControllerFactory(new ErrorControllerFactory());
            }

builder.RegisterControllers(typeof(MvcApplication).Assembly);

protected override IController GetControllerInstance(System.Web.Routing.RequestContext RequestContext, Type ControllerType)
{
	    if (ControllerType == null) return null;

	    var rd = RequestContext.RouteData;
	    string controller = rd.GetRequiredString("controller");
	    string actionName = rd.GetRequiredString("action");

            if (....) return null;
            if (....) return null;
            if (....) return null;

            List<String> list = new List<string>(new string[] { ...... });
            if (list.Contains(actionName) && ..................) return null;

            return Activator.CreateInstance(ControllerType, [color=red]DependencyResolver.Current.GetService<IDataManager>()[/color]) as Controller;
        }

 public static void Start() {
            ConfigureIoC();
 ViewEngines.Engines.Clear();
            if (.....)
            {
                ViewEngines.Engines.Add(new ThemedViewEngine());
                RouteConfig.RegisterRoutes(RouteTable.Routes);
                ControllerBuilder.Current.SetControllerFactory(new ControllerFactory());
            }
            else
            {
                ViewEngines.Engines.Add(new ErrorViewEngine());
                RouteConfig.RegisterCatchRoutes(RouteTable.Routes, message);
                ControllerBuilder.Current.SetControllerFactory(new ErrorControllerFactory());
            }
}

private static void ConfigureIoC()
        {
            var builder = new ContainerBuilder();
            builder.RegisterControllers(Assembly.GetExecutingAssembly());

            builder.RegisterType<ModelDataContext>().As<IModelDataContext>().InstancePerLifetimeScope();
            builder.RegisterType<ModelDataContextWrapper>().As<IModelDataContext>().InstancePerLifetimeScope();

            builder.RegisterType<DataManager>().As<IDataManager>().InstancePerHttpRequest();
            builder.RegisterType<AuditRepository>().As<IAuditRepository>().InstancePerHttpRequest();
            builder.RegisterType<CommandRepository>().As<ICommandRepository>().InstancePerHttpRequest();
            builder.RegisterType<CDMRepository>().As<ICDMRepository>().InstancePerHttpRequest();
            builder.RegisterType<MonitoringRepository>().As<IMonitoringRepository>().InstancePerHttpRequest();
            builder.RegisterType<RoleRepository>().As<IRoleRepository>().InstancePerHttpRequest();
            builder.RegisterType<SettingRepository>().As<ISettingRepository>().InstancePerHttpRequest();
            builder.RegisterType<UserRepository>().As<IUserRepository>().InstancePerHttpRequest();


            builder.RegisterFilterProvider();

            IContainer container = builder.Build();
            DependencyResolver.SetResolver(new AutofacDependencyResolver(container)); 
        }

internal class UserProvider : MembershipProvider
    {
        public IUserRepository Users { get; set; }

            builder.Register(context => Membership.Provider).ExternallyOwned();
            builder.Register(context => Roles.Provider).ExternallyOwned();
            builder.RegisterType<UserProvider>();

            builder.RegisterFilterProvider();

            IContainer container = builder.Build();
            DependencyResolver.SetResolver(new AutofacDependencyResolver(container));

            var lifetimeScope = DependencyResolver.Current.GetService<ILifetimeScope>();
            lifetimeScope.InjectProperties(Membership.Provider);
            lifetimeScope.InjectProperties(Roles.Provider);