CODEWITHSUNDEEP
cachingenterprise-library
sraj
sraj

Reputation: 693

Is there a way to create multiple instances of CacheManager in Microsoft Enterprise Library, programatically without depending on configuration file

We are trying to migrate to use Microsoft Enterprise Library - Caching block. However, cache manager initialization seems to be pretty tied to the config file entries and our application creates inmemory "containers" on the fly. Is there anyway by which an instance of cache manager can be instantiated on the fly using pre-configured set of values (inmemory only).

Upvotes: 4

Views: 1470

Answers (2)

Reverove Likia
Reverove Likia

Reputation: 81

You can using UnityContainer:

        IUnityContainer unityContainer = new UnityContainer();
        IContainerConfigurator configurator = new UnityContainerConfigurator(unityContainer);

        configurator.ConfigureCache("MyCache1");

        IContainerConfigurator configurator2 = new UnityContainerConfigurator(unityContainer);
        configurator2.ConfigureCache("MyCache2");

        // here you can access both MyCache1 and MyCache2:
        var cache1 = unityContainer.Resolve<ICacheManager>("MyCache1");
        var cache2 = unityContainer.Resolve<ICacheManager>("MyCache2");

And this is an extension class for IContainerConfigurator:

public static void ConfigureCache(this IContainerConfigurator configurator, string configKey)
    {
        ConfigurationSourceBuilder builder = new ConfigurationSourceBuilder();
        DictionaryConfigurationSource configSource = new DictionaryConfigurationSource();
        // simple inmemory cache configuration
        builder.ConfigureCaching().ForCacheManagerNamed(configKey).WithOptions.StoreInMemory();
        builder.UpdateConfigurationWithReplace(configSource);
        EnterpriseLibraryContainer.ConfigureContainer(configurator, configSource);
    }

Using this you should manage an static IUnityContainer object and can add new cache, as well as reconfigure existing caching setting anywhere you want.

Upvotes: 3

Randy Levy
Randy Levy

Reputation: 22655

Enterprise Library 5 has a fluent configuration which makes it easy to programmatically configure the blocks. For example:

var builder = new ConfigurationSourceBuilder();

builder.ConfigureCaching()
       .ForCacheManagerNamed("MyCache")
       .WithOptions
         .UseAsDefaultCache()
         .StoreInIsolatedStorage("MyStore")
         .EncryptUsing.SymmetricEncryptionProviderNamed("MySymmetric");

var configSource = new DictionaryConfigurationSource();
builder.UpdateConfigurationWithReplace(configSource);
EnterpriseLibraryContainer.Current 
  = EnterpriseLibraryContainer.CreateDefaultContainer(configSource);

Unfortunately, it looks like you need to configure the entire block at once so you wouldn't be able to add CacheManagers on the fly. (When I call ConfigureCaching() twice on the same builder an exception is thrown.) You can create a new ConfigurationSource but then you lose your previous configuration. Perhaps there is a way to retrieve the existing configuration, modify it (e.g. add a new CacheManager) and then replace it? I haven't been able to find a way.

Another approach is to use the Caching classes directly.

The following example uses the Caching classes to instantiate two CacheManager instances and stores them in a static Dictionary. No configuration required since it's not using the container. I'm not sure it's a great idea -- it feels a bit wrong to me. It's pretty rudimentary but hopefully helps. 

public static Dictionary<string, CacheManager> caches = new Dictionary<string, CacheManager>();

static void Main(string[] args)
{
    IBackingStore backingStore = new NullBackingStore();
    ICachingInstrumentationProvider instrProv = new CachingInstrumentationProvider("myInstance", false, false,
        new NoPrefixNameFormatter());

    Cache cache = new Cache(backingStore, instrProv);
    BackgroundScheduler bgScheduler = new BackgroundScheduler(new ExpirationTask(null, instrProv), new ScavengerTask(0,
        int.MaxValue, new NullCacheOperation(), instrProv), instrProv);

    CacheManager cacheManager = new CacheManager(cache, bgScheduler, new ExpirationPollTimer(int.MaxValue));
    cacheManager.Add("test1", "value1");
    caches.Add("cache1", cacheManager);

    cacheManager = new CacheManager(new Cache(backingStore, instrProv), bgScheduler, new ExpirationPollTimer(int.MaxValue));
    cacheManager.Add("test2", "value2");            
    caches.Add("cache2", cacheManager);

    Console.WriteLine(caches["cache1"].GetData("test1"));
    Console.WriteLine(caches["cache2"].GetData("test2"));
}

public class NullCacheOperation : ICacheOperations
{
    public int Count { get { return 0; } }
    public Hashtable CurrentCacheState { get { return new System.Collections.Hashtable(); } }
    public void RemoveItemFromCache(string key, CacheItemRemovedReason removalReason) {}
}

If expiration and scavenging policies are the same perhaps it might be better to create one CacheManager and then use some intelligent key names to represent the different "containers". E.g. the key name could be in the format "{container name}:{item key}" (assuming that a colon will not appear in a container or key name).

Upvotes: 4

Related Questions