CacheTKey, TValue Class

[SerializableAttribute]
public class Cache<TKey, TValue> : IDictionary<TKey, TValue>, 
	ICollection<KeyValuePair<TKey, TValue>>, IEnumerable<KeyValuePair<TKey, TValue>>, 
	IEnumerable, ICache, IDictionary, ICollection, ISerializable, 
	IDeserializationCallback, IReadOnlyDictionary<TKey, TValue>, IReadOnlyCollection<KeyValuePair<TKey, TValue>>

using System;
using System.Collections.Generic;
using KGySoft.Collections;

class Example
{
    private static Cache<int, bool> isPrimeCache;

    public static void Main()
    {
        // Cache capacity is initialized to store maximum 4 values
        isPrimeCache = new Cache<int, bool>(ItemLoader, 4);

        // If cache is full the least recent used element will be deleted
        isPrimeCache.Behavior = CacheBehavior.RemoveLeastRecentUsedElement;

        // cache is now empty
        DumpCache();

        // reading the cache invokes the loader method
        CheckPrime(13);

        // reading a few more values
        CheckPrime(23);
        CheckPrime(33);
        CheckPrime(43);

        // dumping content
        DumpCache();

        // accessing an already read item does not invoke loader again
        // Now it changes cache order because of the chosen behavior
        CheckPrime(13);
        DumpCache();

        // reading a new element with full cache will delete an old one (now 23)
        CheckPrime(111);
        DumpCache();

        // but accessing a deleted element causes to load it again
        CheckPrime(23);
        DumpCache();

        // dumping some statistics
        Console.WriteLine(isPrimeCache.GetStatistics().ToString());
    }

    // This is the item loader method. It can access database or perform slow calculations.
    // If cache is meant to be serialized it should be a static method rather than an anonymous delegate or lambda expression.
    private static bool ItemLoader(int number)
    {
        Console.WriteLine("Item loading has been invoked for value {0}", number);

        // In this example item loader checks whether the given number is a prime by a not too efficient algorithm.
        if (number <= 1)
            return false;
        if (number % 2 == 0)
            return true;
        int i = 3;
        int sqrt = (int)Math.Floor(Math.Sqrt(number));
        while (i <= sqrt)
        {
            if (number % i == 0)
                return false;
            i += 2;
        }

        return true;
    }

    private static void CheckPrime(int number)
    {
        // cache is used transparently here: indexer is always just read
        bool isPrime = isPrimeCache[number];
        Console.WriteLine("{0} is a prime: {1}", number, isPrime);
    }

    private static void DumpCache()
    {
        Console.WriteLine();
        Console.WriteLine("Cache elements count: {0}", isPrimeCache.Count);
        if (isPrimeCache.Count > 0)
        {
            // enumerating through the cache shows the elements in the evaluation order
            Console.WriteLine("Cache elements:");
            foreach (KeyValuePair<int, bool> item in isPrimeCache)
            {
                Console.WriteLine("\tKey: {0},\tValue: {1}", item.Key, item.Value);
            }
        }

        Console.WriteLine();
    }
}

// This code example produces the following output:
//
// Cache elements count: 0
// 
// Item loading has been invoked for value 13
// 13 is a prime: True
// Item loading has been invoked for value 23
// 23 is a prime: True
// Item loading has been invoked for value 33
// 33 is a prime: False
// Item loading has been invoked for value 43
// 43 is a prime: True
// 
// Cache elements count: 4
// Cache elements:
// Key: 13,        Value: True
// Key: 23,        Value: True
// Key: 33,        Value: False
// Key: 43,        Value: True
// 
// 13 is a prime: True
// 
// Cache elements count: 4
// Cache elements:
// Key: 23,        Value: True
// Key: 33,        Value: False
// Key: 43,        Value: True
// Key: 13,        Value: True
// 
// Item loading has been invoked for value 111
// 111 is a prime: False
// 
// Cache elements count: 4
// Cache elements:
// Key: 33,        Value: False
// Key: 43,        Value: True
// Key: 13,        Value: True
// Key: 111,       Value: False
// 
// Item loading has been invoked for value 23
// 23 is a prime: True
// 
// Cache elements count: 4
// Cache elements:
// Key: 43,        Value: True
// Key: 13,        Value: True
// Key: 111,       Value: False
// Key: 23,        Value: True
// 
// Cache<Int32, Boolean> cache statistics:
// Count: 4
// Capacity: 4
// Number of writes: 6
// Number of reads: 7
// Number of cache hits: 1
// Number of deletes: 2
// Hit rate: 14,29%