CreateFromConfigurations Method

Summary

Creates a new cache object from the specified configuration stream and optional additional values.

Syntax

C++/CLI

Python

public static ObjectCache CreateFromConfigurations( 
   Stream stream, 
   IDictionary<string, string> additionalValues 
)

public:  
   static ObjectCache^ CreateFromConfigurations( 
      Stream^ stream, 
      IDictionary<String^, String^>^ additionalValues 
   )

def CreateFromConfigurations(self,stream,IDictionary<string,additionalValues):

Parameters

stream

Stream containing the configuration. This is usually a stream to an XML file or data containing configuration previously saved with SaveConfiguration. This value must not be null.

additionalValues

Dictionary of key/item values containing optional values to use. additionalValues override any values with the same key found in stream.

Return Value

The ObjectCache derived class created by this method if successful. Otherwise, null.

Remarks

ObjectCache and its derived classes (such as FileCache), support loading and saving XML configuration that can be used to re-create the object. This is very useful to minimize the code required in an application to switch between different configurations such as development versus deployment.

The following discussion will refer to FileCache. Start by creating a new FileCache as usual and set it up with the required properties such as FileCache.CacheDirectory and FileCache.DataSerializationMode. Once done, use SaveConfiguration to create an XML file for the configuration. This file now contains all the values necessary to re-create the FileCache object and initialize it to the same values used at the time of SaveConfiguration.

Loading the configuration can be performed in two ways:

Create a new FileCache and use the LoadConfiguration instance method.
All configuration files contain the name of the class. Therefore, the static CreateFromConfigurations method can be used to re-create the FileCache directory without having to create a new instance. If the name in the configuration file does not match the name of the derived class, null is returned.

All the configuration loading methods contain an additional key/value dictionary that can be used to add or override any values if required.

This table describes the methods that can be used to save configurations:

Method	Description
SaveConfiguration	Instance method that saves the configurations of an ObjectCache derived class to an XML stored in a stream.
GetConfigurationString	Instance method that gets the configurations of an ObjectCache derived class as a string.

This table describes the methods that can be used to load configurations:

Method	Description
CreateFromConfigurations	Static method that creates an ObjectCache derived class from the configuration XML stored in a stream.
CreateFromConfigurationsString	Static method that creates an ObjectCache derived class from the configuration XML stored in a string.
LoadConfiguration	Instance method that updates an ObjectCache derived class from the configuration XML stored in a stream.
SetConfigurationString	Instance method that updates an ObjectCache derived class from the configuration XML stored in a string.

All the load methods will return either true or non-null on success. Otherwise, false or null will be returned. This happens if the configuration does not contain the name of the class used.

Naturally, the result configuration file is standard XML that can also be loaded and modified by any text editor.

Example

This example will create a new FileCache object and set it up. It will then save the configuration to an XML file and use it to re-create the object.

Java

using Leadtools.Caching; 
 
 
public void FileCacheConfigurationExample() 
{ 
   // XML file to save the cache configuration 
   string cacheConfigFile = Path.Combine(LEAD_VARS.ImagesDir, "filecache.xml"); 
 
   string cacheDir = Path.Combine(LEAD_VARS.ImagesDir, "cache"); 
   // This is optional and can be null if not needed 
   string cacheVirtualDir = "http://localhost/cache"; 
 
   // Create the LEADTOOLS FileCache object and set it up 
 
   var cache1 = new FileCache(); 
   cache1.CacheDirectory = cacheDir; 
   if (cacheVirtualDir != null) 
      cache1.CacheVirtualDirectory = new Uri(cacheVirtualDir); 
   cache1.PolicySerializationMode = CacheSerializationMode.Json; 
   cache1.DataSerializationMode = CacheSerializationMode.Json; 
   cache1.DefaultRegion = "defaultRegion"; 
   cache1.AccessTimeout = TimeSpan.FromSeconds(5); 
 
   Console.WriteLine("cache1 ready"); 
 
   // Set the policy, expires in 1 day 
 
   var defaultPolicy = new CacheItemPolicy(); 
   var absoluteExpiration = DateTime.Now; 
   absoluteExpiration = absoluteExpiration.AddDays(1); 
   defaultPolicy.AbsoluteExpiration = absoluteExpiration; 
   cache1.DefaultPolicy = defaultPolicy; 
 
   // Cache is ready, save its configuration to the file 
   using (var stream = File.Create(cacheConfigFile)) 
      cache1.SaveConfiguration(stream, true); 
 
   // Add an item 
   CacheItem<string> cacheItem = new CacheItem<string>("key1", "value1", "region1"); 
   Console.WriteLine("Adding {0}.{1} with value:{2} to cache1", cacheItem.RegionName, cacheItem.Key, cacheItem.Value); 
   cache1.Add(cacheItem, new CacheItemPolicy()); 
   // Check it 
   CacheItem<string> result = cache1.GetCacheItem<string>("key1", "region1"); 
   Assert.AreEqual(cacheItem.Value, result.Value); 
 
   // Now, call a separate function with just the configuration file to load and setup the cache and read the item back 
   InitFromConfigurationAndCheckCache(cacheConfigFile, cacheItem); 
} 
 
