private HttpResourceProvider(ICacheProvider cacheProvider, string applicationName, string resourceSet, Uri lemonadeServiceUri)
 {
     _cacheProvider = cacheProvider;
     _applicationName = applicationName;
     _resourceSet = resourceSet;
     _restClient = new RestClient(lemonadeServiceUri);
 }

 public IdentityService(IWeddingBiddersUow uow, IEncryptionService encryptionService, ISessionService sessionService, ICacheProvider cacheProvider)
     : base(cacheProvider)
 {
     this.uow = uow;
     this.sessionService = sessionService;
     this.encryptionService = encryptionService;
 }

 public IdentityService(IVideoOnDemandUow uow, IEncryptionService encryptionService, ISessionService sessionService, ICacheProvider cacheProvider)
     : base(cacheProvider)
 {
     this.uow = uow;
     this.sessionService = sessionService;
     this.encryptionService = encryptionService;
 }

 public BlogController(ILogger<BlogController> logger, IPostManager postManager, IPortfolioManager portfolioManager, ICacheProvider cacheProvider)
 {
     this.logger = logger;
     this.cacheProvider = cacheProvider;
     this.postManager = postManager;
     this.portfolioManager = portfolioManager;
 }

        public ResourceXmlConfigurationProvider(ICacheProvider cacheProvider, string configurationPath, IVirtualPathResolver virtualPathResolver, IResourceCacher resourceCacher)
        {
            if (cacheProvider == null)
            {
                throw new ArgumentNullException("cacheProvider");
            }

            if (resourceCacher == null)
            {
                throw new ArgumentNullException("resourceCacher");
            }

            if (string.IsNullOrEmpty(configurationPath) && virtualPathResolver == null)
            {
                throw new ArgumentNullException("configurationPath");                    
            }

            m_CacheProvider = cacheProvider;
            m_VirtualPathResolver = virtualPathResolver;
            m_ResourceCacher = resourceCacher;

            m_XmlConfigurationPathProvider = new Lazy<string>(
                () =>
                    {
                        if (string.IsNullOrWhiteSpace(configurationPath))
                        {
                            configurationPath = m_VirtualPathResolver.Resolve("~/App_Data/WebResources.xml");
                        }

                        m_ResourceCacher.AddDependentFile(configurationPath);

                        return configurationPath;
                    },
                true);
        }

 public IdentityService(ILearnWithQBUow uow, IEncryptionService encryptionService, ISessionService sessionService, ICacheProvider cacheProvider)
     : base(cacheProvider)
 {
     this.uow = uow;
     this.sessionService = sessionService;
     this.encryptionService = encryptionService;
 }

 public AlbumCacheTask(ILastfmClientFactory lastfmFactory, IS3ClientFactory s3Factory, ICacheProvider cacheProvider, ILogger<AlbumCacheTask> logger)
 {
     this.s3Client = s3Factory.CreateS3Client();
     this.lastfmClient = lastfmFactory.CreateLastfmClient();
     this.cacheProvider = cacheProvider;
     this.logger = logger;
 }

 public AppContext(ILogger logger, ICacheProvider cache)
 {
     //Environment = new EnvironmentPH();
     Logger = logger;
     Cache = cache;
     Settings = new AppSettings();
 }

      public static void GenerateAllCourses(ICourseStorage courseStorage, ICacheProvider cacheProvider)
      {

         var path = (new System.Uri(Assembly.GetExecutingAssembly().CodeBase)).AbsolutePath;
         path = path.Replace("IUDICO.LMS/Plugins/IUDICO.DataGenerator.DLL", "IUDICO.DataGenerator/Content/Courses/");

         if (Directory.Exists(path))
         {
            var files = Directory.GetFiles(path, "*.zip",SearchOption.TopDirectoryOnly);

            foreach (var file in files)
            {
               var name = Path.GetFileNameWithoutExtension(file);

               if (!courseStorage.GetCourses().Any(c => c.Name == name && c.Owner == "prof3"))
               {
                  courseStorage.Import(file, "prof3");
                  Course course = courseStorage.GetCourses().SingleOrDefault(c => c.Name == name && c.Owner == "prof3");
                  if (course != null && course.Locked.Value)
                  {
                     courseStorage.Parse(course.Id);
                     cacheProvider.Invalidate("course-" + course.Id, "courses");
                  }
               }
            }
         }
      }

 public RespiratoryController([Named("FileDependency")]ICacheProvider cache, IReadEquationData<Equation> readEquationData,IMathExpressionParser mathExpressionParser,IMyLogger logger)
 {
     this.myLogger = logger;
     this.Cache = cache;
     this.ReadEquationData = readEquationData;
     this.MathExpressionParser = mathExpressionParser;
 }

 public CachedUserService(IUserService userService, ICacheProvider cacheProvider, IUserStorePathProvider userStorePathProvider)
 {
     _userService = userService;
     _cacheProvider = cacheProvider;
     _optoutCacheFileName = userStorePathProvider.GetOptoutFileName();
     _optinCacheFileName = userStorePathProvider.GetOptinFileName();
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="CacheInterceptor" /> class.
 /// </summary>
 /// <param name="cacheProvider">The cache provider.</param>
 /// <param name="cachingIsEnabled">if set to <c>true</c> caching is enabled.</param>
 /// <param name="cacheTimeoutSeconds">The cache timeout seconds.</param>
 public CacheInterceptor(ICacheProvider cacheProvider, bool cachingIsEnabled, int cacheTimeoutSeconds, bool logCacheHits)
 {
     this.cacheProvider = cacheProvider;
     this.cachingIsEnabled = cachingIsEnabled;
     this.cacheTimeout = TimeSpan.FromSeconds(cacheTimeoutSeconds);
     this.logCacheHits = logCacheHits;
 }

        protected internal CacheAspect(ICacheProvider cacheProvider)
        {
            if (cacheProvider == null)
                throw new ArgumentNullException("cacheProvider");

            this.Cache = cacheProvider;
        }

		/// <summary>
		/// Default constructor.
		/// </summary>
		/// <param name="container">The current cache provider</param>
		public AppCache(ICacheProvider provider) {
			Authors = new ModelCache<Models.Author>(provider, a => a.Id.Value, a => a.Email);
			Categories = new ModelCache<Models.Category>(provider, c => c.Id.Value, c => c.Slug);
			Params = new ModelCache<Models.Param>(provider, p => p.Id.Value, p => p.InternalId);
			Posts = new ModelCache<Models.Post>(provider, p => p.Id.Value, p => p.Slug);
			Tags = new ModelCache<Models.Tag>(provider, t => t.Id.Value, t => t.Slug);
		}

        public AspNetDatingChatRoomProvider(IChatUserProvider chatUserProvider, ICacheProvider cacheProvider)
        {
            this.chatUserProvider = chatUserProvider;
            this.cacheProvider = cacheProvider;

            mainChatRoom = new Room
            {
                Id = "-1",
                MaxUsers = MaxUsers,
                Name = "Main Chat",
                Password = null,
                Topic = "Welcome to chat!",
                Visible = true
            };

            messengerChatRoom = new Room
            {
                Id = "-2",
                MaxUsers = Int32.MaxValue,
                Name = "Messenger",
                Password = null,
                Topic = "Welcome to chat!",
                Visible = false
            };
        }

 public CouchPotatoController(ISettingsService<CouchPotatoSettingsDto> settingsService, IThirdPartyService api, ILogger logger, ICacheProvider cache)
 {
     SettingsService = settingsService;
     Api = api;
     Logger = logger;
     Settings = SettingsService.GetSettings();
     Cache = cache;
 }

      protected FakeCacheProvider()
      {
         this.mockCacheProvider = new Mock<ICacheProvider>();

         this.Setup();

         this.CacheProvider = this.mockCacheProvider.Object;
      }

 public PageService(IDocumentSession session, IFolderService folderService, ITemplateService templateService,
                    ICacheProvider cacheProvider)
     : base(session)
 {
     this.folderService = folderService;
     this.templateService = templateService;
     this.cacheProvider = cacheProvider;
 }

 public InventoryTransactionRepository(CokeDataContext ctx, IInventoryRepository inventoryRepository, ICacheProvider cacheProvider)
 {
    
     _ctx = ctx;
     _inventoryRepository = inventoryRepository;
     _cacheProvider = cacheProvider;
     
 }

 public Gist(
     ILogProvider logProvider,
     ICacheProvider cacheProvider,
     IAuthProvider authProvider)
     : base(
         logProvider,
         cacheProvider,
         authProvider) { }