// API
/// <summary>
/// Add a shared object.
/// </summary>
/// <remarks>This requires an active Lock using a lock provider.</remarks>
public async Task AddAsync <TYPE>(string key, TYPE data)
{
key = KeyPrefix + key;
key = GetKey(key);
// save new version shared and locally
byte[] cacheData = new GeneralFormatter().Serialize(data);
DateTime created = DateTime.UtcNow;
IDatabase db = Redis.GetDatabase();
if (YetaWFManager.IsSync())
{
db.KeyDelete(GetVersionKey(key));
db.KeyDelete(GetDataKey(key));
db.StringSet(GetVersionKey(key), created.Ticks);
db.StringSet(GetDataKey(key), cacheData);
}
else
{
await db.KeyDeleteAsync(GetVersionKey(key));
await db.KeyDeleteAsync(GetDataKey(key));
await db.StringSetAsync(GetVersionKey(key), created.Ticks);
await db.StringSetAsync(GetDataKey(key), cacheData);
}
StaticCacheObject cachedObj = new StaticCacheObject {
Key = key,
Value = data,
Created = created,
};
lock (_lockObject) { // used to protect StaticObjects - local only
StaticObjects.Remove(key);
StaticObjects.Add(key, cachedObj);
}
}
/// <summary>
/// Add a shared object.
/// </summary>
/// <remarks>This requires an active Lock using a lock provider.</remarks>
public async Task AddAsync <TYPE>(string key, TYPE data)
{
key = GetKey(key);
// save new version shared and locally
SharedCacheObject sharedCacheObj = new SharedCacheObject {
Created = DateTime.UtcNow,
Key = key,
Value = new GeneralFormatter().Serialize(data),
};
await DataProvider.RemoveAsync(key);
await DataProvider.AddAsync(sharedCacheObj); // save shared cached version
StaticCacheObject cachedObj = new StaticCacheObject {
Key = key,
Value = data,
Created = sharedCacheObj.Created,
};
lock (_lockObject) { // used to protect StaticObjects - local only
StaticObjects.Remove(key);
StaticObjects.Add(key, cachedObj);
}
}
public async Task <GetObjectInfo <TYPE> > GetAsync <TYPE>(string key)
{
// get cached version
TYPE data = default(TYPE);
key = GetKey(key);
StaticCacheObject cachedObj;
bool localValid;
lock (_lockObject) { // used to protect StaticObjects - local only
localValid = StaticObjects.TryGetValue(key, out cachedObj);
}
if (!localValid)
{
cachedObj = new StaticCacheObject {
Key = key,
Value = default(TYPE),
Created = DateTime.MinValue,
};
}
else
{
data = (TYPE)cachedObj.Value;
}
// get shared cached version
SharedCacheVersion sharedInfo = await SharedCacheVersionPostgreSQLDataProvider.SharedCacheVersionDP.GetVersionAsync(key);
if (sharedInfo != null)
{
if (sharedInfo.Created != cachedObj.Created)
{
// shared cached version is different, retrieve and save locally
SharedCacheObject sharedCacheObj = await DataProvider.GetAsync(key);
if (sharedCacheObj == null)
{
// this shouldn't happen, we just got the shared version
}
else
{
data = new GeneralFormatter().Deserialize <TYPE>(sharedCacheObj.Value);
sharedInfo = sharedCacheObj;
}
cachedObj = new StaticCacheObject {
Created = sharedInfo.Created,
Key = sharedInfo.Key,
Value = data,
};
localValid = true;
lock (_lockObject) { // used to protect StaticObjects - local only
StaticObjects.Remove(key);
StaticObjects.Add(key, cachedObj);
}
}
else
{
// shared version same as local version
}
return(new GetObjectInfo <TYPE> {
Success = true,
Data = data,
});
}
else
{
// there is no shared version
// no shared cache
if (!localValid)
{
return(new GetObjectInfo <TYPE> {
Success = false
});
}
else
{
return(new GetObjectInfo <TYPE> {
Success = true,
Data = data,
});
}
}
}
public async Task <GetObjectInfo <TYPE> > GetAsync <TYPE>(string key)
{
key = KeyPrefix + key;
key = GetKey(key);
// get cached version
TYPE data = default(TYPE);
StaticCacheObject cachedObj;
bool localValid;
lock (_lockObject) { // used to protect StaticObjects - local only
localValid = StaticObjects.TryGetValue(key, out cachedObj);
}
if (!localValid)
{
cachedObj = new StaticCacheObject {
Key = key,
Value = data,
Created = DateTime.MinValue,
};
}
else
{
data = (TYPE)cachedObj.Value;
}
// get shared cached version
IDatabase db = Redis.GetDatabase();
long? val;
if (YetaWFManager.IsSync())
{
val = (long?)db.StringGet(GetVersionKey(key));
}
else
{
val = (long?)await db.StringGetAsync(GetVersionKey(key));
}
if (val != null)
{
DateTime sharedCacheCreated = new DateTime((long)val);
if (sharedCacheCreated != cachedObj.Created)
{
// shared cached version is different, retrieve and save locally
byte[] sharedCacheData;
if (YetaWFManager.IsSync())
{
sharedCacheData = db.StringGet(GetDataKey(key));
}
else
{
sharedCacheData = await db.StringGetAsync(GetDataKey(key));
}
if (sharedCacheData == null)
{
data = default(TYPE);
}
else
{
data = new GeneralFormatter().Deserialize <TYPE>(sharedCacheData);
}
cachedObj = new StaticCacheObject {
Created = sharedCacheCreated,
Key = key,
Value = data,
};
localValid = true;
lock (_lockObject) { // used to protect StaticObjects - local only
StaticObjects.Remove(key);
StaticObjects.Add(key, cachedObj);
}
}
else
{
// shared version same as local version
}
return(new GetObjectInfo <TYPE> {
Success = true,
Data = data,
});
}
else
{
// no shared cache
if (!localValid)
{
return(new GetObjectInfo <TYPE> {
Success = false
});
}
else
{
return(new GetObjectInfo <TYPE> {
Success = true,
Data = data,
});
}
}
}
