public LockFileCleaner(
     IClock clock,
     IStorageProvider storageProvider)
 {
     _clock = clock;
     _storageProvider = storageProvider;
 }

 public ImportController()
 {
     inputConfigProvider = ObjectFactory.GetProvider<IInputConfigProvider>();
     scriptProvider = ObjectFactory.GetProvider<IScriptProvider>();
     appConfigProvider = ObjectFactory.GetProvider<IAppConfigProvider>();
     storageProvider = ObjectFactory.GetProvider<IStorageProvider>();
 }

 /// <summary>
 /// Loads the provider into the system.
 /// </summary>
 /// <param name="provider">The provider to add to the list.</param>
 public async Task LoadAsync(IStorageProvider provider)
 {
     if (provider == null)
         throw new NullReferenceException(ExceptionMessage.IsNullOrInvalid("provider"));
     await provider.LoadInfoAsync();
     _providers.Add(provider);            
 }

        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 PdfOutputController(IHtmlGenerator htmlGenerator, IPdfGenerator pdfGenerator, IStorageProvider storageProvider, IFilenameGenerator filenameGenerator)
 {
     this.htmlGenerator = htmlGenerator;
     this.pdfGenerator = pdfGenerator;
     this.storageProvider = storageProvider;
     this.filenameGenerator = filenameGenerator;
 }

        /// <summary>
        /// Initializes a new instance of the MediaService class with a given IStorageProvider and IOrchardServices.
        /// </summary>
        /// <param name="storageProvider">The storage provider.</param>
        /// <param name="orchardServices">The orchard services provider.</param>
        public MediaService(IStorageProvider storageProvider, IOrchardServices orchardServices)
        {
            _storageProvider = storageProvider;
            _orchardServices = orchardServices;

            T = NullLocalizer.Instance;
        }

        public RecipeJournalManager(IStorageProvider storageProvider)
        {
            _storageProvider = storageProvider;

            Logger = NullLogger.Instance;
            T = NullLocalizer.Instance;
        }

        public GameViewModel(int totalQuestions, IImageProvider imageProvider, IStorageProvider storageProvider)
        {
            _imageProvider = imageProvider;
            _storageProvider = storageProvider;

            // register all the events
            CommandEvents.ContinueButtonPressed += new EventHandler(ContinueButtonPressed);
            CommandEvents.AnswerButtonPressed += new EventHandler(AnswerButtonPressed);
            CommandEvents.HighScoreContinueButtonPressed += new EventHandler(HighScoreContinueButtonPressed);
            DisplayHighScore += new EventHandler(DisplayScore);

            // check to see whether any game state is already loaded
            if (_storageProvider.GameStateExists())
            {
                _game = _storageProvider.LoadGameState();

                // check if the player was in the middle of a question
                if (_game.CurrentQuestion.Answered)
                {
                    DisplayQuestion();
                    ContinueButtonPressed(this, new EventArgs());
                }
                else
                {
                    DisplayQuestion();
                }
            }
            else
            {
                _game = new Game(totalQuestions);
                ContinueButtonPressed(this, new EventArgs());
            }
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="ScanManager"/> class.
 /// </summary>
 /// <param name="storageProvider">
 /// The storage provider to use.
 /// </param>
 /// <param name="dataProvider">
 /// The data provider to use. 
 /// </param>
 internal ScanManager(IStorageProvider storageProvider, IDataProvider dataProvider)
 {
     this.storageProvider = storageProvider;
     this.dataProvider = dataProvider;
     this.settings = Settings.LoadSettings(storageProvider);
     this.tvShows = TvShow.GetTvShows(storageProvider).ToList();
 }

        public MainViewModel(IStorageProvider storageProvider)
        {
            _storageProvider = storageProvider;

            _storageProvider.DeleteGameState();
            UpdateGameButtonVisibility(this,null);
        }

        public ImageDisOptions(
            IStorageProvider storageProvider,
            IImageTransformProvider imageTransformProvider, 
            string path = null,
            ImageType[] allowedImageTypes = null,
            IKeyGenerator keyGenerator = null)
        {
            if (storageProvider == null)
                throw new ArgumentNullException("storageProvider");

            StorageProvider = storageProvider;

            if (imageTransformProvider == null)
                throw new ArgumentNullException("imageTransformProvider");

            ImageTransformProvider = imageTransformProvider;

            Path = string.IsNullOrWhiteSpace(path) ? "/imagedis" : path;

            AllowedImageTypes = allowedImageTypes == null || !allowedImageTypes.Any() 
                ? new[] { ImageTypes.Jpeg, ImageTypes.Png } 
                : allowedImageTypes;

            KeyGenerator = keyGenerator ?? new RandomKeyGenerator();
        }

        public KeeAnywhereWebRequest(IStorageProvider provider, string itemPath)
        {
            if (provider == null) throw new ArgumentNullException("provider");
            if (itemPath == null) throw new ArgumentNullException("itemPath");

            _provider = provider;
            _itemPath = itemPath;
        }

 internal static void OnStorageActivate(IStorageProvider storage, string grainType, GrainReference grain, TimeSpan latency)
 {
     StorageActivateTotal.Increment();
     if (latency > TimeSpan.Zero)
     {
         StorageReadLatency.AddSample(latency);
     }
 }

        public void Setup()
        {
            scriptProviderMock = new Mock<IScriptProvider>();
            scriptProvider = scriptProviderMock.Object;

            storageProviderMock = new Mock<IStorageProvider>();
            storageProvider = storageProviderMock.Object;
        }

 public Label(IDateProvider dateProvider,
              IIdentityProvider identitiyProvider,
              IStorageProvider storageProvider)
 {
     DateProvider     = dateProvider;
     IdentityProvider = identitiyProvider;
     StorageProvider  = storageProvider;
 }

        public LocalBlobClient(IStorageProvider storageProvider, IPathCreator pathCreator)
        {
            if (storageProvider == null) throw new ArgumentNullException("storageProvider");
            if (pathCreator == null) throw new ArgumentNullException("pathCreator");

            _storageProvider = storageProvider;
            _pathCreator = pathCreator;
        }

        public PrettyGalleryService(IMediaService mediaService, IStorageProvider storageProvider, IOrchardServices orchardServices)
        {
            _mediaService = mediaService;
            _storageProvider = storageProvider;
            _orchardServices = orchardServices;

            T = NullLocalizer.Instance;
        }

        private void Init(string connectionString, CloudProvider provider)
        {
            var catalog = new DirectoryCatalog(".");
            var container = new CompositionContainer(catalog);
            container.ComposeExportedValue<string>(connectionString);
            _provider = container.GetExportedValue<IStorageProvider>(provider.ToString());

        }

 /// <summary>
 /// Updates the collection of TVShows.
 /// </summary>
 /// <param name="shows">
 /// The collection of shows to update.
 /// </param>
 /// <param name="storageProvider">
 /// The storage provider to use
 /// </param>
 /// <param name="dataProvider">
 /// The data provider to use.
 /// </param>
 internal static void Update(
     this IList<TvShow> shows, IStorageProvider storageProvider, IDataProvider dataProvider)
 {
     foreach (var show in dataProvider.UpdateShows(shows, storageProvider))
     {
         show.LockIfNoEpisodes(storageProvider);
         show.Save(storageProvider);
     }
 }

 public LockFileCleaner(
     IScheduledTaskManager scheduledTaskManager,
     IClock clock,
     IStorageProvider storageProvider)
 {
     _scheduledTaskManager = scheduledTaskManager;
     _clock = clock;
     _storageProvider = storageProvider;
 }