private PostEvictionCallbackRegistration GetPostEvictionCallbackRegistration()
{
var registration = new PostEvictionCallbackRegistration();
registration.EvictionCallback = DisposeValue;
return(registration);
}
/// <summary>
/// Adds an object to distributed cache
/// </summary>
/// <typeparam name="TItem">Cache object type</typeparam>
/// <param name="partitionName">Cache Partition Name</param>
/// <param name="key">Cache Key</param>
/// <param name="value">Cache object</param>
/// <param name="expirationToken">Cache <see cref="IChangeToken"/> expiration token to be used while adding cache item</param>
/// <param name="postEvictionCallback"><see cref="PostEvictionCallbackRegistration"/> delegate</param>
public void Set <TItem>(string partitionName, string key, TItem value, IChangeToken expirationToken = null,
PostEvictionCallbackRegistration postEvictionCallback = null)
{
var partition = GetPartition(partitionName);
partition.Cache.Set(partitionName + key, value,
GetDistributedCacheEntryOptions(partition, expirationToken, postEvictionCallback));
}
/// <summary>
/// Adds an object to distributed cache asynchronously without expiration change token
/// </summary>
/// <typeparam name="TItem">Cache object type</typeparam>
/// <param name="partitionName">Cache Partition Name</param>
/// <param name="key">Cache Key</param>
/// <param name="value">Cache object</param>
/// <param name="postEvictionCallback"><see cref="PostEvictionCallbackRegistration"/> delegate</param>
/// <param name="token"><see cref="CancellationToken"/> to be used while setting cache item</param>
public async Task SetAsync <TItem>(string partitionName, string key, TItem value,
PostEvictionCallbackRegistration postEvictionCallback,
CancellationToken token = default)
{
var partition = GetPartition(partitionName);
await partition.Cache.SetAsync(partitionName + key, value,
GetDistributedCacheEntryOptions(partition), token);
}
//TODO need a better LRU cache, //there is no scan timer at all.
public TValue Set(object key, TValue value, TimeSpan slidingExpiration, PostEvictionCallbackRegistration evictionCallback = null)
{
var opt = new MemoryCacheEntryOptions();
////opt.AbsoluteExpirationRelativeToNow = slidingExpiration;
opt.SlidingExpiration = slidingExpiration;
if (null != evictionCallback)
{
opt.PostEvictionCallbacks.Add(evictionCallback);
}
return(_cache.Set(key, value, opt));
}
public static void Main()
{
ICacheManager cacheManager = CreateCacheManager();
object result;
string key = "Key";
object newObject = new object();
object state = new object();
// Basic CRUD operations:
// Create / Overwrite
AddToCache(cacheManager, InMemoryStorePartition, key, newObject);
AddToCache(cacheManager, DistributedMemoryStorePartition, key, newObject);
// Retrieve, null if not found
result = cacheManager.Get(InMemoryStorePartition, key);
result = cacheManager.Get(DistributedMemoryStorePartition, key);
// Retrieve
bool found = cacheManager.TryGetValue(InMemoryStorePartition, key, out result);
found = cacheManager.TryGetValue(DistributedMemoryStorePartition, key, out result);
// Store and Get using weak references
result = cacheManager.SetWeak(InMemoryStorePartition, key, newObject);
result = cacheManager.GetWeak <object>(InMemoryStorePartition, key);
result = cacheManager.SetWeak(DistributedMemoryStorePartition, key, newObject);
result = cacheManager.GetWeak <object>(DistributedMemoryStorePartition, key);
// Delete
cacheManager.Remove(InMemoryStorePartition, key);
cacheManager.Remove(DistributedMemoryStorePartition, key);
// Callback when evicted
PostEvictionCallbackRegistration postEvictionCallbackRegistration = new PostEvictionCallbackRegistration
{
EvictionCallback = (echoKey, value, reason, substate) =>
{
Console.WriteLine($"{echoKey} : {value} was evicted due to {reason}");
}
};
cacheManager.Set(InMemoryStorePartition, key, new object(), null, postEvictionCallbackRegistration);
cacheManager.Set(DistributedMemoryStorePartition, key, new object(), null, postEvictionCallbackRegistration);
AddPostEvictionPolicy(cacheManager, InMemoryStorePartition, key, postEvictionCallbackRegistration);
AddPostEvictionPolicy(cacheManager, DistributedMemoryStorePartition, key, postEvictionCallbackRegistration);
}
private void AddEvictionTracker(string key, object item, TimeSpan expirationSpan, PostEvictionDelegate callback)
{
if (expirationSpan > TimeSpan.Zero)
{
var cache = ExpirationTrackingCache;
var options = new MemoryCacheEntryOptions()
{
//AbsoluteExpiration = absoluteExpiration,
AbsoluteExpirationRelativeToNow = expirationSpan
};
var callbackRegistration = new PostEvictionCallbackRegistration();
callbackRegistration.EvictionCallback = callback;
callbackRegistration.State = key;
options.PostEvictionCallbacks.Add(callbackRegistration);
cache.Set(key, new object(), options);
}
}
public CircuitRegistry(
IOptions <CircuitOptions> options,
ILogger <CircuitRegistry> logger)
{
_options = options.Value;
_logger = logger;
ConnectedCircuits = new ConcurrentDictionary <string, CircuitHost>(StringComparer.Ordinal);
DisconnectedCircuits = new MemoryCache(new MemoryCacheOptions
{
SizeLimit = _options.MaxRetainedDisconnectedCircuits,
});
_postEvictionCallback = new PostEvictionCallbackRegistration
{
EvictionCallback = OnEntryEvicted,
};
}
void KeepClient(UdpClient2 client)
{
PostEvictionCallbackRegistration cb = new PostEvictionCallbackRegistration();
cb.EvictionCallback = (key, value, reason, state) =>
{
if (reason == EvictionReason.Expired)//
{
_logger?.LogInformation($"UDP cache client expired:{key.ToString()},{reason.ToString()}");
UdpClient2 c = value as UdpClient2;
if (c.Active)
{
KeepClient(c);
_logger?.LogInformation($"UDP cache client readd:{key.ToString()}");
}
}
};
_clientManager.Set(client.EndPoint, client, TimeSpan.FromMilliseconds(CLIENT_ACTIVE_TIMEOUT), cb);
}
public CircuitRegistry(
IOptions <CircuitOptions> options,
ILogger <CircuitRegistry> logger,
CircuitIdFactory CircuitHostFactory)
{
_options = options.Value;
_logger = logger;
_circuitIdFactory = CircuitHostFactory;
ConnectedCircuits = new ConcurrentDictionary <CircuitId, CircuitHost>();
DisconnectedCircuits = new MemoryCache(new MemoryCacheOptions
{
SizeLimit = _options.DisconnectedCircuitMaxRetained,
});
_postEvictionCallback = new PostEvictionCallbackRegistration
{
EvictionCallback = OnEntryEvicted,
};
}
private ExtendedDistributedCacheEntryOptions GetDistributedCacheEntryOptions(ICachePartition cachePartition,
IChangeToken expirationToken = null,
PostEvictionCallbackRegistration postEvictionCallback = null)
{
var cacheEntryOptions = new ExtendedDistributedCacheEntryOptions
{
AbsoluteExpiration = cachePartition.AbsoluteExpiration,
AbsoluteExpirationRelativeToNow = cachePartition.AbsoluteExpirationRelativeToNow,
SlidingExpiration = cachePartition.SlidingExpiration,
Priority = cachePartition.Priority
};
if (expirationToken != null)
{
cacheEntryOptions.ExpirationTokens.Add(expirationToken);
}
if (postEvictionCallback != null)
{
cacheEntryOptions.PostEvictionCallbacks.Add(postEvictionCallback);
}
return(cacheEntryOptions);
}
void KeepLocker(Locker <UdpClient2> locker)
{
PostEvictionCallbackRegistration cb = new PostEvictionCallbackRegistration();
cb.EvictionCallback = (key, value, reason, state) =>
{
if (reason == EvictionReason.Expired)//
{
_logger?.LogInformation($"UDP server locker expired:{key.ToString()},{reason.ToString()}");
Locker <UdpClient2> locker = value as Locker <UdpClient2>;
if ((DateTime.Now - locker.Owner.LastActive).TotalMilliseconds <= CLIENT_ACTIVE_TIMEOUT)
{
KeepLocker(locker);
_logger?.LogInformation($"UDP locker cache readd:{key.ToString()}");
}
else
{
locker.Destroy();
}
}
};
_clientLockers.Set(locker.Number, locker, TimeSpan.FromMilliseconds(CLIENT_ACTIVE_TIMEOUT), cb);
}
public static void Main()
{
ICacheManager cacheManager = CreateCacheManager();
var greeting = "";
var cacheKey = "cache_key";
var fileProvider = new PhysicalFileProvider(Path.Combine(Directory.GetCurrentDirectory(), "WatchedFiles"));
do
{
if (!cacheManager.TryGetValue(InMemoryStorePartition, cacheKey, out greeting))
{
using (var streamReader = new StreamReader(fileProvider.GetFileInfo("example.txt").CreateReadStream()))
{
greeting = streamReader.ReadToEnd();
PostEvictionCallbackRegistration postEvictionCallbackRegistration = new PostEvictionCallbackRegistration
{
EvictionCallback = (echoKey, value, reason, substate) =>
{
Console.WriteLine($"{echoKey} : {value} was evicted due to {reason}");
}
};
cacheManager.Set(InMemoryStorePartition, cacheKey, new object(), fileProvider.Watch("example.txt"), postEvictionCallbackRegistration);
Console.WriteLine($"{cacheKey} updated from source.");
}
}
else
{
Console.WriteLine($"{cacheKey} retrieved from cache.");
}
Console.WriteLine(greeting);
Console.WriteLine("Press any key to continue. Press the ESC key to exit");
}while (Console.ReadKey(true).Key != ConsoleKey.Escape);
}
private static void InvokeCallbacks(CacheEntry entry)
{
List <PostEvictionCallbackRegistration> callbackRegistrations = Interlocked.Exchange(ref entry._tokens._postEvictionCallbacks, null);
if (callbackRegistrations == null)
{
return;
}
for (int i = 0; i < callbackRegistrations.Count; i++)
{
PostEvictionCallbackRegistration registration = callbackRegistrations[i];
try
{
registration.EvictionCallback?.Invoke(entry.Key, entry.Value, entry.EvictionReason, registration.State);
}
catch (Exception e)
{
// This will be invoked on a background thread, don't let it throw.
entry._cache._logger.LogError(e, "EvictionCallback invoked failed");
}
}
}
private static void AddPostEvictionPolicy(ICacheManager cacheManager, string partitionName, string key, PostEvictionCallbackRegistration postEvictionCallbackRegistration)
{
// Remove on token expiration
var cts = new CancellationTokenSource();
cacheManager.Set(InMemoryStorePartition, key, new object(), new CancellationChangeToken(cts.Token), postEvictionCallbackRegistration);
// Fire the token to see the registered callback being invoked
cts.Cancel();
// Expire an entry if the dependent entry expires
cacheManager.Set(InMemoryStorePartition, "key1", "value1");
// expire this entry if the entry with key "key2" expires.
cts = new CancellationTokenSource();
cacheManager.Set(InMemoryStorePartition, "key2", "value2", new CancellationChangeToken(cts.Token), postEvictionCallbackRegistration);
// Fire the token to see the registered callback being invoked
cts.Cancel();
}