private static void InitFromConfigurationAndCheckCache(string cacheConfigFile, CacheItem<string> originalItem) 
{ 
   // Create the cache from the configuration file 
   // Note that we can use the base ObjectCache object here, we do not need to know the exact type 
   ObjectCache cache2 = null; 
 
   using (var stream = File.OpenRead(cacheConfigFile)) 
      cache2 = ObjectCache.CreateFromConfigurations(stream, null); 
 
   Console.WriteLine("cache2 loaded from {0}", cacheConfigFile); 
 
   // Read the item we previously saved and check its value 
   CacheItem<string> result = cache2.GetCacheItem<string>(originalItem.Key, originalItem.RegionName); 
   Console.WriteLine("Reading {0}.{1} with value:{2} to cache1", result.RegionName, result.Key, result.Value); 
   Assert.AreEqual(originalItem.Value, result.Value); 
} 
 
static class LEAD_VARS 
{ 
   public const string ImagesDir = @"C:\LEADTOOLS23\Resources\Images"; 
}

 
import static org.junit.Assert.assertTrue; 
 
import java.io.File; 
import java.io.IOException; 
import java.net.MalformedURLException; 
import java.net.URL; 
import java.util.Calendar; 
 
import org.junit.*; 
import org.junit.runner.JUnitCore; 
import org.junit.runner.Result; 
import org.junit.runner.notification.Failure; 
 
import leadtools.*; 
import leadtools.caching.*; 
 
 
public void fileCacheConfigurationExample() throws MalformedURLException { 
   final String LEAD_VARS_IMAGES_DIR = "C:\\LEADTOOLS23\\Resources\\Images"; 
 
   // XML file to save the cache configuration 
   String cacheConfigFile = combine(LEAD_VARS_IMAGES_DIR, "filecache.xml"); 
   String cacheDir = combine(LEAD_VARS_IMAGES_DIR, "cache"); 
 
   // This is optional and can be null if not needed 
   String cacheVirtualDir = "http://localhost/cache"; 
 
   // Create the LEADTOOLS FileCache object and set it up 
   FileCache cache1 = new FileCache(); 
   cache1.setCacheDirectory(cacheDir); 
   if (cacheVirtualDir != null) 
      cache1.setCacheVirtualDirectory(new URL(cacheVirtualDir)); 
   cache1.setPolicySerializationMode(CacheSerializationMode.JSON); 
   cache1.setDataSerializationMode(CacheSerializationMode.JSON); 
   cache1.setDefaultRegion("defaultRegion"); 
   cache1.setAccessTimeout(5000); 
 
   System.out.println("cache1 set up and ready"); 
 
   // Set the policy, expires in 1 day 
   CacheItemPolicy defaultPolicy = new CacheItemPolicy(); 
   Calendar calendar = Calendar.getInstance(); 
   calendar.add(Calendar.DATE, 1); 
 
   defaultPolicy.setAbsoluteExpiration(calendar.getTime()); 
   cache1.setDefaultPolicy(defaultPolicy); 
 
   // Cache is ready, save its configuration to the file 
   ILeadStream stream = LeadStreamFactory.create(cacheConfigFile); 
 
   cache1.saveConfiguration(stream, true); 
 
   // Add an item 
   CacheItem<String> cacheItem = new CacheItem<String>("key1", "value1", "region1"); 
   System.out.printf("Adding %s.%s with value: %s to cache1%n", cacheItem.getRegionName(), cacheItem.getKey(), 
         cacheItem.getValue()); 
   cache1.add(cacheItem, String.class, new CacheItemPolicy()); 
 
   // Now, call a separate function with just the configuration file to load and 
   // setup the cache and read the item back 
   initFromConfigurationAndCheckCache(cacheConfigFile, cacheItem); 
   stream.dispose(); 
} 
 
private void initFromConfigurationAndCheckCache(String cacheConfigFile, CacheItem<String> originalItem) { 
   // Create the cache from the configuration file 
   // Note that we can use the base ObjectCache object here, we do not need to know 
   // the exact type 
   ObjectCache cache2 = null; 
   ILeadStream stream = LeadStreamFactory.create(cacheConfigFile); 
   cache2 = ObjectCache.createFromConfigurations(stream, null); 
   stream.dispose(); 
 
   System.out.println("cache2 loaded from " + cacheConfigFile); 
 
   // Read the item we previously saved and check its value 
   CacheItem<String> result = cache2.getCacheItem(originalItem.getKey(), String.class, originalItem.getRegionName()); 
   System.out.printf("Reading %s.%s with value: %s to cache1%n", result.getRegionName(), result.getKey(), 
         result.getValue()); 
   assertTrue("Saved and loaded values are not the same", originalItem.getValue().equals(result.getValue())); 
}

Requirements

Target Platforms

Reference

ObjectCache Class

ObjectCache Members

Leadtools.Caching Namespace

Download our FREE evaluation

Help Version 23.0.2024.2.29

Leadtools.Caching Assembly

Introduction

Getting Started

Namespaces

Leadtools.Caching Namespace

Assemblies