public void CanDeserializeSerializedConfiguration()
        {
            CacheManagerSettings settings = new CacheManagerSettings();

            DataCacheStorageData data1 = new DataCacheStorageData(name1, database1, partition1);
            settings.BackingStores.Add(data1);

            // needed to save configuration
            settings.CacheManagers.Add(new CacheManagerData("foo", 0, 0, 0, "storage"));

            IDictionary<string, ConfigurationSection> sections = new Dictionary<string, ConfigurationSection>();
            sections[CacheManagerSettings.SectionName] = settings;
            IConfigurationSource configurationSource
                = ConfigurationTestHelper.SaveSectionsInFileAndReturnConfigurationSource(sections);

            CacheManagerSettings roSettigs = (CacheManagerSettings)configurationSource.GetSection(CacheManagerSettings.SectionName);

            Assert.IsNotNull(roSettigs);
            Assert.AreEqual(1, roSettigs.BackingStores.Count);

            Assert.IsNotNull(roSettigs.BackingStores.Get(name1));
            Assert.AreSame(typeof(DataCacheStorageData), roSettigs.BackingStores.Get(name1).GetType());
            Assert.AreEqual(name1, roSettigs.BackingStores.Get(name1).Name);
            Assert.AreEqual(database1, ((DataCacheStorageData)roSettigs.BackingStores.Get(name1)).DatabaseInstanceName);
            Assert.AreEqual(partition1, ((DataCacheStorageData)roSettigs.BackingStores.Get(name1)).PartitionName);
            //Assert.AreEqual(encryption1, ((DataCacheStorageData)roSettigs.BackingStores.Get(name1)).StorageEncryption);
        }
        public void CanDeserializeSerializedConfiguration()
        {
            CacheManagerSettings settings = new CacheManagerSettings();

            SymmetricStorageEncryptionProviderData data1 = new SymmetricStorageEncryptionProviderData(name1, symmetric1);
            settings.EncryptionProviders.Add(data1);

            // needed to save configuration
            settings.CacheManagers.Add(new CacheManagerData("foo", 0, 0, 0, "storage"));
            settings.BackingStores.Add(new CustomCacheStorageData("foo", typeof(MockCustomStorageBackingStore)));

            IDictionary<string, ConfigurationSection> sections = new Dictionary<string, ConfigurationSection>();
            sections[CacheManagerSettings.SectionName] = settings;
            IConfigurationSource configurationSource
                = ConfigurationTestHelper.SaveSectionsInFileAndReturnConfigurationSource(sections);

            CacheManagerSettings roSettigs = (CacheManagerSettings)configurationSource.GetSection(CacheManagerSettings.SectionName);

            Assert.IsNotNull(roSettigs);
            Assert.AreEqual(1, roSettigs.EncryptionProviders.Count);

            Assert.IsNotNull(roSettigs.EncryptionProviders.Get(name1));
            Assert.AreSame(typeof(SymmetricStorageEncryptionProviderData), roSettigs.EncryptionProviders.Get(name1).GetType());
            Assert.AreEqual(name1, roSettigs.EncryptionProviders.Get(name1).Name);
            Assert.AreEqual(symmetric1, ((SymmetricStorageEncryptionProviderData)roSettigs.EncryptionProviders.Get(name1)).SymmetricInstance);
        }
        protected override void Act()
        {
            DesignDictionaryConfigurationSource saveSource = new DesignDictionaryConfigurationSource();

            base.CachingViewModel.Save(saveSource);
            savedSettings = (CacheManagerSettings) saveSource.GetSection(CacheManagerSettings.SectionName);
        }
