Represents LEADTOOLS support for a file cache.
FileCache implements ObjectCache and is the LEADTOOLS implementation of a file cache. It is used by default by the LEADTOOLS Document classes when caching is required to store the document data.
Refer to Document Toolkit and Caching for more information on how the cache is used with the LEADTOOLS Document library and how to set up optional custom cache provider.
To use a FileCache, set the CacheDirectory property to a valid directory in your system or in a network share. then use the various methods and properties to add and retrieve cache items with optional expiration policies. The cache will store the items and their policies into disk using serialization and retrieve them using de-serialization.
Since the cache uses the global file system, it can be re-used after the application is terminated. FileCache does not store any state data and all the items are stored in disk. For instance, the LEADTOOLS Document Web Service creates an instance of FileCache with every method call. All instances point to the same CacheDirectory and can therefore use the same items added in previous calls. The cache is thread and process safe.
FileCache provide support for regions which is used to group cache items belonging to the same logical object. These regions are created as sub-directories in the cache directory on disk. LEADTOOLS Document classes use the unique document identifier as the region name and hence can delete all the items belonging to a single document by deleting the region.
Items are purged from the cache if they have an absolute or sliding expiration policy. This is done when the item is accessed (it will be deleted if expired) or by the user by using CheckPolicy or CheckPolicies.
Since cache items that are not used will stay on disk, it is preferable to create a process for purging expired policies manually. This can be done by calling CheckPolicies which will check the whole cache and delete any items that are expired.
GetItemExternalResource returns the physical path of any item currently stored in the cache. This gives the user the ability to read the data of the item directly or pass the file to another part of the system that may require a physical file on disk.
GetItemVirtualDirectoryUrl returns a URI to any item currently stored in the cache. CacheVirtualDirectory must be setup to use this method. Obtaining a URI to a cache item can be useful in a Web application if the client code is JavaScript for example.
This cache implementation also supports data items with values set to null. Thus it is always preferable to use Contains or GetCacheItem<T> instead of relying to Get and checking for null.
The CacheItemExpiring and CacheItemExpired events occur when an item is expired and is about to be removed from the cache.
Use GetStatistics to get the number of regions, items and expired items currently in the cache.
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:\LEADTOOLS22\Resources\Images";
}