public async Task SaveStream(string fileName, Stream stream) { var _lock = XNamedLock.Get(fileName); using (var releaser = await _lock.LockAsync()) { Debug.WriteLine("Writing file: {0}", fileName); try { var file = await Windows.Storage.ApplicationData.Current.LocalFolder.CreateFileAsync(fileName, CreationCollisionOption.ReplaceExisting); using (var s = await file.OpenStreamForWriteAsync()) { await stream.CopyToAsync(s); } } catch { throw; } } }
public async Task <TimeSpan?> GetAge <T>(string key) where T : class, new() { var locker = XNamedLock.Get(key + "3"); using (var locked = await locker.LockAsync()) { var fullName = _getFullKey <T>(key); var f = await _getMemory <T>(key); if (f == null) { f = await _storageFileRepo.Get <XCacheItem <T> >(fullName); if (f != null && f.Item != null) { _updateItem(f.Item, f); var cacheSet = await _setMemory(key, f.Item, null); _updateItem(cacheSet.Item, cacheSet); } } if (f == null) { return(null); } _updateItemCacheSource(f.Item, true); var ts = DateTime.UtcNow.Subtract(f.DateStamp); return(ts); } }
public async Task <bool> Copy(string source, string newName, bool replace = true) { var _lock = XNamedLock.Get(newName); using (var releaser = await _lock.LockAsync()) { var sFile = _getPath(source); var tFile = _getPath(newName); var r = Task.Run(() => File.Exists(sFile)); await r; if (!r.Result) { return(false); } var dir = Path.GetDirectoryName(tFile); if (dir != null && !Directory.Exists(dir)) { Directory.CreateDirectory(dir); } var r2 = Task.Run(() => File.Copy(sFile, tFile, replace)); await r2; return(true); } }
public async Task <bool> SaveString(string fileName, string data) { var _lock = XNamedLock.Get(fileName); using (var releaser = await _lock.LockAsync()) { try { var dataBytes = GetBytes(data); var file = await Windows.Storage.ApplicationData.Current.LocalFolder.CreateFileAsync(fileName, CreationCollisionOption.ReplaceExisting); using (var s = await file.OpenStreamForWriteAsync()) { await s.WriteAsync(dataBytes, 0, dataBytes.Length); } return(true); } catch { return(false); } } }
private async Task <T> _get(Guid id, Func <Task <T> > sourceTask, TimeSpan?maxAge) { var memory = _memoryCache.FirstOrDefault(_ => _.Id == id); if (memory != null) { return(memory); } using (var lRead = await XNamedLock.Get("entm_" + id).LockAsync()) { T cache = null; if (sourceTask != null) { cache = await _entityCache.GetEntity <T>(_getKey(id), sourceTask); } else { cache = await _entityCache.GetEntity <T>(_getKey(id)); } if (cache == null) { return(null); } var cResult = await Set(cache, maxAge); return(cResult); } }
public async Task Save(string fileName, byte[] data) { var _lock = XNamedLock.Get(fileName); using (var releaser = await _lock.LockAsync()) { var path = _getPath(fileName); _createDirForFile(path); File.WriteAllBytes(path, data); } }
public async Task <bool> SetEntity <T>(string key, T item, TimeSpan?maxAge) where T : class, new() { var locker = XNamedLock.Get(key + "setentity"); using (var locked = await locker.LockAsync()) { var fullName = _getFullKey <T>(key); var cacheEntity = await _setMemory(key, item, maxAge); _updateItem(cacheEntity.Item, cacheEntity); return(await _storageFileRepo.Set(cacheEntity, fullName)); } }
public async Task <bool> IsZero(string fileName) { var _lock = XNamedLock.Get(fileName); using (var releaser = await _lock.LockAsync()) { var file = await Windows.Storage.ApplicationData.Current.LocalFolder.GetFileAsync(fileName); using (var s = await file.OpenStreamForReadAsync()) { return(s.Length == 0); } } }
public async Task <bool> SaveString(string fileName, string data) { var _lock = XNamedLock.Get(fileName); using (var releaser = await _lock.LockAsync()) { var path = _getPath(fileName); _createDirForFile(path); var r = Task.Run(() => File.WriteAllText(path, data)); await r; return(true); } }
public async Task <bool> EnsureFolderExists(string folderPath) { var _lock = XNamedLock.Get(folderPath); using (var l = await _lock.LockAsync()) { var path = folderPath.Split('\\').ToList(); if (path.Count == 0) { return(false); } return(await _createFolder(path, Windows.Storage.ApplicationData.Current.LocalFolder)); } }
public async Task <System.IO.Stream> LoadStream(string fileName) { var _lock = XNamedLock.Get(fileName); using (var releaser = await _lock.LockAsync()) { var path = _getPath(fileName); if (!File.Exists(path)) { return(null); } var r = File.Open(path, FileMode.Open); return(r); } }
public async Task SaveStream(string fileName, System.IO.Stream stream) { var _lock = XNamedLock.Get(fileName); using (var releaser = await _lock.LockAsync()) { var path = _getPath(fileName); _createDirForFile(path); using (var s = File.Create(path)) { await stream.CopyToAsync(s); } } }
public async Task <T> GetEntity <T>(string key, Func <Task <T> > sourceTask, TimeSpan?maxAge = null, bool allowExpired = true, bool allowZeroList = true) where T : class, new() { var locker = XNamedLock.Get(key + "2");//this lock is to cover the gets var e = await GetEntity <T>(key); if (e != null) { if (!_emptyListFails(e, allowZeroList)) { return(e); } } T result = null; using (var l = await locker.LockAsync()) { //this checks to see if this entity was updated on another lock thread e = await GetEntity <T>(key); if (e != null) { if (!_emptyListFails(e, allowZeroList)) { return(e); } } result = await sourceTask(); if (result != null) { _updateItemCacheSource(result, false); await SetEntity <T>(key, result, maxAge); } } if (result == null && allowExpired) { return(await GetEntity <T>(key)); } return(result); }
public async Task <Stream> LoadStream(string fileName) { var _lock = XNamedLock.Get(fileName); using (var releaser = await _lock.LockAsync()) { var file = await Windows.Storage.ApplicationData.Current.LocalFolder.TryGetFileAsync(fileName); if (file == null) { return(null); } Debug.WriteLine("Reading file: {0}", fileName); return(await file.OpenStreamForReadAsync()); } }
public async Task <byte[]> Load(string fileName) { var _lock = XNamedLock.Get(fileName); using (var releaser = await _lock.LockAsync()) { var path = _getPath(fileName); if (!File.Exists(path)) { return(null); } var r = File.ReadAllBytes(path); return(r); } }
public async Task <string> LoadString(string fileName) { var _lock = XNamedLock.Get(fileName); using (var releaser = await _lock.LockAsync()) { var path = _getPath(fileName); if (!File.Exists(path)) { return(null); } var r = Task.Run(() => File.ReadAllText(path)); await r; return(r.Result); } }
public async Task <bool> DeleteFile(string fileName) { var _lock = XNamedLock.Get(fileName); using (var releaser = await _lock.LockAsync()) { var path = _getPath(fileName); var r = File.Exists(path); if (r) { File.Delete(path); } return(true); } }
public async Task <bool> DeleteFile(string fileName) { var _lock = XNamedLock.Get(fileName); using (var releaser = await _lock.LockAsync()) { var file = await Windows.Storage.ApplicationData.Current.LocalFolder.TryGetFileAsync(fileName); if (file != null) { await file.DeleteAsync(); return(true); } return(false); } }
public async Task <bool> DeleteFile(string fileName) { var _lock = XNamedLock.Get(fileName); using (var releaser = await _lock.LockAsync()) { var path = _getPath(fileName); var r = Task.Run(() => File.Exists(path)); await r; if (r.Result) { var r2 = Task.Run(() => File.Delete(path)); await r2; } return(true); } }
public async Task <List <T> > GetAll <T>() where T : class, new() { var path = _getDirPath <T>(); var locker = XNamedLock.Get(path + "getall"); using (var locked = await locker.LockAsync()) { var f = await _storageFileRepo.GetAll <XCacheItem <T> >(path, false); if (f == null) { return(null); } var result = new List <T>(); result.AddRange(f.Select(_ => _.Item)); return(result); } }
public async Task <bool> IsZero(string fileName) { var _lock = XNamedLock.Get(fileName); using (var releaser = await _lock.LockAsync()) { var path = _getPath(fileName); var r = Task.Run(() => File.Exists(path)); await r; if (!r.Result) { return(false); } var b = await Load(fileName); return(b.Length == 0); } }
public async Task <bool> ValidateAge <T>(string key) where T : class, new() { var locker = XNamedLock.Get(key + "3"); using (var locked = await locker.LockAsync()) { var fullName = _getFullKey <T>(key); var f = await _getMemory <T>(key); if (f == null) { f = await _storageFileRepo.Get <XCacheItem <T> >(fullName); if (f != null && f.Item != null) { if (!_validateAge(f)) { return(false); } _updateItem(f.Item, f); var cacheSet = await _setMemory(key, f.Item, null); _updateItem(cacheSet.Item, cacheSet); } } if (f == null) { return(false); } _updateItemCacheSource(f.Item, true); return(_validateAge(f)); } }
public async Task DeleteAll <T>() where T : class, new() { var path = _getDirPath <T>(); var locker = XNamedLock.Get(path + "getall"); using (var locked = await locker.LockAsync()) { var f = await _storageFileRepo.GetAll <XCacheItem <T> >(path, true); if (f == null) { return; } foreach (var item in f) { await Delete <T>(item.Key); } } }
public async Task <string> LoadString(string fileName) { var _lock = XNamedLock.Get(fileName); using (var releaser = await _lock.LockAsync()) { var file = await Windows.Storage.ApplicationData.Current.LocalFolder.TryGetFileAsync(fileName); if (file == null) { return(null); } using (var s = await file.OpenStreamForReadAsync()) { var data = new byte[s.Length]; await s.ReadAsync(data, 0, (int)s.Length); return(GetString(data)); } } }
public async Task Delete(T entity) { var e = await Get(entity.Id); if (e == null) { return; } using (var lRead = await XNamedLock.Get("entm_" + entity.Id).LockAsync()) { using (var lSave = await _saveLock.LockAsync()) { if (_memoryCache.Contains(e)) { _memoryCache.Remove(e); } await _entityCache.Delete <T>(_getKey(e.Id)); } } }
public async Task <bool> Copy(string source, string destinationFolder, string newName, bool replace = true) { var _lock = XNamedLock.Get(destinationFolder + "\\" + newName); using (var releaser = await _lock.LockAsync()) { var file = await Windows.Storage.ApplicationData.Current.LocalFolder.TryGetFileAsync(source); if (file == null) { return(false); } var dFolder = await Windows.Storage.ApplicationData.Current.LocalFolder.GetFolderAsync(destinationFolder); var result = await file.CopyAsync(dFolder, newName, replace?NameCollisionOption.ReplaceExisting : NameCollisionOption.FailIfExists); return(result != null); } }
public async Task Save(string fileName, byte[] data) { var _lock = XNamedLock.Get(fileName); using (var releaser = await _lock.LockAsync()) { Debug.WriteLine("Writing file: {0}", fileName); try { var file = await Windows.Storage.ApplicationData.Current.LocalFolder.CreateFileAsync(fileName, CreationCollisionOption.ReplaceExisting); using (var s = await file.OpenStreamForWriteAsync()) { await s.WriteAsync(data, 0, data.Length); } } catch { } } }
public async Task <T> GetEntity <T>(string key) where T : class, new() { var fullName = _getFullKey <T>(key); var f = await _getMemory <T>(key); if (f == null) { var locker = XNamedLock.Get(key + "3"); using (var locked = await locker.LockAsync()) { f = await _getMemory <T>(key); if (f == null) { Debug.WriteLine($"*** Entity cache miss: {fullName}"); f = await _storageFileRepo.Get <XCacheItem <T> >(fullName); if (f != null && f.Item != null) { Debug.WriteLine($" Found: {fullName}"); _updateItem(f.Item, f); if (!_validateAge(f)) { //delete it from storage await _storageFileRepo.Delete(fullName); return(null); } TimeSpan?toLiveFromNow = f.MaxAge != null ? f.DateStamp.Add(f.MaxAge.Value).Subtract(DateTime.UtcNow) : TimeSpan.FromDays(30); if (toLiveFromNow.Value.Milliseconds < 0) { //this item is in the past! //Top it up with another day. toLiveFromNow = TimeSpan.FromDays(1); } var cacheEntity = await _setMemory(key, f.Item, toLiveFromNow); _updateItem(cacheEntity.Item, cacheEntity); } } if (f == null) { Debug.WriteLine($" Not found: {fullName}"); return(null); } } } //else //{ // Debug.WriteLine($"Entity cache hit: {fullName}"); //} _updateItemCacheSource(f.Item, true); return(_validateAge(f) ? f.Item : null); }