Global Caching

[snarfblam]

I posted this class definition on another thread and decided that it would be a good idea to post it in the Code Library as well. It is a generic, global object caching class, working in a dictionary-like manner (and, in fact, backed by a Dictionary<string, TValue> object).

Because of the way that .Net handles fields of static classes you are provided a complete and separate cache for each type. (Or, to be more accurate, for each type parameter. For example, you can store a Bitmap in Cache<Image> and it will not be found in Cache<Bitmap>. Likewise, a Bitmap stored in Cache<Bitmap> will not be found in Cache<Image>.) The Cache class provides indexers and enumerators, and is implemented in a manner that makes the use of keys to identify objects completely optional.

static class Cache<T>
{
    // Backing collection
    static Dictionary<string, T> values;
    
    static Cache() {
        // Create a dicationary with case-insensitive strings for keys.
        values = new Dictionary<string, T>(StringComparer.InvariantCultureIgnoreCase);
    }
 
    public static T GetItem(string key){
        return values[key];
    }
 
#region Add/Remove methods
    /// <summary>
    /// Adds an object with a specified key to the cache.
    /// </summary>
    /// <param name="key">The key under which the object is stored.</param>
    /// <param name="value">The object to store.</param>
    public static void Add(string key, T value){
        values.Add(key, value);
    }
    /// <summary>
    /// Adds an object to the cache, generating a key automatically.
    /// </summary>
    /// <param name="value">The value to store.</param>
    public static void Add(T value){
        values.Add(
            //Create a key based on the object's hash code, ideally
            //ensuring that unique objects obtain unique keys.
            value.GetHashCode().ToString(),
            value);
    }
 
    /// <summary>
    /// Removes an object from the cache by specifying the key.
    /// </summary>
    /// <param name="key">The key of the object to remove from the cache.</param>
    /// <returns>A value indicating success or failure of the operation.</returns>
    public static bool Remove(string key) {
        return values.Remove(key);
    }
    /// <summary>
    /// Removes an object from the cache by specifying the key.
    /// </summary>
    /// <param name="value">The object to remove from the cache.</param>
    /// <returns>A value indicating success or failure of the operation.</returns>
    public static bool Remove(T value) {
        string key = null;
        foreach(KeyValuePair<string, T> item in values){
            if(item.Value.Equals(value)) {
                key = item.Key;
                break;
            }
        }
 
        if(key == null) return false;
 
        return values.Remove(key);
    }
 
    /// <summary>
    /// Removes any items from the cache where the item meets the condition specified.
    /// </summary>
    /// <param name="condition">A delegate which processes an item and returns a boolean value
    /// indicative of whether or not the value meets a condition.</param>
    public static void Remove(Predicate<T> condition) {
        string[] keys = new string[values.Count];
        values.Keys.CopyTo(keys, 0);
 
        foreach(string key in keys) {
            if(condition(values[key])) values.Remove(key);
        }
    }
    /// <summary>
    /// Removes any items from the cache where the key meets the condition specified.
    /// </summary>
    /// <param name="condition">A delegate which processes a key and returns a boolean value
    /// indicative of whether or not the value meets a condition.</param>
    public static void Remove(Predicate<string> condition) {
        string[] keys = new string[values.Count];
        values.Keys.CopyTo(keys, 0);
 
        foreach(string key in keys) {
            if(condition(key)) values.Remove(key);
        }
    }
 
    /// <summary>
    /// Removes all items from the cache.
    /// </summary>
    public static void Clear() {
        values.Clear();
    }
#endregion
 
#region Enumerators
    /// <summary>
    /// Gets an enumerable collection of all the objects stored in the cache.
    /// </summary>
    public static IEnumerable<T> Values {
        get {
            return values.Values;
        }
    }
    /// <summary>
    /// Gets an enumerable collection of all the keys that identify objects in the cache.
    /// </summary>
    public static IEnumerable<string> Keys {
        get {
            return values.Keys;
        }
    }
#endregion
 
}

The Cache<T> class generally performs the same function that a statically declared Dictionary<TKey, TValue> object would, but it can be more convinient to write code with, and, again, the use of keys is optional.

Unfortunately, because of a technical issue (overloading), Cache<string> will be difficult if not impossible to use.

Here is an example of using the Cache<T> class.

public void Example(){
    // It could be handy to cache bitmaps that will be used application-wide.
    Cache<Image>.Add("OpenIcon", Image.FromFile(IconPath.OpenIcon));
    Cache<Image>.Add("CloseIcon", Image.FromFile(IconPath.CloseIcon));
 
    // Be careful--generics do not respect inheritance.
    // (They can't due to the way that .Net handles static members of generic classes.)

    // Throws exception because object is not cached in Cache<Bitmap>.
    Image OpenImage = Cache<Bitmap>["OpenIcon"]; 
    // Works
    OpenImage = Cache<Image>["OpenIcon"];

    // Cache is enumerable.
    // Let's display the contents of Cache<Image> using an image displaying form.
    foreach(string key in Cache<Image>.Keys) {
        // Create the form with the key for the caption and the associated image within the form.
        frmImageDisplay = new ImageDisplayForm(key, Cache<Image>[key]);
        // And show.
        frmImageDisplay.ShowDialog();
    }
}