Пример #4
0
        private static CacheManagerSettings GenerateCachingSettings()
        {
            CacheManagerSettings settings = new CacheManagerSettings();

            settings.CacheManagers.Add(new CacheManagerData("test", 10, 10, 1, new CustomCacheStorageData()));
            return settings;
        }
        public void CanDeserializeSerializedConfiguration()
        {
            MockCacheManagerData data1 = new MockCacheManagerData(name1, foo1);
            MockCacheManagerData data2 = new MockCacheManagerData(name2, foo2);

            CacheManagerSettings settings = new CacheManagerSettings();
            settings.DefaultCacheManager = name1;

            settings.CacheManagers.Add(data1);
            settings.CacheManagers.Add(data2);

            IDictionary<string, ConfigurationSection> sections = new Dictionary<string, ConfigurationSection>();
            sections[CacheManagerSettings.SectionName] = settings;
            IConfigurationSource configurationSource
                = ConfigurationTestHelper.SaveSectionsInFileAndReturnConfigurationSource(sections);

            CacheManagerSettings roSettigs = (CacheManagerSettings)configurationSource.GetSection(CacheManagerSettings.SectionName);

            Assert.IsNotNull(roSettigs);
            Assert.AreEqual(2, roSettigs.CacheManagers.Count);
            Assert.AreEqual(name1, roSettigs.DefaultCacheManager);

            data1 = (MockCacheManagerData)roSettigs.CacheManagers.Get(name1);
            Assert.IsNotNull(data1);
            Assert.AreEqual(name1, data1.Name);
            Assert.AreEqual(foo1, data1.Foo);

            data2 = (MockCacheManagerData)roSettigs.CacheManagers.Get(name2);
            Assert.IsNotNull(data2);
            Assert.AreEqual(name2, data2.Name);
            Assert.AreEqual(foo2, data2.Foo);
        }
