public IObservable <IEnumerable <GitHubRepository> > LoadNextRepositories() { return(_blob.GetObject <IEnumerable <GitHubRepository> >(nameof(GitHubRepository)) .Select(x => { var page = x.Any() ? x.Count() / 50 : 0; page++; return _apiService.GetRepositories(_language, page) .Select(response => { var copy = new List <GitHubRepository>(x); if (copy.Count + response.Count() < KeyValues.MaxRepositories) { copy.AddRange(response); } else { var rest = KeyValues.MaxRepositories - copy.Count; var complete = new List <GitHubRepository>(response.Take(rest)); copy.AddRange(complete); response = new List <GitHubRepository>(complete); } _blob.InsertObject(nameof(GitHubRepository), copy, DateTimeOffset.UtcNow.AddDays(1)); return response; }).Wait(); })); }
public async Task <bool> Store(IStorableObject o, string key) { await cache.InsertObject(key, JsonConvert.SerializeObject(o, o.GetType(), settings)); Debug.WriteLine("Storing in the cache: {0} ", o); return(true); }
public IObservable <Unit> InsertAll(IList <Session> sessions) { return(blob.GetOrCreateObject <IList <Session> >(KEY_SESSIONS, () => new List <Session>()) .Select(source => { var checkedSessions = sessions.Where(session => session.IsChecked).ToDictionary(session => session.id); var merged = sessions.Union(source); return merged.Select(session => { session.IsChecked = checkedSessions.ContainsKey(session.id); return session; }); }) .SelectMany(merged => { return Observable.Merge( merged.ToObservable() .Select(session => session.category) .ToList().Distinct() .SelectMany(categoryDao.InsertAll), merged.ToObservable() .Select(session => session.place) .ToList().Distinct() .SelectMany(placeDao.InsertAll), blob.InsertObject(KEY_SESSIONS, merged) ); })); }
/// <summary> /// This method attempts to returned a cached value, and fetch one from /// the web. Optionally, it can continue to query to see if an update is required. /// /// If the cached value exists, it is returned. Then the predicate is queried to see /// if the remote value should be refreshed. /// /// If there is no cached value, then the value is fetched. /// /// Once the above is done, as the retrySequence comes in, the predicate will /// be called to see if a refresh is needed. If so, the data will be re-fetched. /// /// In all cases any remotely fetched data is cached. /// /// This also means that await'ing this method is a Bad Idea(tm), always /// use Subscribe. 1-infinity values can be returned depending on the arguments. /// </summary> /// <param name="key">The key to store the returned result under.</param> /// <param name="fetchFunc">A sequence that will return the new values of the data</param> /// <param name="fetchPredicate">A Func to determine whether /// the updated item should be fetched. Only called once a cached version exists.</param> /// <param name="retrySequence">Sequence that will trigger a predicate call followed by /// a fetch call if the predicate indicates so.</param> /// <param name="This">The blob cache against which we operate</param> /// <returns>An Observable stream containing one or more /// results (possibly a cached version, then the latest version(s))</returns> public static IObservable <T> GetAndFetchLatest <T>(this IBlobCache This, string key, Func <IObservable <T> > fetchFunc, Func <DateTimeOffset, IObservable <bool> > fetchPredicate, IObservable <Unit> retrySequence = null, DateTimeOffset?absoluteExpiration = null ) { if (fetchPredicate == null) { throw new ArgumentException("fetchPredicate"); } if (fetchFunc == null) { throw new ArgumentException("fetchFunc"); } // We are going to get the cache value if we can. And then we will run updates after that. // If we have nothing cached, then we will run the fetch directly. Otherwise we will run the // fetch sequence. var getOldKey = This.GetObjectCreatedAt <T>(key); var refetchIfNeeded = getOldKey .Where(dt => dt != null && dt.HasValue && dt.Value != null) .SelectMany(dt => fetchPredicate(dt.Value)) .Where(doit => doit == true) .Select(_ => default(Unit)); var fetchRequired = getOldKey .Where(dt => dt == null || !dt.HasValue || dt.Value == null) .Select(_ => default(Unit)); // Next, get the item... var fetchFromCache = Observable.Defer(() => This.GetObject <T>(key)) .Catch <T, KeyNotFoundException>(_ => Observable.Empty <T>()); var fetchFromRemote = fetchRequired.Concat(refetchIfNeeded) .SelectMany(_ => fetchFunc()) .SelectMany(x => This.InsertObject <T>(key, x, absoluteExpiration).Select(_ => x)); var items = fetchFromCache.Concat(fetchFromRemote); // Once we have these, we also have to kick off a second set of fetches for our retry sequence. if (retrySequence == null) { return(items); } var getAfter = retrySequence .SelectMany(_ => This.GetObjectCreatedAt <T>(key)) .SelectMany(dt => fetchPredicate(dt.Value)) .Where(doit => doit == true) .SelectMany(_ => fetchFunc()) .SelectMany(x => This.InsertObject <T>(key, x, absoluteExpiration).Select(_ => x)); return(items.Concat(getAfter)); }
public async Task SaveAsync <T>(string key, T value, TimeSpan?expiration = null) where T : class { if (expiration != null && expiration.HasValue) { await localBlobCache.InsertObject(key, value, expiration.Value); } else { await localBlobCache.InsertObject(key, value); } }
public async Task Logout() { try { //await _accountApiService.Logout(); } catch (Exception) { } AccessToken = string.Empty; await _secureBlobCache.Invalidate(AccessTokenKey); await _localMachineCache.InsertObject(IsNewUserKey, true); IsNewUser = true; }
/// <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. /// /// This also means that await'ing this method is a Bad Idea(tm), always /// use Subscribe. /// </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> /// <param name="shouldInvalidateOnError">If this is true, the cache will /// be cleared when an exception occurs in fetchFunc</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 shouldInvalidateOnError = false) { var fetch = Observable.Defer(() => This.GetObjectCreatedAt <T>(key)) .Select(x => fetchPredicate == null || x == null || fetchPredicate(x.Value)) .Where(x => x != false) .SelectMany(_ => { var fetchObs = fetchFunc().Catch <T, Exception>(ex => { var shouldInvalidate = shouldInvalidateOnError ? This.InvalidateObject <T>(key) : Observable.Return(Unit.Default); return(shouldInvalidate.SelectMany(__ => Observable.Throw <T>(ex))); }); return(fetchObs .SelectMany(x => This.InvalidateObject <T>(key).Select(__ => x)) .SelectMany(x => This.InsertObject <T>(key, x, absoluteExpiration).Select(__ => x))); }); var result = This.GetObject <T>(key).Select(x => new Tuple <T, bool>(x, true)) .Catch(Observable.Return(new Tuple <T, bool>(default(T), false))); return(result.SelectMany(x => { return x.Item2 ? Observable.Return(x.Item1) : Observable.Empty <T>(); }).Concat(fetch).Multicast(new ReplaySubject <T>()).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()); }
public static IObservable <T> CacheApiResult <T>( this IObservable <T> source, string cacheKey, IBlobCache blobCache, IFullLogger?logger = null, IScheduler?scheduler = null, bool forceUpdate = false, TimeSpan expiration = default) { expiration = expiration == TimeSpan.Zero ? Constants.DefaultCacheExpirationTimeOut : expiration; if (forceUpdate) { // TODO: [rlittlesii: July 30, 2020] Add retry and cached return(source.SelectMany(async value => { await blobCache.InsertObject(cacheKey, value, expiration); logger?.Debug($"CACHE: Writing {{Value}} to cache with key: {{CacheKey}}", value, cacheKey); return value; })); } blobCache .GetObject <T>(cacheKey) .Subscribe(obj => logger?.Debug("Found: {@Object}", obj)); // TODO: [rlittlesii: July 30, 2020] Add retry and cached return(blobCache .GetOrFetchObject( cacheKey, () => source.Timeout(Constants.DefaultRequestTimeout), DateTimeOffset.Now.Add(expiration))); }
private async void InsertObjects() { var postService = RestService.For <IHttpCallsJsonPlaceHolder>("http:\\jsonplaceholder.com"); var posts = await postService.GetPosts(); localData.InsertObject("Posts", posts); }
public IObservable <CacheIndex> Save(IBlobCache cache, DateTimeOffset?absoluteExpiration = null) { Guard.ArgumentNotNull(cache, nameof(cache)); return(cache.InsertObject(IndexKey, this, absoluteExpiration) .Select(x => this)); }
/// <summary> /// Inserts a item into the cache. /// </summary> /// <param name="blobCache">The blob cache to insert the item into.</param> /// <param name="key">The key to associate with the entry.</param> /// <param name="value">The data for the entry.</param> /// <param name="expiration">A timespan that will be added to the current DateTime.</param> /// <typeparam name="T">The type of item to insert.</typeparam> /// <returns>A observable which will signal when the item is added.</returns> public static IObservable <Unit> InsertObject <T>(this IBlobCache blobCache, string key, T value, TimeSpan expiration) { if (blobCache is null) { throw new ArgumentNullException(nameof(blobCache)); } return(blobCache.InsertObject(key, value, blobCache.Scheduler.Now + expiration)); }
partial void BtnStoreData_TouchUpInside(UIButton sender) { _encryptionProvider.SetPassword(txtPassword.Text); _encryptedBlobCache .InsertObject("key", kStoreMe) .Do(_ => InvokeOnMainThread(() => lblResult.Text = "Data Stored")) .Subscribe(); }
public IObservable<Unit> InsertAll(ICollection<Place> places) { return blob.GetOrCreateObject<IList<Place>>(KEY_PLACES, () => new List<Place>()) .Select(source => { return places.Union(source); }) .SelectMany(merged => blob.InsertObject(KEY_PLACES, merged)); }
/// <summary> /// Save all the data we pull off the internet in the cache for later user. /// </summary> /// <param name="file"></param> /// <param name="serverModifiedType"></param> /// <param name="filedata"></param> /// <param name="cache"></param> /// <returns></returns> public static IObservable <Unit> SaveFileInCache(this IFile file, string serverModifiedType, byte[] filedata, IBlobCache cache) { var timeToDelete = DateTime.Now + Settings.CacheFilesTime; var insertDate = cache.InsertObject(file.FileDateKey(), serverModifiedType, timeToDelete); var insertData = cache.Insert(file.FileDataKey(), filedata, timeToDelete); return(Observable.Concat(insertDate, insertData).Skip(1)); }
public IObservable <Unit> InsertAll(IList <Category> categories) { return(blob.GetOrCreateObject <IList <Category> >(KEY_CATEGORIES, () => new List <Category>()) .Select(source => { return categories.Union(source); }) .SelectMany(merged => blob.InsertObject(KEY_CATEGORIES, merged))); }
public IObservable<CacheIndex> AddAndSave(IBlobCache cache, string indexKey, CacheItem item, DateTimeOffset? absoluteExpiration = null) { var k = string.Format(CultureInfo.InvariantCulture, "{0}|{1}", IndexKey, item.Key); if (!Keys.Contains(k)) Keys.Add(k); UpdatedAt = DateTimeOffset.UtcNow; return cache.InsertObject(IndexKey, this, absoluteExpiration) .Select(x => this); }
public async Task <bool> Create <T>(T entity) where T : EntityBase, new() { try { // Aquí se haría la llamada con await a la API Rest con _remoteDatabase para CREAR el elemento en el servidor // Si ha ido bien se hace lo mismo en caché await _cache.InsertObject <T>( typeof(T).Name + "_" + entity.id.ToString(), entity, DateTimeOffset.Now.AddHours(1)); } catch (Exception) { return(false); } return(true); }
public IObservable<CacheIndex> Clear(IBlobCache cache, string indexKey, DateTimeOffset? absoluteExpiration = null) { OldKeys = Keys.ToList(); Keys.Clear(); UpdatedAt = DateTimeOffset.UtcNow; return cache .InvalidateObject<CacheIndex>(indexKey) .SelectMany(_ => cache.InsertObject(indexKey, this, absoluteExpiration)) .Select(_ => this); }
public IObservable <CacheIndex> Clear(IBlobCache cache, string indexKey, DateTimeOffset?absoluteExpiration = null) { OldKeys = Keys.ToList(); Keys.Clear(); UpdatedAt = DateTimeOffset.UtcNow; return(cache .InvalidateObject <CacheIndex>(indexKey) .SelectMany(_ => cache.InsertObject(indexKey, this, absoluteExpiration)) .Select(_ => this)); }
public IObservable <T> Save <T>(IBlobCache cache, string key, DateTimeOffset?absoluteExpiration = null) where T : CacheItem { var k = string.Format(CultureInfo.InvariantCulture, "{0}|{1}", key, Key); return(cache .InvalidateObject <T>(k) .Select(_ => cache.InsertObject(k, this, absoluteExpiration)) .Select(_ => this as T)); }
public async Task <List <IPage> > FetchPages(string id) { Cache = BlobCache.LocalMachine; List <IPage> getPagesTask = await GetPagesAsync(id); await Cache.InsertObject("pages", getPagesTask, DateTimeOffset.Now.AddHours(2)); List <IPage> pages = await Cache.GetObject <List <IPage> >("pages"); return(pages); }
public static IObservable <T?> GetAndFetchLatest <T>( this IBlobCache blobCache, string key, Func <IObservable <T> > fetchFunc, Func <DateTimeOffset, bool>?fetchPredicate = null, DateTimeOffset?absoluteExpiration = null, bool shouldInvalidateOnError = false, Func <T, bool>?cacheValidationPredicate = null) { if (blobCache is null) { throw new ArgumentNullException(nameof(blobCache)); } #pragma warning disable CS8604 // Possible null reference argument. var fetch = Observable.Defer(() => blobCache.GetObjectCreatedAt <T>(key)) .Select(x => fetchPredicate is null || x is null || fetchPredicate(x.Value)) .Where(x => x) .SelectMany(_ => { var fetchObs = fetchFunc().Catch <T, Exception>(ex => { var shouldInvalidate = shouldInvalidateOnError ? blobCache.InvalidateObject <T>(key) : Observable.Return(Unit.Default); return(shouldInvalidate.SelectMany(__ => Observable.Throw <T>(ex))); }); return(fetchObs .SelectMany(x => cacheValidationPredicate is not null && !cacheValidationPredicate(x) ? Observable.Return(default(T)) : blobCache.InvalidateObject <T>(key).Select(__ => x)) .SelectMany(x => cacheValidationPredicate is not null && !cacheValidationPredicate(x) ? Observable.Return(default(T)) : blobCache.InsertObject(key, x, absoluteExpiration).Select(__ => x))); }); if (fetch is null) { return(Observable.Throw <T>(new Exception("Could not find a valid way to fetch the value"))); } var result = blobCache.GetObject <T>(key).Select(x => (x, true)) .Catch(Observable.Return((default(T), false))); #pragma warning restore CS8604 // Possible null reference argument. return(result.SelectMany(x => x.Item2 ? Observable.Return(x.Item1) : Observable.Empty <T>()) .Concat(fetch) .Multicast(new ReplaySubject <T?>()) .RefCount()); }
/// <summary> /// Attempt to return an object from the cache. If the item doesn't /// exist or returns an error, call a Func to return the latest /// version of an object and insert the result in the cache. /// /// For most Internet applications, this method is the best method to /// call to fetch static data (i.e. images) from the network. /// </summary> /// <param name="key">The key to associate with the object.</param> /// <param name="fetchFunc">A Func which will asynchronously return /// the latest value for the object should the cache not contain the /// key. /// /// Observable.Start is the most straightforward way (though not the /// most efficient!) to implement this Func.</param> /// <param name="absoluteExpiration">An optional expiration date.</param> /// <returns>A Future result representing the deserialized object from /// the cache.</returns> public static IObservable <T> GetOrFetchObject <T>(this IBlobCache This, string key, Func <IObservable <T> > fetchFunc, DateTimeOffset?absoluteExpiration = null) { return(This.GetObjectAsync <T>(key).Catch <T, Exception>(_ => { object dontcare; return ((IObservable <T>)inflightFetchRequests.GetOrAdd(key, __ => (object)fetchFunc())) .Do(x => This.InsertObject(key, x, absoluteExpiration)) .Finally(() => inflightFetchRequests.TryRemove(key, out dontcare)) .Multicast(new AsyncSubject <T>()).RefCount(); })); }
public Task Set <T>(string key, T value, TimeSpan?expireTimeSpan) { var t = Task.Run(async() => { DateTimeOffset?offset = expireTimeSpan.HasValue ? DateTimeOffset.UtcNow.Add(expireTimeSpan.Value) : (DateTimeOffset?)null; await cache.InsertObject(key, value, offset); }); t.ConfigureAwait(false); return(t); }
/// <summary> /// Inserts the specified key/value pairs into the blob. /// </summary> /// <typeparam name="T">The type of item to insert.</typeparam> /// <param name="blobCache">The blob cache to insert the values to.</param> /// <param name="keyValuePairs">The key/value to insert.</param> /// <param name="absoluteExpiration">An optional expiration date.</param> /// <returns>A observable which signals when complete.</returns> public static IObservable <Unit> InsertObjects <T>(this IBlobCache blobCache, IDictionary <string, T> keyValuePairs, DateTimeOffset?absoluteExpiration = null) { if (blobCache is IObjectBulkBlobCache bulkCache) { return(bulkCache.InsertObjects(keyValuePairs, absoluteExpiration)); } return(keyValuePairs.ToObservable() .SelectMany(x => blobCache.InsertObject(x.Key, x.Value, absoluteExpiration)) .TakeLast(1)); }
public async Task <bool> PickupPackage(Package package) { if (await _blobCache.ContainsKey(package.Barcode)) { return(false); } await _blobCache.InsertObject(package.Barcode, package); return(true); }
//These methods are the ones we call from courseViewModel and ChapterViewModel public async Task <List <ChapterLevel> > FetchChapterLevels(string id) { Cache = BlobCache.LocalMachine; List <Chapter> getChaptersTask = await GetChaptersAsync(id); List <ChapterLevel> chapterLevels = FetchSortedLevels(getChaptersTask); await Cache.InsertObject("chapters", chapterLevels, DateTimeOffset.Now.AddHours(2)); List <ChapterLevel> chapters = await Cache.GetObject <List <ChapterLevel> >("chapters"); return(chapters); }
public async Task SaveAsync <T>(string key, T value, TimeSpan?expiration = null) where T : class { if (string.IsNullOrWhiteSpace(key)) { throw new InvalidOperationException($"{nameof(key)} cannot be null or white space."); } if (value == null) { throw new InvalidOperationException($"{nameof(value)} cannot be null."); } if (expiration != null && expiration.HasValue) { await localBlobCache.InsertObject(key, value, expiration.Value); } else { await localBlobCache.InsertObject(key, value); } }
public async Task <bool> SetUser(UserDto user) { try { await _blobCache.InsertObject($"current_user", user).ToTask(); return(true); } catch (Exception) { return(false); } }
public IObservable <CacheIndex> AddAndSave(IBlobCache cache, string indexKey, CacheItem item, DateTimeOffset?absoluteExpiration = null) { var k = string.Format(CultureInfo.InvariantCulture, "{0}|{1}", IndexKey, item.Key); if (!Keys.Contains(k)) { Keys.Add(k); } UpdatedAt = DateTimeOffset.UtcNow; return(cache.InsertObject(IndexKey, this, absoluteExpiration) .Select(x => this)); }
public override void SetOrCreate <T>(T value, [CallerMemberName] string key = null) { if (key == null) { throw new ArgumentNullException(nameof(key)); } AddToInternalCache(key, value); // Fire and forget, we retrieve the value from the in-memory cache from now on _blobCache.InsertObject($"{_cacheKey}:{key}", value).Wait(); _model.RaisePropertyChanged(key); }
public static IObservable<CacheIndex> AddAndSaveToIndex(IBlobCache cache, string indexKey, CacheItem item, DateTimeOffset? absoluteExpiration = null) { return cache.GetOrCreateObject(indexKey, () => Create(indexKey)) .Do(index => { var k = string.Format(CultureInfo.InvariantCulture, "{0}|{1}", index.IndexKey, item.Key); if (!index.Keys.Contains(k)) index.Keys.Add(k); index.UpdatedAt = DateTimeOffset.UtcNow; }) .SelectMany(index => cache.InsertObject(index.IndexKey, index, absoluteExpiration) .Select(x => index)); }
public FeedsViewModel(IBlobCache cache = null) { Cache = cache ?? Locator.Current.GetService<IBlobCache>(); Cache.GetOrCreateObject(BlobCacheKeys.Blogs, () => new ReactiveList<BlogViewModel>()) .Subscribe(blogs => { Blogs = blogs; }); RefreshAll = ReactiveCommand.CreateAsyncTask(x => { foreach (var blog in Blogs) { blog.Refresh.InvokeCommand(null); } return Task.FromResult(Unit.Default); }); RefreshAll.ThrownExceptions.Subscribe(thrownException => { this.Log().Error(thrownException); }); _isLoading = RefreshAll.IsExecuting.ToProperty(this, x => x.IsLoading); PersistData = ReactiveCommand.CreateAsyncTask(async x => { await Cache.InsertObject(BlobCacheKeys.Blogs, Blogs); }); PersistData.ThrownExceptions.Subscribe(thrownException => { this.Log().Error(thrownException); }); // behaviours // when a blog is added or removed, wait for 5 seconds of inactivity before persisting the data as the user may be doing bulk [add|remove] operations. this.WhenAnyValue(viewModel => viewModel.Blogs) .Throttle(TimeSpan.FromSeconds(5), RxApp.MainThreadScheduler) .InvokeCommand(this, viewModel => viewModel.PersistData); // When an user adds a new blog to the feed, automatically fetch/cache the contents of the blog. // When a blog becomes the selected blog, fetch/cache the contents of the blog. this.WhenAnyObservable(viewModel => viewModel.Blogs.ItemsAdded) .Merge(this.WhenAnyValue(viewModel => viewModel.SelectedBlog).Where(blogVm => blogVm != null)) .Subscribe(x => x.Refresh.InvokeCommand(null)); // post-condition checks Condition.Ensures(Cache).IsNotNull(); Condition.Ensures(RefreshAll).IsNotNull(); Condition.Ensures(PersistData).IsNotNull(); }
public async Task WriteToStorage(IBlobCache storage) { await storage.InsertObject("ApiKey", ApiKey); await storage.InsertObject("AuthUser", AuthUser); await storage.InsertObject("AuthPass", AuthPass); await storage.InsertObject("Endpoint", Endpoint); await storage.InsertObject("PbxFolder", PbxFolder); await storage.InsertObject("SyncStarred", SyncStarred); await storage.InsertObject("MinimizeToTray", MinimizeToTray); await storage.InsertObject("StartWithWindows", StartWithWindows); await storage.InsertObject("ReformatXml", ReformatXml); await storage.InsertObject("XmlFile", XmlFile); await storage.InsertObject("DownloadOnStartup", DownloadOnStartup); await storage.InsertObject("PatchTableScripts", PatchTableScripts); await storage.InsertObject("DownloadOrientation", DownloadOrientation); await storage.InsertObject("DownloadOrientationFallback", DownloadOrientationFallback); await storage.InsertObject("DownloadLighting", DownloadLighting); await storage.InsertObject("DownloadLightingFallback", DownloadLightingFallback); await storage.InsertObject("IsFirstRun", false); IsFirstRun = false; }
public IObservable<CacheIndex> Save(IBlobCache cache, DateTimeOffset? absoluteExpiration = null) { return cache.InsertObject(IndexKey, this, absoluteExpiration) .Select(x => this); }
public async Task WriteInternalToStorage(IBlobCache storage) { await storage.InsertObject("WindowPosition", WindowPosition); }
private static async Task Vacuum(IBlobCache x) { await x.Vacuum(); await x.InsertObject(vacuumKey, DateTime.UtcNow); }