public void Add(string key, object data, int duration)
{
_distributedCache.Set(key, CacheSerializer.Serialize(data), new DistributedCacheEntryOptions
{
AbsoluteExpiration = DateTime.Now.AddMinutes(duration)
});
}
public DbDataWorker(IAsyncDbDataFetcher <TMap> fetcher, IDbDataFetcher <TMap, TKey, TValue> keyBasedFetcher,
CacheSerializer cacheSerializer, ObjectPool <TMap> mapPool)
{
_fetcher = fetcher;
_keyBasedFetcher = keyBasedFetcher;
_cacheSerializer = cacheSerializer;
_mapPool = mapPool;
}
public object Get(string key)
{
byte[] result;
result = _distributedCache.Get(key);
var deserializeResult = CacheSerializer.Deserialize <object>(result);
return(deserializeResult);
}
public void ShouldDeserializeJsonToCache()
{
string json = CreateJsonString();
var cacheSerializer = new CacheSerializer();
Dictionary <string, int> result = cacheSerializer.Deserialize(json);
int id = result[SerieName];
Assert.That(id, Is.EqualTo(SerieId));
}
public void ShouldSerializeCacheToJson()
{
var testDictionary = new Dictionary <string, int>();
testDictionary[SerieName] = SerieId;
var cacheSerializer = new CacheSerializer();
string serializedContents = cacheSerializer.Serialize(testDictionary);
Assert.That(serializedContents, Is.EqualTo(CreateJsonString()));
}
public T GetValue()
{
var cacheKey = GetCacheKey();
var cacheValue = CacheSerializer.Get <T>(cacheKey);
if (Equals(cacheValue, default(T)))
{
cacheValue = GetValueConcrete();
CacheSerializer.SetAsync(cacheKey, cacheValue, CacheConfiguration.ExpirationSeconds);
}
return(cacheValue);
}
public async Task <T> GetValueAsync()
{
var cacheKey = GetCacheKey();
var cacheValue = await CacheSerializer.GetAsync <T>(cacheKey);
if (Equals(cacheValue, default(T)))
{
cacheValue = await GetValueConcreteAsync();
await CacheSerializer.SetAsync(cacheKey, cacheValue, CacheConfiguration.ExpirationSeconds);
}
return(cacheValue);
}
private static void Uninstall()
{
IRegistryService registryService = new RegistryService();
ICacheSerializer cacheSerializer = new CacheSerializer();
ISettingsSerializer settingsSerializer = new SettingsSerializer(registryService);
cacheSerializer.DeleteCache();
registryService.DeleteRunOnStartup();
//Not sure, if it will be user-friendly; but i prefer if applications remove themselves completely,
//especially small ones.
settingsSerializer.DeleteSettings();
}
private async Task <IReadOnlyList <IWallet> > ReloadAllAsync(string walletId)
{
var result = (await _repository.GetAsync(walletId)).Select(CachedWalletModel.Create).ToArray();
try
{
await _redisDatabase.HashSetAsync(
GetCacheKey(walletId),
result.Select(x => new HashEntry(x.AssetId, CacheSerializer.Serialize(x))).ToArray());
await _redisDatabase.KeyExpireAsync(GetCacheKey(walletId), _cacheExpiration);
}
catch (RedisConnectionException ex)
{
_log.Warning("Redis cache is not available", ex);
}
return(result);
}
public async Task <IReadOnlyList <IWallet> > GetAllAsync(string walletId)
{
// todo: refactor most of code below into RedisCacheExtensions method 'TryHashGetAllAsync'
try
{
var balances = await _redisDatabase.HashGetAllAsync(GetCacheKey(walletId));
if (balances != null && balances.Length > 0)
{
return(balances.Select(x => CacheSerializer.Deserialize <CachedWalletModel>(x.Value)).ToList());
}
}
catch (RedisConnectionException ex)
{
_log.Warning("Redis cache is not available", ex);
}
return(await ReloadAllAsync(walletId));
}
public void SetUp()
{
_listener = new FileSystemListener();
_serializer = new CacheSerializer(TempFileName);
//Don't use the same listener for parser and cached file parser, as they will operate on different threads
_fileSystemParser = new FileSystemParserWithAction(new FileSystemListener(), new List <string> {
FolderName
});
_registryService = new FakeRegistryService();
_asyncParser = new AsyncFileSystemParser(new FileSystemParser(new FileSystemListener(), new List <string> {
FolderName
}));
_appRunOnStartup = true;
_updatesCountToWrite = -1;
DirectoryUtility.EnsureClearFolder(FolderName);
if (Directory.Exists(FolderName))
{
DeleteFolder();
}
Directory.CreateDirectory(FolderName);
}
public T Get(string cacheKeyName, int cacheTimeOutSeconds, Func <T> func)
{
//var redisManager = new PooledRedisClientManager("localhost:6379");
var redisCacheServer =
ConfigurationManager.AppSettings["RedisCacheServer"];
var redisCacheServerPort =
ConfigurationManager.AppSettings["RedisCacheServerPort"];
if (string.IsNullOrEmpty(redisCacheServer))
{
throw new ApplicationException("RedisCacheServer must be defined in appsettings");
}
if (string.IsNullOrEmpty(redisCacheServerPort))
{
throw new ApplicationException("RedisCacheServerPort must be defined in appsettings");
}
var redisKey = ConfigurationManager.AppSettings["RedisCacheServerKey"];
string connectionString;
if (!string.IsNullOrEmpty(redisKey))
{
connectionString =
$"{redisCacheServer}:{redisCacheServerPort},abortConnect=false,ssl=false,password={redisKey}";
}
else
{
connectionString =
$"{redisCacheServer}:{redisCacheServerPort}";
}
using (var connectionMultiplexer = ConnectionMultiplexer.Connect(connectionString))
{
lock (Locker)
{
redis = connectionMultiplexer.GetDatabase();
}
var o = CacheSerializer.Deserialize <T>(redis.StringGet(cacheKeyName));
if (o != null)
{
return(o);
}
lock (Locker)
{
// get lock but release if it takes more than 60 seconds to complete to avoid deadlock if this app crashes before release
//using (redis.AcquireLock(cacheKeyName + "-lock", TimeSpan.FromSeconds(60)))
var lockKey = cacheKeyName + "-lock";
if (redis.LockTake(lockKey, Environment.MachineName, TimeSpan.FromSeconds(10)))
{
try
{
o = CacheSerializer.Deserialize <T>(redis.StringGet(cacheKeyName));
if (o == null)
{
o = func();
redis.StringSet(cacheKeyName, CacheSerializer.Serialize(o),
TimeSpan.FromSeconds(cacheTimeOutSeconds));
}
redis.LockRelease(lockKey, Environment.MachineName);
return(o);
}
finally
{
redis.LockRelease(lockKey, Environment.MachineName);
}
}
return(o);
}
}
}
