public ItemController(IItemRepository itemRepository, IMapper mapper)
 {
     if (itemRepository == null) throw new ArgumentNullException(nameof(itemRepository));
     if (mapper == null) throw new ArgumentNullException(nameof(mapper));
    _itemRepository = itemRepository;
    _mapper = mapper;
 }

 public InternalEncodingTaskFactory(ILibraryManager libraryManager, ILiveTvManager liveTvManager, IItemRepository itemRepo, IServerConfigurationManager config)
 {
     _libraryManager = libraryManager;
     _liveTvManager = liveTvManager;
     _itemRepo = itemRepo;
     _config = config;
 }

 public DtoBuilder(ILogger logger, ILibraryManager libraryManager, IUserDataRepository userDataRepository, IItemRepository itemRepo)
 {
     _logger = logger;
     _libraryManager = libraryManager;
     _userDataRepository = userDataRepository;
     _itemRepo = itemRepo;
 }

        /// <summary>
        /// Initializes a new instance of the <see cref="MainWindow" /> class.
        /// </summary>
        /// <param name="logManager">The log manager.</param>
        /// <param name="appHost">The app host.</param>
        /// <param name="configurationManager">The configuration manager.</param>
        /// <param name="userManager">The user manager.</param>
        /// <param name="libraryManager">The library manager.</param>
        /// <param name="jsonSerializer">The json serializer.</param>
        /// <param name="displayPreferencesManager">The display preferences manager.</param>
        /// <exception cref="System.ArgumentNullException">logger</exception>
        public MainWindow(ILogManager logManager, IServerApplicationHost appHost, IServerConfigurationManager configurationManager, IUserManager userManager, ILibraryManager libraryManager, IJsonSerializer jsonSerializer, IDisplayPreferencesRepository displayPreferencesManager, IItemRepository itemRepo)
        {
            if (logManager == null)
            {
                throw new ArgumentNullException("logManager");
            }
            if (appHost == null)
            {
                throw new ArgumentNullException("appHost");
            }
            if (configurationManager == null)
            {
                throw new ArgumentNullException("configurationManager");
            }

            _logger = logManager.GetLogger("MainWindow");
            _itemRepository = itemRepo;
            _appHost = appHost;
            _logManager = logManager;
            _configurationManager = configurationManager;
            _userManager = userManager;
            _libraryManager = libraryManager;
            _jsonSerializer = jsonSerializer;
            _displayPreferencesManager = displayPreferencesManager;

            InitializeComponent();

            Loaded += MainWindowLoaded;
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="MoviesService"/> class.
 /// </summary>
 /// <param name="userManager">The user manager.</param>
 /// <param name="userDataRepository">The user data repository.</param>
 /// <param name="libraryManager">The library manager.</param>
 public MoviesService(IUserManager userManager, IUserDataRepository userDataRepository, ILibraryManager libraryManager, IItemRepository itemRepo)
 {
     _userManager = userManager;
     _userDataRepository = userDataRepository;
     _libraryManager = libraryManager;
     _itemRepo = itemRepo;
 }

 public BorrowerItemController(IBorrowerItemRepository borrowerItemRepository, IMappingEngine mappingEngine, IBorrowerRepository borrowerRepository, IItemRepository itemRepository)
 {
     _borrowerItemRepository = borrowerItemRepository;
     _mappingEngine = mappingEngine;
     _borrowerRepository = borrowerRepository;
     _itemRepository = itemRepository;
 }

        public FurnaceWindow(IEventScheduler scheduler, Coordinates3D coordinates,
            IItemRepository itemRepository, InventoryWindow inventory)
        {
            ItemRepository = itemRepository;
            EventScheduler = scheduler;
            Coordinates = coordinates;

            WindowAreas = new[]
                {
                    new WindowArea(IngredientIndex, 1, 1, 1),
                    new WindowArea(FuelIndex, 1, 1, 1),
                    new WindowArea(OutputIndex, 1, 1, 1),
                    new WindowArea(MainIndex, 27, 9, 3),
                    new WindowArea(HotbarIndex, 9, 9, 1)
                };
            inventory.MainInventory.CopyTo(MainInventory);
            inventory.Hotbar.CopyTo(Hotbar);
            foreach (var area in WindowAreas)
                area.WindowChange += (s, e) => OnWindowChange(new WindowChangeEventArgs(
                    (s as WindowArea).StartIndex + e.SlotIndex, e.Value));
            Copying = false;
            inventory.WindowChange += (sender, e) =>
            {
                if (Copying) return;
                if ((e.SlotIndex >= InventoryWindow.MainIndex && e.SlotIndex < InventoryWindow.MainIndex + inventory.MainInventory.Length)
                    || (e.SlotIndex >= InventoryWindow.HotbarIndex && e.SlotIndex < InventoryWindow.HotbarIndex + inventory.Hotbar.Length))
                {
                    inventory.MainInventory.CopyTo(MainInventory);
                    inventory.Hotbar.CopyTo(Hotbar);
                }
            };
        }

 public CleanDatabaseScheduledTask(ILibraryManager libraryManager, IItemRepository itemRepo, ILogger logger, IServerConfigurationManager config)
 {
     _libraryManager = libraryManager;
     _itemRepo = itemRepo;
     _logger = logger;
     _config = config;
 }

 public ChapterManager(ILibraryManager libraryManager, ILogger logger, IServerConfigurationManager config, IItemRepository itemRepo)
 {
     _libraryManager = libraryManager;
     _logger = logger;
     _config = config;
     _itemRepo = itemRepo;
 }

 public PnRegAppService(IPnRegQuery pnRegQuery, IPnRegRepository pnRegRepository,
     IItemRepository itemRepository)
 {
     _pnRegQuery = pnRegQuery;
     _pnRegRepository = pnRegRepository;
     _itemRepository = itemRepository;
 }

 public AdminController(IItemRepository itemRepository, IBasketRepository basketRepository)
 {
     if (itemRepository == null) throw new ArgumentNullException(nameof(itemRepository));
     if (basketRepository == null) throw new ArgumentNullException(nameof(basketRepository));
     _itemRepository = itemRepository;
     _basketRepository = basketRepository;
 }

 public EpisodeXmlProvider(IItemRepository itemRepository, IServerConfigurationManager config, ILibraryManager libraryManager, IFileSystem fileSystem)
 {
     _itemRepository = itemRepository;
     _config = config;
     _libraryManager = libraryManager;
     _fileSystem = fileSystem;
 }

 public EpisodeProviderFromXml(ILogManager logManager, IServerConfigurationManager configurationManager, IItemRepository itemRepo, IFileSystem fileSystem)
     : base(logManager, configurationManager)
 {
     _itemRepo = itemRepo;
     _fileSystem = fileSystem;
     Current = this;
 }

 public LiveTvDtoService(IDtoService dtoService, IUserDataManager userDataManager, IImageProcessor imageProcessor, ILogger logger, IItemRepository itemRepo)
 {
     _dtoService = dtoService;
     _userDataManager = userDataManager;
     _imageProcessor = imageProcessor;
     _logger = logger;
     _itemRepo = itemRepo;
 }

 public SubtitleManager(ILogger logger, IFileSystem fileSystem, ILibraryMonitor monitor, ILibraryManager libraryManager, IItemRepository itemRepo)
 {
     _logger = logger;
     _fileSystem = fileSystem;
     _monitor = monitor;
     _libraryManager = libraryManager;
     _itemRepo = itemRepo;
 }

 public PlayToControllerFactory(ISessionManager sessionManager, IItemRepository itemRepository, ILibraryManager libraryManager, ILogManager logManager, INetworkManager networkManager)
 {
     _itemRepository = itemRepository;
     _sessionManager = sessionManager;
     _libraryManager = libraryManager;
     _networkManager = networkManager;
     _logger = logManager.GetLogger("PlayTo");
 }

 public MediaSourceManager(IItemRepository itemRepo, IUserManager userManager, ILibraryManager libraryManager, ILogger logger, IJsonSerializer jsonSerializer)
 {
     _itemRepo = itemRepo;
     _userManager = userManager;
     _libraryManager = libraryManager;
     _logger = logger;
     _jsonSerializer = jsonSerializer;
 }

 public LiveTvManager(IServerApplicationPaths appPaths, IFileSystem fileSystem, ILogger logger, IItemRepository itemRepo, IImageProcessor imageProcessor)
 {
     _appPaths = appPaths;
     _fileSystem = fileSystem;
     _logger = logger;
     _itemRepo = itemRepo;
     _imageProcessor = imageProcessor;
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="ImageCleanupTask" /> class.
 /// </summary>
 /// <param name="kernel">The kernel.</param>
 /// <param name="logger">The logger.</param>
 /// <param name="libraryManager">The library manager.</param>
 /// <param name="appPaths">The app paths.</param>
 public ImageCleanupTask(Kernel kernel, ILogger logger, ILibraryManager libraryManager, IServerApplicationPaths appPaths, IItemRepository itemRepo)
 {
     _kernel = kernel;
     _logger = logger;
     _libraryManager = libraryManager;
     _appPaths = appPaths;
     _itemRepo = itemRepo;
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="ChapterImagesTask" /> class.
 /// </summary>
 /// <param name="logManager">The log manager.</param>
 /// <param name="libraryManager">The library manager.</param>
 /// <param name="itemRepo">The item repo.</param>
 public ChapterImagesTask(ILogManager logManager, ILibraryManager libraryManager, IItemRepository itemRepo, IApplicationPaths appPaths, IEncodingManager encodingManager)
 {
     _logger = logManager.GetLogger(GetType().Name);
     _libraryManager = libraryManager;
     _itemRepo = itemRepo;
     _appPaths = appPaths;
     _encodingManager = encodingManager;
 }