public Startup(IHostingEnvironment hostingEnvironment, IApplicationEnvironment applicationEnvironment, IAssemblyLoaderContainer assemblyLoaderContainer, IAssemblyLoadContextAccessor assemblyLoadContextAccessor, ILibraryManager libraryManager)
 {
   this.applicationBasePath = applicationEnvironment.ApplicationBasePath;
   this.assemblyLoaderContainer = assemblyLoaderContainer;
   this.assemblyLoadContextAccessor = assemblyLoadContextAccessor;
   this.libraryManager = libraryManager;
 }

 public EncodingJobFactory(ILogger logger, ILibraryManager libraryManager, IMediaSourceManager mediaSourceManager, IConfigurationManager config)
 {
     _logger = logger;
     _libraryManager = libraryManager;
     _mediaSourceManager = mediaSourceManager;
     _config = config;
 }

        /// <summary>
        /// Sets the initial item values.
        /// </summary>
        /// <param name="item">The item.</param>
        /// <param name="args">The args.</param>
        /// <param name="fileSystem">The file system.</param>
        /// <param name="libraryManager">The library manager.</param>
        public static void SetInitialItemValues(BaseItem item, ItemResolveArgs args, IFileSystem fileSystem, ILibraryManager libraryManager)
        {
            // If the resolver didn't specify this
            if (string.IsNullOrEmpty(item.Path))
            {
                item.Path = args.Path;
            }

            // If the resolver didn't specify this
            if (args.Parent != null)
            {
                item.Parent = args.Parent;
            }

            item.Id = libraryManager.GetNewItemId(item.Path, item.GetType());

            // Make sure the item has a name
            EnsureName(item, args.FileInfo);

            item.IsLocked = item.Path.IndexOf("[dontfetchmeta]", StringComparison.OrdinalIgnoreCase) != -1 ||
                item.Parents.Any(i => i.IsLocked);

            // Make sure DateCreated and DateModified have values
            EnsureDates(fileSystem, item, args, true);
        }

 public ChannelPostScanTask(IChannelManager channelManager, IUserManager userManager, ILogger logger, ILibraryManager libraryManager)
 {
     _channelManager = channelManager;
     _userManager = userManager;
     _logger = logger;
     _libraryManager = libraryManager;
 }

 /// <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 EpisodeXmlProvider(IItemRepository itemRepository, IServerConfigurationManager config, ILibraryManager libraryManager, IFileSystem fileSystem)
 {
     _itemRepository = itemRepository;
     _config = config;
     _libraryManager = libraryManager;
     _fileSystem = fileSystem;
 }

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

 public SyncManager(ILibraryManager libraryManager, ISyncRepository repo, IImageProcessor imageProcessor, ILogger logger)
 {
     _libraryManager = libraryManager;
     _repo = repo;
     _imageProcessor = imageProcessor;
     _logger = logger;
 }

 public DlnaEntryPoint(IServerConfigurationManager config, 
     ILogManager logManager, 
     IServerApplicationHost appHost, 
     INetworkManager network, 
     ISessionManager sessionManager, 
     IHttpClient httpClient, 
     ILibraryManager libraryManager, 
     IUserManager userManager, 
     IDlnaManager dlnaManager, 
     IImageProcessor imageProcessor, 
     IUserDataManager userDataManager, 
     ILocalizationManager localization, 
     IMediaSourceManager mediaSourceManager, 
     ISsdpHandler ssdpHandler)
 {
     _config = config;
     _appHost = appHost;
     _network = network;
     _sessionManager = sessionManager;
     _httpClient = httpClient;
     _libraryManager = libraryManager;
     _userManager = userManager;
     _dlnaManager = dlnaManager;
     _imageProcessor = imageProcessor;
     _userDataManager = userDataManager;
     _localization = localization;
     _mediaSourceManager = mediaSourceManager;
     _ssdpHandler = (SsdpHandler)ssdpHandler;
     _logger = logManager.GetLogger("Dlna");
 }

 public LocalTrailerDownloadTask(ILibraryManager libraryManager, ILogger logger, ILibraryMonitor libraryMonitor, IChannelManager channelManager)
 {
     _libraryManager = libraryManager;
     _logger = logger;
     _channelManager = channelManager;
     _libraryMonitor = libraryMonitor;
 }

 public MissingEpisodeProvider(ILogger logger, IServerConfigurationManager config, ILibraryManager libraryManager, ILocalizationManager localization)
 {
     _logger = logger;
     _config = config;
     _libraryManager = libraryManager;
     _localization = localization;
 }

 public RefreshChannelsScheduledTask(IChannelManager channelManager, IUserManager userManager, ILogger logger, ILibraryManager libraryManager)
 {
     _channelManager = channelManager;
     _userManager = userManager;
     _logger = logger;
     _libraryManager = libraryManager;
 }

 public TVSeriesManager(IUserManager userManager, IUserDataManager userDataManager, ILibraryManager libraryManager, IServerConfigurationManager config)
 {
     _userManager = userManager;
     _userDataManager = userDataManager;
     _libraryManager = libraryManager;
     _config = config;
 }

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

        public SearchEngine(ILogManager logManager, ILibraryManager libraryManager, IUserManager userManager)
        {
            _libraryManager = libraryManager;
            _userManager = userManager;

            _logger = logManager.GetLogger("Lucene");
        }

 public DummySeasonProvider(IServerConfigurationManager config, ILogger logger, ILocalizationManager localization, ILibraryManager libraryManager)
 {
     _config = config;
     _logger = logger;
     _localization = localization;
     _libraryManager = libraryManager;
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="PeopleValidator" /> class.
 /// </summary>
 /// <param name="libraryManager">The library manager.</param>
 /// <param name="logger">The logger.</param>
 public PeopleValidator(ILibraryManager libraryManager, ILogger logger, IServerConfigurationManager config, IFileSystem fileSystem)
 {
     _libraryManager = libraryManager;
     _logger = logger;
     _config = config;
     _fileSystem = fileSystem;
 }

 public SharingManager(SharingRepository repository, IServerConfigurationManager config, ILibraryManager libraryManager, IServerApplicationHost appHost)
 {
     _repository = repository;
     _config = config;
     _libraryManager = libraryManager;
     _appHost = appHost;
 }

        public OrchardLibraryManager(ILibraryManager libraryManager)
        {
            _libraryManager = libraryManager;

            AdditionalLibraries = new List<Library>();
            MetadataReferences = new List<IMetadataReference>();
        }

 public SubtitleScheduledTask(ILibraryManager libraryManager, IServerConfigurationManager config, ISubtitleManager subtitleManager, ILogger logger)
 {
     _libraryManager = libraryManager;
     _config = config;
     _subtitleManager = subtitleManager;
     _logger = logger;
 }