/// <summary>
/// Registers <see cref="VolatileCache"/> as singleton implementation for
/// <see cref="ICache"/>, <see cref="IAsyncCache"/>, <see cref="IDistributedCache"/>.
/// </summary>
/// <param name="services">Services collection.</param>
/// <param name="changeSettings">Can be used to customize settings.</param>
/// <returns>Modified services collection.</returns>
public static IServiceCollection AddVolatileSQLiteKVLiteCache(this IServiceCollection services, Action <VolatileCacheSettings> changeSettings)
{
var settings = new VolatileCacheSettings();
changeSettings?.Invoke(settings);
var ext = services.GetKVLiteExtensionServices();
#pragma warning disable CC0022 // Should dispose object
return(services.AddKVLiteCache(new VolatileCache(settings, ext.Serializer, ext.Compressor, ext.Clock, ext.Random)));
#pragma warning restore CC0022 // Should dispose object
}
/// <summary>
/// Learn how to use KVLite by examples.
/// </summary>
public static void Main()
{
// Some variables used in the examples.
var examplePartition1 = "example partition 1";
var examplePartition2 = "example partition 2";
var exampleKey1 = "example key 1";
var exampleKey2 = "example key 2";
var simpleValue = Math.PI;
var complexValue = new ComplexValue
{
Integer = 21,
NullableBoolean = null,
String = "Learning KVLite",
Dictionary = new Dictionary <short, ComplexValue>
{
[1] = new ComplexValue {
NullableBoolean = true
},
[2] = new ComplexValue {
String = "Nested..."
}
}
};
/*
* KVLite stores its values inside a given partition and each value is linked to a key.
* KVLite can contain more than one partition and each partition can contain more than one key.
*
* Therefore, values are stored according to this logical layout:
*
* [partition1] --> key1/value1
* --> key2/value2
* [partition2] --> key1/value1
* --> key2/value2
* --> key3/value3
*
* A key is unique inside a partition, not inside all cache.
* A partition, instead, is unique inside all cache.
*/
// You can start using the default caches immediately. Let's try to store some values in
// a way similar to the figure above, using the default persistent cache.
ICache persistentCache = PersistentCache.DefaultInstance;
persistentCache.AddTimed(examplePartition1, exampleKey1, simpleValue, persistentCache.Clock.GetCurrentInstant() + Duration.FromMinutes(5));
persistentCache.AddTimed(examplePartition1, exampleKey2, simpleValue, persistentCache.Clock.GetCurrentInstant() + Duration.FromMinutes(10));
persistentCache.AddTimed(examplePartition2, exampleKey1, complexValue, persistentCache.Clock.GetCurrentInstant() + Duration.FromMinutes(10));
persistentCache.AddTimed(examplePartition2, exampleKey2, complexValue, persistentCache.Clock.GetCurrentInstant() + Duration.FromMinutes(5));
PrettyPrint(persistentCache);
// Otherwise, you can customize you own cache... Let's see how we can use a volatile
// cache. Let's define the settings that we will use in new volatile caches.
var volatileCacheSettings = new VolatileCacheSettings
{
CacheName = "My In-Memory Cache", // The backend.
StaticInterval = Duration.FromDays(10) // How long static values will last.
};
// Then the settings that we will use in new persistent caches.
var persistentCacheSettings = new PersistentCacheSettings
{
CacheFile = "CustomCache.sqlite", // The SQLite DB used as the backend for the cache.
ChancesOfAutoCleanup = 0.5, // Chance of an automatic a cache cleanup being issued.
StaticInterval = Duration.FromDays(10) // How long static values will last.
};
// We create both a volatile and a persistent cache.
var volatileCache = new VolatileCache(volatileCacheSettings);
persistentCache = new PersistentCache(persistentCacheSettings);
// Use the new volatile cache!
volatileCache.AddStatic(examplePartition1, exampleKey1, Tuple.Create("Volatile!", 123));
PrettyPrint(volatileCache);
// Use the new persistent cache!
persistentCache.AddStatic(examplePartition2, exampleKey2, Tuple.Create("Persistent!", 123));
PrettyPrint(persistentCache);
/*
* An item can be added to the cache in three different ways.
*
* "Timed" values last until the specified date and time, or for a specified timespan.
* Reading them will not extend their lifetime.
*
* "Sliding" values last for the specified lifetime, but, if read,
* their lifetime will be extended by the timespan specified initially.
*
* "Static" values are a special form of "sliding" values.
* They use a very long timespan, 30 days by default, and they can be used for seldom changed data.
*/
// Let's clear the volatile cache and let's a value for each type.
volatileCache.Clear();
volatileCache.AddTimed(examplePartition1, exampleKey1, simpleValue, volatileCache.Clock.GetCurrentInstant() + Duration.FromMinutes(10));
volatileCache.AddTimed(examplePartition1, exampleKey2, complexValue, Duration.FromMinutes(15));
volatileCache.AddStatic(examplePartition2, exampleKey1, simpleValue);
volatileCache.AddSliding(examplePartition2, exampleKey2, complexValue, Duration.FromMinutes(15));
PrettyPrint(volatileCache);
Console.Read();
}
/// <summary>
/// Learn how to use KVLite by examples.
/// </summary>
public static void Main()
{
// Some variables used in the examples.
var examplePartition1 = "example partition 1";
var examplePartition2 = "example partition 2";
var exampleKey1 = "example key 1";
var exampleKey2 = "example key 2";
var simpleValue = Math.PI;
var complexValue = new ComplexValue
{
Integer = 21,
NullableBoolean = null,
String = "Learning KVLite",
Dictionary = new Dictionary<short, ComplexValue>
{
[1] = new ComplexValue { NullableBoolean = true },
[2] = new ComplexValue { String = "Nested..." }
}
};
/*
* KVLite stores its values inside a given partition and each value is linked to a key.
* KVLite can contain more than one partition and each partition can contain more than one key.
*
* Therefore, values are stored according to this logical layout:
*
* [partition1] --> key1/value1
* --> key2/value2
* [partition2] --> key1/value1
* --> key2/value2
* --> key3/value3
*
* A key is unique inside a partition, not inside all cache.
* A partition, instead, is unique inside all cache.
*/
// You can start using the default caches immediately. Let's try to store some values in
// a way similar to the figure above, using the default persistent cache.
ICache persistentCache = PersistentCache.DefaultInstance;
persistentCache.AddTimed(examplePartition1, exampleKey1, simpleValue, persistentCache.Clock.UtcNow.AddMinutes(5));
persistentCache.AddTimed(examplePartition1, exampleKey2, simpleValue, persistentCache.Clock.UtcNow.AddMinutes(10));
persistentCache.AddTimed(examplePartition2, exampleKey1, complexValue, persistentCache.Clock.UtcNow.AddMinutes(10));
persistentCache.AddTimed(examplePartition2, exampleKey2, complexValue, persistentCache.Clock.UtcNow.AddMinutes(5));
PrettyPrint(persistentCache);
// Otherwise, you can customize you own cache... Let's see how we can use a volatile
// cache. Let's define the settings that we will use in new volatile caches.
var volatileCacheSettings = new VolatileCacheSettings
{
CacheName = "My In-Memory Cache", // The backend.
StaticIntervalInDays = 10 // How many days static values will last.
};
// Then the settings that we will use in new persistent caches.
var persistentCacheSettings = new PersistentCacheSettings
{
CacheFile = "CustomCache.sqlite", // The SQLite DB used as the backend for the cache.
InsertionCountBeforeAutoClean = 10, // Number of inserts before a cache cleanup is issued.
MaxCacheSizeInMB = 64, // Max size in megabytes for the cache.
MaxJournalSizeInMB = 16, // Max size in megabytes for the SQLite journal log.
StaticIntervalInDays = 10 // How many days static values will last.
};
// We create both a volatile and a persistent cache.
var volatileCache = new VolatileCache(volatileCacheSettings);
persistentCache = new PersistentCache(persistentCacheSettings);
// Use the new volatile cache!
volatileCache.AddStatic(examplePartition1, exampleKey1, Tuple.Create("Volatile!", 123));
PrettyPrint(volatileCache);
// Use the new persistent cache!
persistentCache.AddStatic(examplePartition2, exampleKey2, Tuple.Create("Persistent!", 123));
PrettyPrint(persistentCache);
/*
* An item can be added to the cache in three different ways.
*
* "Timed" values last until the specified date and time, or for a specified timespan.
* Reading them will not extend their lifetime.
*
* "Sliding" values last for the specified lifetime, but, if read,
* their lifetime will be extended by the timespan specified initially.
*
* "Static" values are a special form of "sliding" values.
* They use a very long timespan, 30 days by default, and they can be used for seldom changed data.
*/
// Let's clear the volatile cache and let's a value for each type.
volatileCache.Clear();
volatileCache.AddTimed(examplePartition1, exampleKey1, simpleValue, volatileCache.Clock.UtcNow.AddMinutes(10));
volatileCache.AddTimed(examplePartition1, exampleKey2, complexValue, TimeSpan.FromMinutes(15));
volatileCache.AddStatic(examplePartition2, exampleKey1, simpleValue);
volatileCache.AddSliding(examplePartition2, exampleKey2, complexValue, TimeSpan.FromMinutes(15));
PrettyPrint(volatileCache);
Console.Read();
}
