public static void PreStartInitialise()
        {
            switch (WebConfigSettings.CacheProviderType)
            {

            #if !NET35
                case CacheTypes.AppFabricCache:

                    _cache = new AppFabricCacheAdapter();

                    break;

            #endif
                case CacheTypes.MemoryCache:
                default:
                    _cache = new MemoryCacheAdapter();

                    // http://msdn.microsoft.com/en-us/library/wcxyzt4d.aspx
                    //_cache = Activator.CreateInstance(Type.GetType(WebConfigSettings.CacheProviderType, _logger)) as ICache;

                    break;

            }

            _cacheProvider = new CacheProvider(_cache);
        }

        public OpenDatabaseViewModel(
            INavigationService navigationService,
            IDatabaseInfoRepository databaseInfoRepository,
            ICanSHA256Hash hasher,
            IDialogService dialogService,
            IPWDatabaseDataSource databaseSource,
            ICache cache)
        {
            _cache = cache;
            _databaseSource = databaseSource;
            _dialogService = dialogService;
            _databaseInfoRepository = databaseInfoRepository;
            _hasher = hasher;
            _navigationService = navigationService;
            var canHitOpen = this.WhenAny(
                vm => vm.Password, 
                vm => vm.KeyFileName,
                (p, k) => !string.IsNullOrEmpty(p.Value) || !string.IsNullOrEmpty(k.Value));

            OpenCommand = new ReactiveCommand(canHitOpen);
            OpenCommand.Subscribe(OpenDatabase);

            GetKeyFileCommand = new ReactiveCommand();
            GetKeyFileCommand.Subscribe(GetKeyFile); 
            
            ClearKeyFileCommand = new ReactiveCommand();
            ClearKeyFileCommand.Subscribe(ClearKeyFile);

            IObservable<string> keyFileNameChanged = this.WhenAny(vm => vm.KeyFileName, kf => kf.Value);
            keyFileNameChanged.Subscribe(v => ClearKeyFileButtonIsVisible = !string.IsNullOrWhiteSpace(v));
            keyFileNameChanged.Subscribe(v => GetKeyFileButtonIsVisible = string.IsNullOrWhiteSpace(v));
        }

 public BenchmarkRunner(ICache cache, IBenchmark benchmark)
 {
     _cache = cache;
     _benchmark = benchmark;
     _singleMeasurer = new SingleThreadedBenchmarkMeasurer(cache, benchmark);
     _multiMeasurer = new MultiThreadedBenchmarkMeasurer(cache, benchmark);
 }

 public AuthorizationContextCache(ICache cache, IControllerContextCache controllerContextCache, IControllerDescriptorCache controllerDescriptorCache, IRouteDataCache routeDataCache)
 {
     this.cache = cache;
     this.routeDataCache = routeDataCache;
     this.controllerContextCache = controllerContextCache;
     this.controllerDescriptorCache = controllerDescriptorCache;
 }

 public CobreGratisForTests(
     string clientAppIdentification, string authToken, ILogger logger, ICache cache,
     INetworkServices networkServices, IXmlSerializer xmlSerializer
     )
     : base(clientAppIdentification, authToken, logger, cache, networkServices, xmlSerializer)
 {
 }

 public RequestQueue(ICache cache, INetwork network, int threadPoolSize, IResponseDelivery delivery)
 {
     this.mCache = cache;
     this.mNetwork = network;
     this.mDispatchers = new NetworkDispatcher[threadPoolSize];
     this.mDelivery = delivery;
 }

        private static void RunCacheTests(ICache cache)
        {
            cache.Insert("ByteArray", new byte[] {0, 1, 2, 3}, CachePriority.Normal);
            cache.Insert("String", "Hello World", CachePriority.Normal);
            cache.Insert("Object", new TestObject("Test Object", 1234), CachePriority.Normal);

            var byteArray = cache.Lookup("ByteArray");
            Assert.IsNotNull(byteArray);
            Assert.AreEqual(4, byteArray.Length);
            for (int i = 0; i < 4; i++) Assert.AreEqual(i, byteArray[i]);

            var cachedString = cache.Lookup<string>("String");
            Assert.IsNotNull(cachedString);
            Assert.AreEqual("Hello World", cachedString);

            var cachedObject = cache.Lookup<TestObject>("Object");
            Assert.IsNotNull(cachedObject);
            Assert.AreEqual("Test Object", cachedObject.StringValue);
            Assert.AreEqual(1234, cachedObject.LongValue);

            cache.Remove("Object");
            Assert.IsNull(cache.Lookup("Object"));
            Assert.IsFalse(cache.ContainsKey("Object"));
            Assert.IsTrue(cache.ContainsKey("String"));
        }

        protected Element(MSpecUnitTestProvider provider,
                          IPsi psiModuleManager,
                          ICache cacheManager,
                          Element parent,
                          ProjectModelElementEnvoy projectEnvoy,
                          IClrTypeName declaringTypeName,
                          bool isIgnored)
        {
            if (declaringTypeName == null)
            {
                throw new ArgumentNullException("declaringTypeName");
            }

            if (projectEnvoy != null)
            {
                this._projectEnvoy = projectEnvoy;
            }

            this._provider = provider;
            this._declaringTypeName = declaringTypeName;
            this._psiModuleManager = psiModuleManager;
            this._cacheManager = cacheManager;

            if (isIgnored)
            {
                this.ExplicitReason = "Ignored";
            }

            this.TypeName = declaringTypeName;
            this.Parent = parent;

            this.Children = new List<IUnitTestElement>();
            this.State = UnitTestElementState.Valid;
            this._taskFactory = new UnitTestTaskFactory(this._provider.ID);
        }

 public SubActivityDao(ISession session, 
     ISettingsProvider<SubSettings> subSettings,
     ICache cache)
     : base(session, subSettings)
 {
     _cache = cache;
 }

        public void SetUp()
        {
            _project = new Project(Path.GetFullPath("someProject.csproj"), new ProjectDocument(ProjectType.CSharp));
			_project.Value.SetOutputPath("");
			_project.Value.SetAssemblyName("someAssembly.dll");
            _bus = MockRepository.GenerateMock<IMessageBus>();
            _listGenerator = MockRepository.GenerateMock<IGenerateBuildList>();
            _configuration = MockRepository.GenerateMock<IConfiguration>();
            _buildRunner = MockRepository.GenerateMock<IBuildRunner>();
            _testRunner = MockRepository.GenerateMock<ITestRunner>();
			_testAssemblyValidator = MockRepository.GenerateMock<IDetermineIfAssemblyShouldBeTested>();
			_optimizer = MockRepository.GenerateMock<IOptimizeBuildConfiguration>();
            _fs = MockRepository.GenerateMock<IFileSystemService>();
            _cache = MockRepository.GenerateMock<ICache>();
            _runCache = MockRepository.GenerateMock<IRunResultCache>();
			_runInfo = new RunInfo(_project);
			_runInfo.ShouldBuild();
			_runInfo.SetAssembly(_project.Value.AssemblyName);
			_optimizer.Stub(o => o.AssembleBuildConfiguration(new string[] {})).IgnoreArguments().Return(new RunInfo[] { _runInfo });
            _preProcessor = MockRepository.GenerateMock<IPreProcessTestruns>();
            _preProcessor.Stub(x => x.PreProcess(null)).IgnoreArguments().Return(new PreProcessedTesRuns(null, new RunInfo[] { _runInfo }));
            var preProcessors = new IPreProcessTestruns[] { _preProcessor };
            var buildPreProcessor = MockRepository.GenerateMock<IPreProcessBuildruns>();
            buildPreProcessor.Stub(x => x.PreProcess(null)).IgnoreArguments().Return(new RunInfo[] { _runInfo });
            var buildPreProcessors = new IPreProcessBuildruns[] { buildPreProcessor };
            _removedTestLocator = MockRepository.GenerateMock<ILocateRemovedTests>();
            _buildSessionRunner = new BuildSessionRunner(new BuildConfiguration(null), _cache, _bus, _configuration, _buildRunner, buildPreProcessors, _fs, _runCache);
            _consumer = new ProjectChangeConsumer(_bus, _listGenerator, _configuration, _buildSessionRunner, new ITestRunner[] { _testRunner }, _testAssemblyValidator, _optimizer, preProcessors, _removedTestLocator);
        }

        ICache ICachingFactory.Create()
        {
            if (_caches == null)
            {
                lock (_syncObj)
                {
                    if (_caches == null)
                    {
                        var assemblyName = CachingConfig.GetCacheProvider();
                        if (String.IsNullOrWhiteSpace(assemblyName))
                        {
                            _caches = new NoCacheProvider();
                        }
                        else
                        {
                            var assemblys = assemblyName.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
                            var handler = Activator.CreateInstance(assemblys[0], assemblys[1]);
                            var obj = handler.Unwrap();
                            _caches = obj as ICache;
                        }

                    }
                }
            }

            return _caches;
        }

		async Task<IAccessToken> IAccessTokenProvider.ProvisionAccessTokenAsync(
			IEnumerable<Claim> claims,
			IEnumerable<Scope> scopes,
			ICache cache
			) {

			if( cache == null ) {
				cache = new NullCache();
			}

			claims = claims.ToList();
			scopes = scopes.ToList();

			string cacheKey = TokenCacheKeyBuilder.BuildKey( claims, scopes );

			CacheResponse cacheResponse = await cache.GetAsync( cacheKey ).SafeAsync();

			if( cacheResponse.Success ) {
				SecurityToken securityToken = m_tokenHandler.ReadToken( cacheResponse.Value );
				if( securityToken.ValidTo > DateTime.UtcNow.Add( m_tokenRefreshGracePeriod ) ) {
					return new AccessToken( cacheResponse.Value );
				}
			}

			IAccessToken token =
				await m_accessTokenProvider.ProvisionAccessTokenAsync( claims, scopes ).SafeAsync();

			DateTime validTo = m_tokenHandler.ReadToken( token.Token ).ValidTo;

			await cache.SetAsync( cacheKey, token.Token, validTo - DateTime.UtcNow ).SafeAsync();
			return token;
		}

 public SplashViewModel(INavigationService navigationService, ITrelloApiSettings settings, ITrello api, ICache cache)
 {
     _navigationService = navigationService;
     _settings = settings;
     _cache = cache;
     _api = api;
 }

 public void testSetup()
 {
     _services = MockRepository.GenerateMock<IServiceLocator>();
     _cache = MockRepository.GenerateMock<ICache>();
     _bus = MockRepository.GenerateMock<IMessageBus>();
     _subject = new FileChangeConsumer(_services, _bus, _cache);
 }

        public ISession CreateSession(IDictionary<string, string> parameters, IObjectFactory objectFactory, AbstractAuthenticationProvider authenticationProvider, ICache cache)
        {
            Session session = new Session(parameters, objectFactory, authenticationProvider, cache);
            session.Connect();

            return session;
        }

 public NetworkDispatcher(ConcurrentQueue<Request> queue, INetwork network, ICache cache, IResponseDelivery delivery)
 {
     this.mQueue = queue;
     this.mNetwork = network;
     this.mCache = cache;
     this.mDelivery = delivery;
 }

        public static void EnsureIsStarted(Key key,
                                           ICacheItemRecalculationStrategy recalculationStrategy,
                                           MethodInterceptionArgs args,
                                           ICache cache)
        {
            var keyString = key.ToString();
            Ensure.That<NHelpfulException.FrameworkExceptions.ArgumentException>(keyString.Length.IsLessThanOrEqualTo(260),
                                                              "key must be less than 260 characters long.");

            try
            {
                bool createdNew;
                var mutex = new Mutex(false, MutexPrefix + keyString, out createdNew);
                if (createdNew)
                {
                    if (cache[keyString].IsNotNull())
                        return;
                    //item already in cache, assume thread already started TODO: possibly log this as an error

                    ThreadPool.QueueUserWorkItem(
                        o => recalculationStrategy.RunRoutine(key, args, cache, mutex, args.Proceed));

                    //NOTE: mutex.ReleaseMutex(); is not called because the mutex is only expected to be released upon closure of the application
                }
            }
            catch (Exception)
            {
                //log exception
                throw;
            }
        }

        /// <summary>
        /// Prints the cache entries.
        /// </summary>
        /// <param name="cache">The cache.</param>
        private static void PrintCacheEntries(ICache<int, int> cache)
        {
            Console.WriteLine("\n>>> Entries in cache:");

            foreach (var entry in cache)
                Console.WriteLine(entry);
        }

 public SeoRouteValueDictionary(string siteMapNodeKey, string memberName, ISiteMap siteMap,
     IReservedAttributeNameProvider reservedAttributeNameProvider,
     IJsonToDictionaryDeserializer jsonToDictionaryDeserializer, ICache cache)
     : base(
         siteMapNodeKey, memberName, siteMap, reservedAttributeNameProvider, jsonToDictionaryDeserializer, cache)
 {
 }

 public Chat(IResourceProcessor resourceProcessor, IChatService service, IJabbrRepository repository, ICache cache)
 {
     _resourceProcessor = resourceProcessor;
     _service = service;
     _repository = repository;
     _cache = cache;
 }