public ShadowCultureManager(IRepository<CultureRecord> cultureRepository, 
                              IEnumerable<ICultureSelector> cultureSelectors, 
                              ISignals signals, 
                              IWorkContextAccessor workContextAccessor) {
     _workContextAccessor = workContextAccessor;
     _underlyingCultureManager = new DefaultCultureManager(cultureRepository, cultureSelectors, signals, workContextAccessor);
 }

 /// <summary>
 /// Ctor
 /// </summary>
 /// <param name="cacheManager">Cache manager</param>
 /// <param name="notificationRepository">Notification repository</param>
 /// <param name="eventPublisher">Event published</param>
 public NotificationService(ICacheManager cacheManager,
     IRepository<Notification> notificationRepository,
     ISignals signals) {
     _cacheManager = cacheManager;
     _notificationRepository = notificationRepository;
     _signals = signals;
 }

        public LocalizedTagCloudHandler(
            ILocalizedTagsService tagsService,
            ISignals signals) {

            _tagsService = tagsService;
            _signals = signals;
        }

        public UrlPermissionPartHandler(ISignals signals)
        {
            _signals = signals;

            OnUpdated<UrlPermissionPart>(EmptyCache);
            OnRemoved<UrlPermissionPart>(EmptyCache);
        }

 /// <summary>
 /// Ctor
 /// </summary>
 /// <param name="cacheManager">Cache manager</param>
 /// <param name="storeRepository">Store repository</param>
 public StoreService(ICacheManager cacheManager,
     IRepository<Store> storeRepository,
     ISignals signals) {
     this._cacheManager = cacheManager;
     this._storeRepository = storeRepository;
     this._signals = signals;
 }

        public ShapePartHandler(ISignals signals) {
            _signals = signals;

            OnPublished<ShapePart>((ctx, part) => InvalidateTemplatesCache());
            OnUnpublished<ShapePart>((ctx, part) => InvalidateTemplatesCache());
            OnRemoved<ShapePart>((ctx, part) => InvalidateTemplatesCache());
        }

        public ThumbnailsService(ShellSettings settings, IWorkContextAccessor wca, ICacheManager cacheManager, IMediaService mediaService, ISignals signals, IStorageProvider storageProvider)
        {
            _wca = wca;
            _cacheManager = cacheManager;
            _mediaService = mediaService;
            _signals = signals;
            _storageProvider = storageProvider;
            var appPath = "";
            if (HostingEnvironment.IsHosted)
            {
                appPath = HostingEnvironment.ApplicationVirtualPath;
            }
            if (!appPath.EndsWith("/"))
                appPath = appPath + '/';
            if (!appPath.StartsWith("/"))
                appPath = '/' + appPath;

            _publicPath = appPath + "Media/" + settings.Name + "/";

            var physPath = ThumbnailsCacheMediaPath.Replace('/', Path.DirectorySeparatorChar);
            var parent = Path.GetDirectoryName(physPath);
            var folder = Path.GetFileName(physPath);
            if (_mediaService.GetMediaFolders(parent).All(f => f.Name != folder))
            {
                _mediaService.CreateFolder(parent, folder);
            }
        }

 public AdminController(IContentManager contentManager,
     IOrchardServices services,
     IShapeFactory shapeFactory,
     IContentDefinitionManager contentDefinitionManager,
     IRemoteContentFetchService remoteContentFetchService,
     ISynchronisationMapFactory synchronisationMapFactory,
     IRepository<ContentSyncSettings> contentSyncSettingsRepository,
     ISignals signals,
     ILoggerFactory loggerFactory,
     ICacheManager cacheManager,
     IImportExportService importExportService,
     IRecipeParser recipeParser,
     IRemoteImportService remoteImportService,
     IEnumerable<IHardComparer> hardComparers, 
     IEnumerable<ISoftComparer> softComparers) {
     _contentManager = contentManager;
     _services = services;
     _shapeFactory = shapeFactory;
     _contentDefinitionManager = contentDefinitionManager;
     _remoteContentFetchService = remoteContentFetchService;
     _synchronisationMapFactory = synchronisationMapFactory;
     _contentSyncSettingsRepository = contentSyncSettingsRepository;
     _signals = signals;
     _loggerFactory = loggerFactory;
     _cacheManager = cacheManager;
     _importExportService = importExportService;
     _recipeParser = recipeParser;
     _remoteImportService = remoteImportService;
     _hardComparers = hardComparers;
     _softComparers = softComparers;
     Logger = loggerFactory.CreateLogger(typeof (AdminController));
     }

 public AdminController(IOrchardServices services, ILinkRewriteService service, ISignals signals)
 {
     _services = services;
     _service = service;
     _signals = signals;
     T = NullLocalizer.Instance;
 }

 public AdvancedSitemapService(
     IRepository<SitemapRouteRecord> routeRepository, 
     IRepository<SitemapSettingsRecord> settingsRepository,
     IRepository<SitemapCustomRouteRecord> customRouteRepository,
     IContentManager contentManager,
     ICacheManager cacheManager,
     ISignals signals,
     IClock clock,
     IContentDefinitionManager contentDefinitionManager,
     IEnumerable<ISitemapRouteFilter> routeFilters,
     IEnumerable<ISitemapRouteProvider> routeProviders, 
     ISiteService siteService, 
     IEnumerable<ISpecializedSitemapProvider> specializedSitemapProviders)
 {
     _routeRepository = routeRepository;
     _settingsRepository = settingsRepository;
     _customRouteRepository = customRouteRepository;
     _contentManager = contentManager;
     _cacheManager = cacheManager;
     _signals = signals;
     _clock = clock;
     _contentDefinitionManager = contentDefinitionManager;
     _routeFilters = routeFilters;
     _routeProviders = routeProviders;
     _siteService = siteService;
     _specializedSitemapProviders = specializedSitemapProviders;
 }

 /// <summary>
 /// Ctor
 /// </summary>
 /// <param name="cacheManager">Cache manager</param>
 /// <param name="departmentRepository">Department repository</param>
 /// <param name="eventPublisher">Event published</param>
 public DepartmentService(ICacheManager cacheManager,
     IRepository<Department> departmentRepository,
     ISignals signals) {
     _cacheManager = cacheManager;
     _departmentRepository = departmentRepository;
     _signals = signals;
 }

        public OutputCacheFilter(
            ICacheManager cacheManager,
            IOutputCacheStorageProvider cacheStorageProvider,
            ITagCache tagCache,
            IDisplayedContentItemHandler displayedContentItemHandler,
            IWorkContextAccessor workContextAccessor,
            IThemeManager themeManager,
            IClock clock,
            ICacheService cacheService,
            ISignals signals,
            ShellSettings shellSettings) {

            _cacheManager = cacheManager;
            _cacheStorageProvider = cacheStorageProvider;
            _tagCache = tagCache;
            _displayedContentItemHandler = displayedContentItemHandler;
            _workContextAccessor = workContextAccessor;
            _themeManager = themeManager;
            _clock = clock;
            _cacheService = cacheService;
            _signals = signals;
            _shellSettings = shellSettings;

            Logger = NullLogger.Instance;
        }

 public UsersService(
     IContentManager contentManager, 
     IOrchardServices orchardServices, 
     IRoleService roleService, 
     IMessageManager messageManager, 
     IScheduledTaskManager taskManager, 
     IRepository<EmailPartRecord> emailRepository, 
     ShellSettings shellSettings, 
     IRepository<UserRolesPartRecord> userRolesRepository, 
     ICacheManager cache, 
     IClock clock, 
     ISignals signals) 
 {
     _signals = signals;
     _clock = clock;
     _cache = cache;
     _emailRepository = emailRepository;
     _orchardServices = orchardServices;
     _contentManager = contentManager;
     _roleService = roleService;
     _messageManager = messageManager;
     _taskManager = taskManager;
     _shellSettings = shellSettings;
     _userRolesRepository = userRolesRepository;
     T = NullLocalizer.Instance;
     Logger = NullLogger.Instance;            
 }

 /// <summary>
 /// Ctor
 /// </summary>
 /// <param name="cacheManager">Cache manager</param>
 /// <param name="appVersionRepository">AppVersion repository</param>
 /// <param name="eventPublisher">Event published</param>
 public AppVersionService(ICacheManager cacheManager,
     IRepository<AppVersion> appVersionRepository,
     ISignals signals) {
     _cacheManager = cacheManager;
     _appVersionRepository = appVersionRepository;
     _signals = signals;
 }

 /// <summary>
 /// Ctor
 /// </summary>
 /// <param name="cacheManager">Cache manager</param>
 /// <param name="jPushUserRepository">JPushUser repository</param>
 /// <param name="eventPublisher">Event published</param>
 public JPushUserService(ICacheManager cacheManager,
     IRepository<JPushUser> jPushUserRepository,
     ISignals signals) {
     _cacheManager = cacheManager;
     _jPushUserRepository = jPushUserRepository;
     _signals = signals;
 }

 public SlickService(IWorkContextAccessor wca, ICacheManager cacheManager, ISignals signals, IMediaLibraryService mediaService)
 {
     _wca = wca;
     _cacheManager = cacheManager;
     _signals = signals;
     _mediaService = mediaService;
 }

 public VersionManagerInfoDataService(IRepository<VersionManagerRecord> versionManagerRecords, ICacheManager cacheManager, ISignals signals, IClock clock, INotifier notifier)
 {
     _versionManagerRecords = versionManagerRecords;
     _cacheManager = cacheManager;
     _signals = signals;
     _clock = clock;
     T = NullLocalizer.Instance;
 }

 public CachedUrlProtectorRules(IRepository<DashboardFilterRecord> dashboardFilterRecords, IRepository<UrlFilterRecord> urlFilterRecords, ICacheManager cacheManager, ISignals signals, IClock clock)
 {
     _dashboardFilterRecords = dashboardFilterRecords;
     _urlFilterRecords = urlFilterRecords;
     _cacheManager = cacheManager;
     _signals = signals;
     _clock = clock;
 }

 public SettingsService(
     IRepository<ThemePickerSettingsRecord> repository,
     ISignals signals,
     ICacheManager cacheManager) {
     _repository = repository;
     _signals = signals;
     _cacheManager = cacheManager;
 }

 public VersionManagerDataService(IRepository<ContentItemVersionRecord> contentItemVersionRepository, IRepository<VersionManagerRecord> versionManagerRecords, ICacheManager cacheManager, ISignals signals, IClock clock)
 {
     _contentItemVersionRepository = contentItemVersionRepository;
     _versionManagerRecords = versionManagerRecords;
     _cacheManager = cacheManager;
     _signals = signals;
     _clock = clock;
 }