using System;

using System.Collections.Generic;

using KGySoft.Collections;

​

public 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%