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