Пример #6
0
        private static CacheManagerSettings GenerateCachingSettings()
        {
            CacheManagerSettings settings = new CacheManagerSettings();

            settings.DefaultCacheManager = "ShortInMemoryPersistence";

            //<cacheManager name="InMemoryPersistence" expirationPollFrequencyInSeconds="60" maximumElementsInCacheBeforeScavenging="100"
            //    numberToRemoveWhenScavenging="10">
            //    <cacheStorage xsi:type="CustomCacheStorageData" name="inMemory" type="Microsoft.Practices.EnterpriseLibrary.Caching.BackingStoreImplementations.NullBackingStore, Microsoft.Practices.EnterpriseLibrary.Caching" />
            //</cacheManager>
            settings.CacheManagers.Add( new CacheManagerData("InMemoryPersistence", 60, 100, 10, new CustomCacheStorageData("inMemory", typeof(NullBackingStore).AssemblyQualifiedName)) );

            //<cacheManager name="SmallInMemoryPersistence" cacheStorageName="inMemory" expirationPollFrequencyInSeconds="1"
            //    maximumElementsInCacheBeforeScavenging="3" numberToRemoveWhenScavenging="2">
            //    <cacheStorage xsi:type="CustomCacheStorageData" name="inMemory" type="Microsoft.Practices.EnterpriseLibrary.Caching.BackingStoreImplementations.NullBackingStore, Microsoft.Practices.EnterpriseLibrary.Caching" />
            //</cacheManager>
            settings.CacheManagers.Add( new CacheManagerData("SmallInMemoryPersistence", 1, 3, 2, new CustomCacheStorageData("inMemory", typeof(NullBackingStore).AssemblyQualifiedName)));

            //<cacheManager name="ShortInMemoryPersistence" cacheStorageName="inMemory" expirationPollFrequencyInSeconds="1"
            //    maximumElementsInCacheBeforeScavenging="10" numberToRemoveWhenScavenging="2">
            //    <cacheStorage xsi:type="CustomCacheStorageData" name="inMemory" type="Microsoft.Practices.EnterpriseLibrary.Caching.BackingStoreImplementations.NullBackingStore, Microsoft.Practices.EnterpriseLibrary.Caching" />
            //</cacheManager>
            settings.CacheManagers.Add( new CacheManagerData("ShortInMemoryPersistence", 1, 10, 2, new CustomCacheStorageData("inMemory", typeof(NullBackingStore).AssemblyQualifiedName)));

            return settings;
        }
        public void CanDeserializeSerializedConfiguration()
        {
            CustomCacheStorageData customData
                = new CustomCacheStorageData("custom", typeof(MockCustomStorageBackingStore));
            customData.SetAttributeValue(MockCustomProviderBase.AttributeKey, "value1");
            CacheManagerSettings settings = new CacheManagerSettings();
            settings.BackingStores.Add(customData);
            settings.CacheManagers.Add(new CacheManagerData("ignore", 0, 0, 0, "custom"));

            IDictionary<string, ConfigurationSection> sections = new Dictionary<string, ConfigurationSection>(1);
            sections[CacheManagerSettings.SectionName] = settings;
            IConfigurationSource configurationSource
                = ConfigurationTestHelper.SaveSectionsInFileAndReturnConfigurationSource(sections);

            CacheManagerSettings roSettigs = (CacheManagerSettings)configurationSource.GetSection(CacheManagerSettings.SectionName);

            Assert.IsNotNull(roSettigs);
            Assert.AreEqual(1, roSettigs.BackingStores.Count);

            Assert.IsNotNull(roSettigs.BackingStores.Get("custom"));
            Assert.AreSame(typeof(CustomCacheStorageData), roSettigs.BackingStores.Get("custom").GetType());
            Assert.AreEqual("custom", ((CustomCacheStorageData)roSettigs.BackingStores.Get("custom")).Name);
            Assert.AreEqual(typeof(MockCustomStorageBackingStore), ((CustomCacheStorageData)roSettigs.BackingStores.Get("custom")).Type);
            Assert.AreEqual("value1", ((CustomCacheStorageData)roSettigs.BackingStores.Get("custom")).Attributes[MockCustomProviderBase.AttributeKey]);
        }
        public void Setup()
        {
            CacheManagerSettings settings = new CacheManagerSettings();
            settings.BackingStores.Add(new DataCacheStorageData("Data Cache Storage", "db instance", "partition"));

            registrations = settings.GetRegistrations(null);
        }
 public void SetUp()
 {
     settings = new CacheManagerSettings();
     dbSettings = new DatabaseSettings();
     configurationSource = new DictionaryConfigurationSource();
     configurationSource.Add(CacheManagerSettings.SectionName, settings);
     configurationSource.Add(DatabaseSettings.SectionName, dbSettings);
 }
        /// <summary>
        /// Main entry point to create a <see cref="CacheManagerSettings"/> section.
        /// </summary>
        /// <param name="configurationSourceBuilder">The builder interface to extend.</param>
        /// <returns>A fluent interface to further configure the caching configuration section.</returns>
        public static ICachingConfiguration ConfigureCaching(this IConfigurationSourceBuilder configurationSourceBuilder)
        {
            if (configurationSourceBuilder == null) throw new ArgumentNullException("configurationSourceBuilder");

            CacheManagerSettings cacheSettings = new CacheManagerSettings();
            configurationSourceBuilder.AddSection(CacheManagerSettings.SectionName, cacheSettings);

            return new CachingConfigurationBuilder(cacheSettings);
        }
		private static CacheManagerSettings GenerateCacheManagerSettings()
		{
			CacheManagerSettings settings = new CacheManagerSettings();
			settings.BackingStores.Add(new DataCacheStorageData("Data Cache Storage", "CachingDatabase", "Partition1"));
			settings.CacheManagers.Add(new CacheManagerData("InDatabasePersistence",
				1, 100, 100, "Data Cache Storage"));
			settings.CacheManagers.Add(new CacheManagerData("SecondInDatabasePersistence",
				1, 100, 100, "Data Cache Storage"));
			return settings;
		}
        protected override void Arrange()
        {
            base.Arrange();
            this.Container.RegisterInstance<IAssemblyDiscoveryService>(new Mock<IAssemblyDiscoveryService>().Object);

            var cachingSettings = new CacheManagerSettings();
            var cachingSettingsModel = SectionViewModel.CreateSection(Container, CacheManagerSettings.SectionName, cachingSettings);

            var cacheManagerCollection = (ElementCollectionViewModel)cachingSettingsModel.GetDescendentsOfType<NameTypeConfigurationElementCollection<CacheManagerDataBase, CustomCacheManagerData>>().First();
            var cacheManagerCollectionCommands = cacheManagerCollection.Commands.SelectMany(x => x.ChildCommands);
            addCacheManagerCommand = cacheManagerCollectionCommands.OfType<AddCacheManagerCommand>().First();
        }
        public void Setup()
        {
            CacheStorageData cacheStorageData = new CacheStorageData("Null Storage", typeof(NullBackingStore));
            CacheManagerData cacheManagerData = new CacheManagerData("Default Cache Manager", 10, 10, 10, cacheStorageData.Name);
            
            CacheManagerSettings settings = new CacheManagerSettings();
            settings.CacheManagers.Add(cacheManagerData);
            settings.BackingStores.Add(cacheStorageData);

            settings.DefaultCacheManager = cacheManagerData.Name;

            registrations = settings.GetRegistrations(null);
        }
 public System.Configuration.ConfigurationSection GetSection(string sectionName)
 {
     if (sectionName.Equals("cachingConfiguration", StringComparison.CurrentCulture))
     {
         CacheManagerSettings settings = new CacheManagerSettings();
         settings.DefaultCacheManager = "Default Cache Manager";
         CacheManagerData data = new CacheManagerData("Default Cache Manager", 60, 1000, 10, "inMemory");
         settings.CacheManagers.Add(data);
         CacheStorageData storageData = new CacheStorageData("inMemory", typeof(NullBackingStore));
         settings.BackingStores.Add(storageData);
         return settings;
     }
     return null;
 }
        public void SetUp()
        {
            cryptoSettings = new CryptographySettings();
            settings = new CacheManagerSettings();

            SymmetricStorageEncryptionProviderData encrytionProvider = new SymmetricStorageEncryptionProviderData(providerName, symmetricInstance);
            settings.EncryptionProviders.Add(encrytionProvider);

            cryptoSettings.SymmetricCryptoProviders.Add(new DpapiSymmetricCryptoProviderData(symmetricInstance, DataProtectionScope.CurrentUser));

            configurationSource = new DictionaryConfigurationSource();
            configurationSource.Add(CacheManagerSettings.SectionName, settings);
            configurationSource.Add(CryptographySettings.SectionName, cryptoSettings);

		}
