private void DoSerializationWork(ProgressForm progressForm, DoWorkEventArgs e) { StorageSerializationInfo serializationInfo = e.Argument as StorageSerializationInfo; if (serializationInfo != null) { var remoteVaultSerializer = new StorageSerializer( serializationInfo.Model, serializationInfo.TabControl ); ISerializationCancellationToken canceller = new FormSerializationCancellationToken(progressForm); try { remoteVaultSerializer.SaveData( serializationInfo.OutputFolder, serializationInfo.SaveCurrentDatabase, serializationInfo.SaveHistoricDatabase, canceller ); } catch (OperationCanceledException ex) { log.Error("Exception at Concelled", ex); e.Cancel = true; } } }
/// <summary> /// Get value from cache /// </summary> /// <typeparam name="T"></typeparam> /// <param name="key"></param> /// <param name="serializerType">JSON or XML serializer</param> /// <returns></returns> public static async Task <T> GetFromCache <T>(string key, StorageSerializer serializerType = StorageSerializer.JSON) { IStorageHelper <CacheObject <T> > storage = new StorageHelper <CacheObject <T> >(_storageFolder, CacheFolder, serializerType); //Get cache value try { var value = await storage.LoadAsync(key).ConfigureAwait(false); if (value == null) { return(default(T)); } if (value.IsValid) { return(value.File); } //Delete old value //Do not await Delete(key, serializerType); } catch { //Restoring from cache might throw an error //Don't crash the app, return default value } return(default(T)); }
public async Task StorageHelperSaveOverwriteTest(StorageSerializer serializerType) { var myObject = new MyModel() { Name = "Michiel", Age = 29 }; IStorageHelper <MyModel> sh = new StorageHelper <MyModel>(Windows.Storage.ApplicationData.Current.LocalFolder, serializerType: serializerType); await sh.SaveAsync(myObject, "myfile"); var newObject = new MyModel() { Name = "Simon", Age = 0 }; //Save new object await sh.SaveAsync(newObject, "myfile"); var loadedObject = await sh.LoadAsync("myfile"); Assert.AreEqual(newObject.Name, loadedObject.Name); Assert.AreEqual(newObject.Age, loadedObject.Age); await sh.DeleteAsync("myfile"); }
public static async Task <DateTime> GetExpiryDate <T>(string key, StorageSerializer serializerType = StorageSerializer.JSON) { IStorageHelper <CacheObject <T> > storage = new StorageHelper <CacheObject <T> >(_storageFolder, CacheFolder, serializerType); //Get cache value try { var value = await storage.LoadAsync(key).ConfigureAwait(false); if (value == null) { return(DateTime.MinValue); } if (!value.IsValid) { return(DateTime.MinValue); } if (value.ExpireDateTime == null) { return(DateTime.MinValue); } return((DateTime)value.ExpireDateTime); } catch { } return(DateTime.MinValue); }
public StorageSerializer Save() { StorageSerializer ss = new StorageSerializer(); ss.standartResources = standartResources; return(ss); }
public UpdateViewCommand(MainViewModel mainViewModel, StorageSerializer storageSerializer, Counter counter, IEnumerable <Series> seriesCollection) { _mainViewModel = mainViewModel; _storageSerializer = storageSerializer; _counter = counter; _seriesCollection = seriesCollection; }
public async Task StorageHelperNotExistingTest(StorageSerializer serializerType) { IStorageHelper <MyModel> sh = new StorageHelper <MyModel>(StorageType.Local, serializerType: serializerType); var loadedObject = await sh.LoadAsync("myfile561616516"); Assert.IsNull(loadedObject); }
public async Task StorageHelperNotExistingTest(StorageSerializer serializerType) { IStorageHelper <MyModel> sh = new StorageHelper <MyModel>(Windows.Storage.ApplicationData.Current.LocalFolder, serializerType: serializerType); var loadedObject = await sh.LoadAsync("myfile561616516"); Assert.IsNull(loadedObject); }
public void Load(StorageSerializer ss) { standartResources = ss.standartResources; totalVolume = 0; for (int i = 0; i < standartResources.Length; i++) { totalVolume += standartResources[i]; } }
public MainViewModel(StorageSerializer storageSerializer) { var storage = storageSerializer.Load(); var seriesCollection = storage.SeriesCollection ?? new ObservableCollection <Series>(); var counter = new Counter(storage.Id ?? 0); var updateViewCommand = new UpdateViewCommand(this, storageSerializer, counter, seriesCollection); var content = new EntryListViewModel(seriesCollection); CurrentViewModel = new ShowEntryListViewModel(content, updateViewCommand); }
public async Task StorageHelperDeleteNotExistingTest(StorageSerializer serializerType) { IStorageHelper <MyModel> sh = new StorageHelper <MyModel>(StorageType.Local, serializerType: serializerType); //Delete non existing object await sh.DeleteAsync("myfile6526161651651"); var loadedObject = await sh.LoadAsync("myfile6526161651651"); Assert.IsNull(loadedObject); }
/// <summary> /// Set value in cache /// </summary> /// <typeparam name="T"></typeparam> /// <param name="key"></param> /// <param name="value"></param> /// <param name="expireDate"></param> /// <param name="serializerType">JSON or XML serializer</param> /// <returns></returns> public static Task Set <T>(string key, T value, DateTime?expireDate = null, StorageSerializer serializerType = StorageSerializer.JSON) { IStorageHelper <CacheObject <T> > storage = new StorageHelper <CacheObject <T> >(StorageType.Local, CacheFolder, serializerType); CacheObject <T> cacheFile = new CacheObject <T>() { File = value, ExpireDateTime = expireDate }; return(storage.SaveAsync(cacheFile, key)); }
/// <summary> /// Delete key from cache /// </summary> /// <param name="key"></param> /// <param name="serializerType">JSON or XML serializer</param> /// <returns></returns> public static Task Delete(string key, StorageSerializer serializerType = StorageSerializer.JSON) { try { IStorageHelper <object> storage = new StorageHelper <object>(_storageFolder, CacheFolder, serializerType); return(storage.DeleteAsync(key)); } catch { return(Task.CompletedTask); } }
public async Task StorageHelperSaveTest(StorageSerializer serializerType) { var myObject = new MyModel() { Name = "Michiel", Age = 29 }; IStorageHelper<MyModel> sh = new StorageHelper<MyModel>(StorageType.Local, serializerType: serializerType); await sh.SaveAsync(myObject, "myfile"); var loadedObject = await sh.LoadAsync("myfile"); Assert.AreEqual(myObject.Name, loadedObject.Name); Assert.AreEqual(myObject.Age, loadedObject.Age); await sh.DeleteAsync("myfile"); }
public async Task StorageHelperDeleteTest(StorageSerializer serializerType) { var myObject = new MyModel() { Name = "Michiel", Age = 29 }; IStorageHelper <MyModel> sh = new StorageHelper <MyModel>(Windows.Storage.ApplicationData.Current.LocalFolder, serializerType: serializerType); await sh.SaveAsync(myObject, "myfile"); //Delete saved object await sh.DeleteAsync("myfile"); var loadedObject = await sh.LoadAsync("myfile"); Assert.IsNull(loadedObject); }
public async Task StorageHelperSaveTest(StorageSerializer serializerType) { var myObject = new MyModel() { Name = "Michiel", Age = 29 }; IStorageHelper <MyModel> sh = new StorageHelper <MyModel>(StorageType.Local, serializerType: serializerType); await sh.SaveAsync(myObject, "myfile"); var loadedObject = await sh.LoadAsync("myfile"); Assert.AreEqual(myObject.Name, loadedObject.Name); Assert.AreEqual(myObject.Age, loadedObject.Age); await sh.DeleteAsync("myfile"); }
/// <summary> /// Clear expired cache files /// </summary> /// <returns></returns> public static async Task ClearInvalid(StorageSerializer serializerType = StorageSerializer.JSON) { var storage = new StorageHelper <CacheObject>(_storageFolder, CacheFolder, serializerType); var validExtension = storage.GetFileExtension(); var folder = await storage.GetFolderAsync().ConfigureAwait(false); var files = await folder.GetFilesAsync(); foreach (var file in files.Where(x => x.FileType == validExtension)) { var loadedFile = await storage.LoadAsync(file.DisplayName).ConfigureAwait(false); if (loadedFile != null && !loadedFile.IsValid) { await file.DeleteAsync(); } } }
public async Task StorageHelperSaveOverwriteTest(StorageSerializer serializerType) { var myObject = new MyModel() { Name = "Michiel", Age = 29 }; IStorageHelper<MyModel> sh = new StorageHelper<MyModel>(Windows.Storage.ApplicationData.Current.LocalFolder, serializerType: serializerType); await sh.SaveAsync(myObject, "myfile"); var newObject = new MyModel() { Name = "Simon", Age = 0 }; //Save new object await sh.SaveAsync(newObject, "myfile"); var loadedObject = await sh.LoadAsync("myfile"); Assert.AreEqual(newObject.Name, loadedObject.Name); Assert.AreEqual(newObject.Age, loadedObject.Age); await sh.DeleteAsync("myfile"); }
/// <summary> /// Get object based on key, or generate the value /// </summary> /// <typeparam name="T"></typeparam> /// <param name="key"></param> /// <param name="generate"></param> /// <param name="expireDate"></param> /// <param name="forceRefresh"></param> /// <param name="serializerType">JSON or XML serializer</param> /// <returns></returns> public static async Task <T> GetAsync <T>(string key, Func <Task <T> > generate, DateTime?expireDate = null, bool forceRefresh = false, StorageSerializer serializerType = StorageSerializer.JSON) { T value; //Force bypass of cache? if (!forceRefresh) { //Check cache value = await GetFromCache <T>(key, serializerType).ConfigureAwait(false); if (!EqualityComparer <T> .Default.Equals(value, default(T))) { return(value); } } value = await generate().ConfigureAwait(false); await Set(key, value, expireDate).ConfigureAwait(false); return(value); }
/// <summary> /// Get value from cache /// </summary> /// <typeparam name="T"></typeparam> /// <param name="key"></param> /// <param name="serializerType">JSON or XML serializer</param> /// <returns></returns> public async static Task <T> GetFromCache <T>(string key, StorageSerializer serializerType = StorageSerializer.JSON) { IStorageHelper <CacheObject <T> > storage = new StorageHelper <CacheObject <T> >(StorageType.Local, CacheFolder, serializerType); //Get cache value var value = await storage.LoadAsync(key).ConfigureAwait(false); if (value == null) { return(default(T)); } else if (value.IsValid) { return(value.File); } else { //Delete old value //Do not await Delete(key, serializerType); return(default(T)); } }
/// <summary> /// Constructor that takes a storageFolder as input /// </summary> /// <param name="storageFolder">For example: Windows.Storage.ApplicationData.Current.LocalFolder</param> /// <param name="subFolder"></param> /// <param name="serializerType"></param> public StorageHelper(StorageFolder storageFolder, string subFolder = null, StorageSerializer serializerType = StorageSerializer.JSON) { _storageFolder = storageFolder; _subFolder = subFolder; _serializerType = serializerType; }
private static string SerializeObject(object value) { return(Convert.ToBase64String(StorageSerializer.Serialize(value))); }
private static object DeSerializeObject(string value) { return(StorageSerializer.Deserialize(Convert.FromBase64String(value))); }
private void mnuOpenRaw_Click(object sender, EventArgs e) { var openDialog = new OpenFileDialog { Filter = @"MSD|*.msd|MSH|*.msh|MSR|*.msr", RestoreDirectory = true }; if (openDialog.ShowDialog() == DialogResult.OK) { ICryptoService cryptoService = this._model.CryptoService; List <ConnectionGroupInfo> storedConnections = StorageSerializer.GetStoredConnections(openDialog.FileName, cryptoService); if (storedConnections != null && !storedConnections.Any()) { return; } OpenConnectionDialog openConnectionDialog = new OpenConnectionDialog(); openConnectionDialog.SetStoredConnections(storedConnections); if (openConnectionDialog.ShowDialog() == DialogResult.OK) { ConnectionGroupInfo connectionGroup = storedConnections != null ? openConnectionDialog.SelectedConnectionGroup : new ConnectionGroupInfo() { Connections = new List <InstanceInfo>(), Name = Path.GetFileName(openDialog.FileName) }; foreach (InstanceInfo instanceInfo in connectionGroup.Connections) { instanceInfo.DbType = openConnectionDialog.DataBaseType.ToString(); } string inMsd = openDialog.FileName; string inMsh = StorageSerializer.GetMshFromMsd(inMsd); string inMsr = StorageSerializer.GetMsrFromMsd(inMsd); if (!StorageSerializer.IsMsdFile(inMsd)) { inMsd = null; } var vaultProcessor = StorageSerializer.GetReadonlyVaultProcessor( this._model, inMsd, inMsh, inMsr ); this._model.AssociateVaultProcessor(vaultProcessor, connectionGroup); var connectionTab = GetTargetTab(connectionGroup.Name + " "); connectionTab.OpenConnection(connectionGroup); } } }
public async Task StorageHelperNotExistingTest(StorageSerializer serializerType) { IStorageHelper<MyModel> sh = new StorageHelper<MyModel>(Windows.Storage.ApplicationData.Current.LocalFolder, serializerType: serializerType); var loadedObject = await sh.LoadAsync("myfile561616516"); Assert.IsNull(loadedObject); }
public async Task StorageHelperDeleteNotExistingTest(StorageSerializer serializerType) { IStorageHelper<MyModel> sh = new StorageHelper<MyModel>(StorageType.Local, serializerType: serializerType); //Delete non existing object await sh.DeleteAsync("myfile6526161651651"); var loadedObject = await sh.LoadAsync("myfile6526161651651"); Assert.IsNull(loadedObject); }
public async Task StorageHelperNotExistingTest(StorageSerializer serializerType) { IStorageHelper<MyModel> sh = new StorageHelper<MyModel>(StorageType.Local, serializerType: serializerType); var loadedObject = await sh.LoadAsync("myfile561616516"); Assert.IsNull(loadedObject); }
/// <summary> /// Delete key from cache /// </summary> /// <param name="key"></param> /// <param name="serializerType">JSON or XML serializer</param> /// <returns></returns> public static Task Delete(string key, StorageSerializer serializerType = StorageSerializer.JSON) { IStorageHelper <object> storage = new StorageHelper <object>(StorageType.Local, CacheFolder, serializerType); return(storage.DeleteAsync(key)); }
public async Task StorageHelperDeleteTest(StorageSerializer serializerType) { var myObject = new MyModel() { Name = "Michiel", Age = 29 }; IStorageHelper<MyModel> sh = new StorageHelper<MyModel>(StorageType.Local, serializerType: serializerType); await sh.SaveAsync(myObject, "myfile"); //Delete saved object await sh.DeleteAsync("myfile"); var loadedObject = await sh.LoadAsync("myfile"); Assert.IsNull(loadedObject); }
/// <summary> /// Get object based on key, or generate the value /// </summary> /// <typeparam name="T"></typeparam> /// <param name="key"></param> /// <param name="generate"></param> /// <param name="expireDate"></param> /// <param name="forceRefresh"></param> /// <param name="serializerType">JSON or XML serializer</param> /// <returns></returns> public async static Task <T> GetAsync <T>(string key, Func <Task <T> > generate, DateTime?expireDate = null, bool forceRefresh = false, StorageSerializer serializerType = StorageSerializer.JSON) { object value; //Force bypass of cache? if (!forceRefresh) { //Check cache value = await GetFromCache <T>(key, serializerType).ConfigureAwait(false); if (value != null) { return((T)value); } } value = await generate().ConfigureAwait(false); await Set(key, value, expireDate).ConfigureAwait(false); return((T)value); }