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