Пример #16
0
        private static CacheManagerSettings GenerateCacheManagerSettings()
        {
            CacheManagerSettings settings = new CacheManagerSettings();
            settings.BackingStores.Add(new CacheStorageData("inMemoryWithEncryptor", typeof(NullBackingStore), "dpapiEncryptor"));
            settings.BackingStores.Add(new CacheStorageData("inMemoryWithNullEncryptor", typeof(NullBackingStore), "nullEncryptor"));

            settings.EncryptionProviders.Add(new SymmetricStorageEncryptionProviderData("dpapiEncryptor", "dpapi1"));
            settings.EncryptionProviders.Add(new MockStorageEncryptionProviderData("nullEncryptor"));

            settings.CacheManagers.Add(new CacheManagerData("InMemoryPersistenceWithNullEncryption",
                60, 100, 10, "inMemoryWithNullEncryptor"));
            settings.CacheManagers.Add(new CacheManagerData("InMemoryPersistenceWithSymmetricEncryption",
                60, 100, 10, "inMemoryWithEncryptor"));
            return settings;
        }
        public void CanBuildCustomBackingStoreFromGivenConfiguration()
        {
            CustomCacheStorageData customData
                = new CustomCacheStorageData("custom", typeof(MockCustomStorageBackingStore));
            customData.SetAttributeValue(MockCustomProviderBase.AttributeKey, "value1");
            CacheManagerSettings settings = new CacheManagerSettings();
            settings.BackingStores.Add(customData);
            settings.CacheManagers.Add(new CacheManagerData("ignore", 0, 0, 0, "custom"));
            DictionaryConfigurationSource configurationSource = new DictionaryConfigurationSource();
            configurationSource.Add(CacheManagerSettings.SectionName, settings);

            IBackingStore custom
                = EnterpriseLibraryContainer.CreateDefaultContainer(configurationSource).GetInstance<IBackingStore>("custom");

            Assert.IsNotNull(custom);
            Assert.AreSame(typeof(MockCustomStorageBackingStore), custom.GetType());
            Assert.AreEqual("value1", ((MockCustomStorageBackingStore)custom).customValue);
        }
        public void Setup()
        {
            configurationSource = new ConfigurationSourceUpdatable();
            cacheSettings = new CacheManagerSettings();

            configurationSource.Add(CacheManagerSettings.SectionName, cacheSettings);

            cacheStorageData = new CacheStorageData("Null Storage", typeof(NullBackingStore));
            cacheManagerData = new CacheManagerData("Default Cache Manager", 10, 10, 10, cacheStorageData.Name);
            
            CacheManagerSettings settings = new CacheManagerSettings();
            cacheSettings.CacheManagers.Add(cacheManagerData);
            cacheSettings.BackingStores.Add(cacheStorageData);
            cacheSettings.DefaultCacheManager = cacheManagerData.Name;

            UnityContainer container = new UnityContainer();
            configurator = new UnityContainerConfigurator(container);
            serviceLcoator = new UnityServiceLocator(container);
            EnterpriseLibraryContainer.ConfigureContainer(configurator, configurationSource);
        }
        public void CanBuildCustomCacheManagerFromSavedConfiguration()
        {
            CustomCacheManagerData customData
                = new CustomCacheManagerData("custom", typeof(CustomCacheManager));
            customData.SetAttributeValue(MockCustomProviderBase.AttributeKey, "value1");
            CacheManagerSettings settings = new CacheManagerSettings();
            settings.CacheManagers.Add(customData);

            IDictionary<string, ConfigurationSection> sections = new Dictionary<string, ConfigurationSection>(1);
            sections[CacheManagerSettings.SectionName] = settings;
            IConfigurationSource configurationSource
                = ConfigurationTestHelper.SaveSectionsInFileAndReturnConfigurationSource(sections);

            ICacheManager custom
                = EnterpriseLibraryContainer.CreateDefaultContainer(configurationSource).GetInstance<ICacheManager>("custom");

            Assert.IsNotNull(custom);
            Assert.AreSame(typeof(CustomCacheManager), custom.GetType());
            Assert.AreEqual("value1", ((CustomCacheManager)custom).customValue);
        }
		public void CanBuildCustomBackingStoreFromSavedConfiguration()
		{
			CustomCacheStorageData customData
				= new CustomCacheStorageData("custom", typeof(MockCustomStorageBackingStore));
			customData.SetAttributeValue(MockCustomProviderBase.AttributeKey, "value1");
			CacheManagerSettings settings = new CacheManagerSettings();
			settings.BackingStores.Add(customData);
			settings.CacheManagers.Add(new CacheManagerData("ignore", 0, 0, 0, "custom"));

			IDictionary<string, ConfigurationSection> sections = new Dictionary<string, ConfigurationSection>(1);
			sections[CacheManagerSettings.SectionName] = settings;
			IConfigurationSource configurationSource 
				= ConfigurationTestHelper.SaveSectionsInFileAndReturnConfigurationSource(sections);

			IBackingStore custom
				= EnterpriseLibraryFactory.BuildUp<IBackingStore>("custom", configurationSource);

			Assert.IsNotNull(custom);
			Assert.AreSame(typeof(MockCustomStorageBackingStore), custom.GetType());
			Assert.AreEqual("value1", ((MockCustomStorageBackingStore)custom).customValue);
		}
        protected override void Arrange()
        {
            base.Arrange();

            DictionaryConfigurationSource source = new DictionaryConfigurationSource();
            ConfigurationSourceBuilder sourceBuilder = new ConfigurationSourceBuilder();

            sourceBuilder.ConfigureCaching()
                .ForCacheManagerNamed("Cache Manager 1")
                .StoreInMemory()
                .ForCacheManagerNamed("Cache Manager 2")
                .StoreInSharedBackingStore("database store")
                .ForCacheManagerNamed("Cache Manager 3")
                .StoreCacheMangerItemsInDatabase("database store")
                .EncryptUsing.SymmetricEncryptionProviderNamed("crypto thingy")
                .UsingSharedSymmetricEncryptionInstanceNamed("symm instance");

            sourceBuilder.UpdateConfigurationWithReplace(source);
            CachingConfiguration = (CacheManagerSettings)source.GetSection(CacheManagerSettings.SectionName);
            
            var sourceModel = Container.Resolve<ConfigurationSourceModel>();
            CachingViewModel = sourceModel.AddSection(CacheManagerSettings.SectionName, CachingConfiguration);
        }
		private static CacheManagerSettings GenerateCacheManagerSettings()
		{
			CacheManagerSettings settings = new CacheManagerSettings();
			settings.DefaultCacheManager = "ShortInMemoryPersistence";

			settings.BackingStores.Add(new CacheStorageData("inMemory", typeof(NullBackingStore)));
			settings.BackingStores.Add(new IsolatedStorageCacheStorageData("inIsolatedStorage", "", "EntLib"));
			settings.BackingStores.Add(new CacheStorageData("inMemoryWithNullEncryptor", typeof(NullBackingStore), "nullEncryptor"));
			settings.BackingStores.Add(new IsolatedStorageCacheStorageData("inIsolatedStorageWithNullEncryptor", "nullEncryptor", "EntLib"));
			settings.BackingStores.Add(new IsolatedStorageCacheStorageData("inMemoryWithBadStorage", "EntLib", "badname"));

			settings.EncryptionProviders.Add(new MockStorageEncryptionProviderData("nullEncryptor"));

			settings.CacheManagers.Add(new CacheManagerData("InMemoryPersistence",
				60, 100, 10, "inMemory"));
			settings.CacheManagers.Add(new CacheManagerData("InIsoStorePersistence",
				1, 100, 2, "inIsolatedStorage"));
			settings.CacheManagers.Add(new CacheManagerData("SmallInMemoryPersistence",
				1, 3, 2, "inMemory"));
			settings.CacheManagers.Add(new CacheManagerData("ShortInMemoryPersistence",
				1, 10, 2, "inMemory"));
			settings.CacheManagers.Add(new CacheManagerData("CacheManagerWithBadCacheStorageInstance",
				60, 100, 10, ""));
			//settings.CacheManagers.Add(new CacheManagerData("CacheManagerWithBadStoreType",
			//    60, 100, 10, "storageWithBadType"));
			settings.CacheManagers.Add(new CacheManagerData("InMemoryPersistenceWithNullEncryption",
				60, 100, 10, "inMemoryWithNullEncryptor"));
			settings.CacheManagers.Add(new CacheManagerData("InIsoStorePersistenceWithNullEncryption",
				1, 100, 2, "inIsolatedStorageWithNullEncryptor"));
			settings.CacheManagers.Add(new CacheManagerData("InIsoStorePersistenceWithNullEncryption2",
				1, 100, 2, "inIsolatedStorageWithNullEncryptor"));
			settings.CacheManagers.Add(new CacheManagerData("test", 10, 10, 1, "foo"));
			settings.CacheManagers.Add(new CacheManagerData("BadStorageProvider", 10, 10, 1, "inMemoryWithBadStorage"));
			settings.CacheManagers.Add(new CacheManagerData("BadBackingStore", 10, 10, 1, "foo"));
			settings.CacheManagers.Add(new MockCacheManagerData("MockManager", "FooValue"));
			return settings;
		}
        public void Setup()
        {
            CustomCacheStorageData customStorageData = new CustomCacheStorageData("Custom Storage", typeof(MockCustomStorageBackingStore));
            CacheManagerData cacheManagerData = new CacheManagerData("Default Cache Manager", 10, 10, 10, customStorageData.Name);

            CacheManagerSettings settings = new CacheManagerSettings();
            settings.CacheManagers.Add(cacheManagerData);
            settings.BackingStores.Add(customStorageData);

            registrations = settings.GetRegistrations(null);
        }
        public void Setup()
        {
            CustomCacheManagerData customCacheManager = new CustomCacheManagerData();
            customCacheManager.Name = "Custom Cache Manager";
            customCacheManager.Type = typeof(FaultyType);

            settings = new CacheManagerSettings();
            settings.CacheManagers.Add(customCacheManager);
        }
        public void Setup()
        {
            CustomCacheStorageData customStoreData = new CustomCacheStorageData();
            customStoreData.Name = "Custom Store";
            customStoreData.Type = typeof(FaultyType);

            settings = new CacheManagerSettings();
            settings.BackingStores.Add(customStoreData);
        }
 public void Setup()
 {
     CacheManagerSettings settings = new CacheManagerSettings();
     registrations = settings.GetRegistrations(null);
 }
        public void Setup()
        {
            CacheStorageData storeData = new CacheStorageData("cache store",typeof(BackingStoreWithoutDefaultCtor));

            settings = new CacheManagerSettings();
            settings.BackingStores.Add(storeData);
        }
 public CachingConfigurationBuilder(CacheManagerSettings cachingSettings)
 {
     this.cachingSettings = cachingSettings;
 }
 public void Setup()
 {
     CacheManagerSettings settings = new CacheManagerSettings();
     settings.EncryptionProviders.Add(new SymmetricStorageEncryptionProviderData("symm storage encryption", "default"));
     registrations = settings.GetRegistrations(null);
 }
 public CacheManagerSectionViewModel(IUnityContainer builder, string sectionName, ConfigurationSection section)
     : base(builder, sectionName, section)
 {
     NullBackingStoreName = DefaultNullBackingStore;
     cacheManagerSettings = (CacheManagerSettings)section;
 }