// 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, }); } } }