public static void InvalidateAllObjects <T>(this IBlobCache This) { foreach (var key in This.GetAllKeys().Where(x => x.StartsWith(GetTypePrefixedKey("", typeof(T))))) { This.Invalidate(key); } }
public Task Remove(string key) { var t = Task.Run(() => cache.Invalidate(key)); t.ConfigureAwait(false); return(t); }
/// <summary> /// This is the non-generic analog of JsonSerializationMixin.GetAndFetchLatest[1] /// We shouldn't make modifications to this that alter its behavior from the generic /// version. By having this we can keep our two GetAndRefresh methods extremely /// similar and thus trust that what works in one will work in the other. /// /// 1. https://github.com/akavache/Akavache/blob/1b19bb56d/Akavache/Portable/JsonSerializationMixin.cs#L202-L236 /// </summary> static IObservable <byte[]> GetAndFetchLatestBytes( this IBlobCache blobCache, string key, Func <IObservable <byte[]> > fetchFunc, Func <DateTimeOffset, bool> fetchPredicate = null, DateTimeOffset?absoluteExpiration = null) { var fetch = Observable.Defer(() => blobCache.GetCreatedAt(key)) .Select(x => fetchPredicate == null || x == null || fetchPredicate(x.Value)) .Where(predicateIsTrue => predicateIsTrue) .SelectMany(_ => { return(fetchFunc() .SelectMany(x => blobCache.Invalidate(key).Select(__ => x)) .SelectMany(x => blobCache.Insert(key, x, absoluteExpiration).Select(__ => x))); }); var result = blobCache.Get(key).Select(x => Tuple.Create(x, true)) .Catch(Observable.Return(new Tuple <byte[], bool>(null, false))); return(result .SelectMany(x => x.Item2 ? Observable.Return(x.Item1) : Observable.Empty <byte[]>()) .Concat(fetch) .Replay() .RefCount()); }
/// <summary> /// This method attempts to returned a cached value, while /// simultaneously calling a Func to return the latest value. When the /// latest data comes back, it replaces what was previously in the /// cache. /// /// This method is best suited for loading dynamic data from the /// Internet, while still showing the user earlier data. /// /// This method returns an IObservable that may return *two* results /// (first the cached data, then the latest data). Therefore, it's /// important for UI applications that in your Subscribe method, you /// write the code to merge the second result when it comes in. /// </summary> /// <param name="key">The key to store the returned result under.</param> /// <param name="fetchFunc"></param> /// <param name="fetchPredicate">An optional Func to determine whether /// the updated item should be fetched. If the cached version isn't found, /// this parameter is ignored and the item is always fetched.</param> /// <param name="absoluteExpiration">An optional expiration date.</param> /// <returns>An Observable stream containing either one or two /// results (possibly a cached version, then the latest version)</returns> public static IObservable <T> GetAndFetchLatest <T>(this IBlobCache This, string key, Func <IObservable <T> > fetchFunc, Func <DateTimeOffset, bool> fetchPredicate = null, DateTimeOffset?absoluteExpiration = null) { bool foundItemInCache; var fail = Observable.Defer(() => This.GetCreatedAt(key)) .Select(x => fetchPredicate != null && x != null ? fetchPredicate(x.Value) : true) .Where(x => x != false) .SelectMany(_ => fetchFunc()) .Finally(() => This.Invalidate(key)) .Do(x => This.InsertObject(key, x, absoluteExpiration)); var result = This.GetObjectAsync <T>(key).Select(x => new Tuple <T, bool>(x, true)) .Catch(Observable.Return(new Tuple <T, bool>(default(T), false))); return(result.SelectMany(x => { foundItemInCache = x.Item2; return x.Item2 ? Observable.Return(x.Item1) : Observable.Empty <T>(); }).Concat(fail).Multicast(new ReplaySubject <T>()).RefCount()); }
/// <summary> /// Invalidates a single object from the cache. It is important that the Type /// Parameter for this method be correct, and you cannot use /// IBlobCache.Invalidate to perform the same task. /// </summary> /// <typeparam name="T">The type of item to invalidate.</typeparam> /// <param name="blobCache">The cache to invalidate.</param> /// <param name="key">The key to invalidate.</param> /// <returns>An observable that signals when the operation has completed.</returns> public static IObservable <Unit> InvalidateObject <T>(this IBlobCache blobCache, string key) { if (blobCache is IObjectBlobCache objCache) { return(objCache.InvalidateObject <T>(key)); } return(blobCache.Invalidate(GetTypePrefixedKey(key, typeof(T)))); }
private static async Task TestIt(IBlobCache cache) { _cnt = 0; Console.WriteLine(await GetOrFetchAsync(cache, DateTime.UtcNow + TimeSpan.FromMilliseconds(1000))); await cache.Invalidate("a"); Console.WriteLine(await GetOrFetchAsync(cache, DateTime.UtcNow + TimeSpan.FromMilliseconds(1000))); Console.WriteLine("====================="); Console.WriteLine(); }
/// <summary> /// Invalidates a single object from the cache. It is important that the Type /// Parameter for this method be correct, and you cannot use /// IBlobCache.Invalidate to perform the same task. /// </summary> /// <param name="key">The key to invalidate.</param> public static IObservable <Unit> InvalidateObject <T>(this IBlobCache This, string key) { var objCache = This as IObjectBlobCache; if (objCache != null) { return(objCache.InvalidateObject <T>(key)); } return(This.Invalidate(GetTypePrefixedKey(key, typeof(T)))); }
private void OnRequestFailed(PreparedTrackingRequest request, IRestResponse response) { if (response.ResponseStatus != ResponseStatus.Completed || response.StatusCode != System.Net.HttpStatusCode.OK) { ThreadPool.RegisterWaitForSingleObject(new ManualResetEvent(false), (completed, state) => { RequestQueue.OnNext(request); //Re-queue the item for sending }, null, RetryInterval, true); } Debug.WriteLine("Analytics Request Failed"); Debug.Indent(); Debug.WriteLine("{0} {1} {2}", response.ResponseStatus, (int)response.StatusCode, response.StatusCode); Debug.WriteLine("{0}", response.Request.Parameters.Select(x => x.Name + "=" + x.Value).Aggregate((x, y) => x + "&" + y)); if (!response.Content.IsNullOrEmpty()) { Debug.WriteLine("{0}", response.Content); } Debug.Unindent(); KeyStore.Invalidate(string.Format("PreparedTrackingRequest_{0}", request.RequestID.ToString())); }
public Task Logout() => Task.Run(async() => { var keys = await _blobCache.GetAllKeys(); foreach (var driveKey in keys.Where(x => x.StartsWith("google-drive", StringComparison.OrdinalIgnoreCase))) { await _blobCache.Invalidate(driveKey); } _driveService = null; _isAuthorized.OnNext(false); return(Task.CompletedTask); });
public static IObservable <Unit> Invalidate(this IBlobCache This, IEnumerable <string> keys) { var bulkCache = This as IBulkBlobCache; if (bulkCache != null) { return(bulkCache.Invalidate(keys)); } return(keys.ToObservable() .SelectMany(x => This.Invalidate(x)) .TakeLast(1)); }
/// <summary> /// Invalidates a single object from the cache. It is important that the Type /// Parameter for this method be correct, and you cannot use /// IBlobCache.Invalidate to perform the same task. /// </summary> /// <typeparam name="T">The type of item to invalidate.</typeparam> /// <param name="blobCache">The cache to invalidate.</param> /// <param name="key">The key to invalidate.</param> /// <returns>An observable that signals when the operation has completed.</returns> public static IObservable <Unit> InvalidateObject <T>(this IBlobCache blobCache, string key) { if (blobCache is null) { throw new ArgumentNullException(nameof(blobCache)); } if (blobCache is IObjectBlobCache objCache) { return(objCache.InvalidateObject <T>(key)); } return(blobCache.Invalidate(GetTypePrefixedKey(key, typeof(T)))); }
public async Task <bool> Delete <T>(T item) where T : BaseModel, new() { var collection = (await GetAll <T>()).ToList(); var element = collection.FirstOrDefault(x => x.Id == item.Id); if (element != null) { collection.Remove(element); await localBlobCache.Invalidate(typeof(T).Name); InsertAll(collection); } return(false); }
// deletes and then inserts an object in the cache public static async Task UpdateUserCache <T>(String key, T obj) { if (key == null || obj == null) { return; } try { await userCache.Invalidate(key).FirstAsync().ToTask().ContinueWith(async(unit) => { await userCache.InsertObject(key, obj) .FirstAsync().ToTask().ConfigureAwait(false); }).ConfigureAwait(false); } catch (Exception ex) { throw new Exception($"Exception on UpdateUserCache: { ex.Message }"); //Debug.WriteLine("*** " + e.Message); } }
public async Task RemoveFileRecordAsync(string path) { await Cache.Invalidate(path); }
public IObservable <Unit> Invalidate(string key) { return(_inner.Invalidate(key)); }
public async Task DeleteAsync <T>(string key) { var identity = $"google-drive-{_id}-{key}"; await _blobCache.Invalidate(identity); }
public IObservable <Unit> ClearCache() => _blob.Invalidate(nameof(GitHubRepository)).Select(x => { _blob.InsertObject(nameof(GitHubRepository), new List <GitHubRepository>()); return(x); });
public void InvalidateCache(string key) { Cache.Invalidate(key); }
public void Remove(string key) { _internalCache.Invalidate(key); }
public void Remove(string key) { blobCache.Invalidate(key).Wait(); }
public static void InvalidateObject <T>(this IBlobCache This, string key) { This.Invalidate(GetTypePrefixedKey(key, typeof(T))); }
public IObservable <Unit> InvalidateAvatar(IAvatarContainer apiAccount) { return(String.IsNullOrWhiteSpace(apiAccount?.Login) ? Observable.Return(Unit.Default) : cache.Invalidate(apiAccount.Login)); }
public static void DeleteUserData(string key) { UserData.Invalidate(key); }