public async Task <List <string> > GetAllFilesListAsync(StorageTargetType storageTargetType = StorageTargetType.Local, string targetPath = null)
{
var targetFolder = await getStorageFolderAsync(storageTargetType, targetPath);
var queryOptions = new QueryOptions(CommonFileQuery.DefaultQuery, new[] { "*" });
queryOptions.FolderDepth = FolderDepth.Deep;
var availableCachFiles = targetFolder.CreateFileQueryWithOptions(queryOptions);
var files = await availableCachFiles.GetFilesAsync();
return(files.Select(storageFile => storageFile.Name).ToList());
}
public async Task <bool> FileExistsAsync(string filename, StorageTargetType targetType, string targetPath = null)
{
try
{
var folder = await getStorageFolderAsync(targetType, targetPath);
return(File.Exists(Path.Combine(folder.Path, filename)));
}
catch (FileNotFoundException)
{
return(false);
}
catch (Exception)
{
return(false);
}
}
public async Task <bool> DeleteFromStorageAsync(string fileName, StorageTargetType storageTargetType = StorageTargetType.Local, string targetPath = null)
{
try
{
var targetFolder = await getStorageFolderAsync(storageTargetType, targetPath);
var file = await targetFolder.GetFileAsync(fileName);
await file.DeleteAsync();
return(true);
}
catch
{
Debug.WriteLine("LocalStorageService.cs | DeleteFromStorageAsync | Could not delete file: {0}", fileName);
return(false);
}
}
public async Task <string> ReadStringFromStorageAsync(string fileName, StorageTargetType storageTargetType = StorageTargetType.Local, string targetPath = null)
{
try
{
var targetFolder = await getStorageFolderAsync(storageTargetType, targetPath);
var file = await targetFolder.GetFileAsync(fileName).AsTask().ConfigureAwait(false);
if (file != null)
{
var data = await FileIO.ReadTextAsync(file).AsTask().ConfigureAwait(false);
return(data);
}
}
catch
{
Debug.WriteLine("LocalStorageService.cs | ReadStringFromStorageAsync | Error reading file {0}", fileName);
}
return(null);
}
private async Task <StorageFolder> getStorageFolderAsync(StorageTargetType targetType, string targetPath)
{
var targetFolder = ApplicationData.Current.LocalFolder;
try
{
switch (targetType)
{
case StorageTargetType.Roaming:
targetFolder = ApplicationData.Current.RoamingFolder;
break;
case StorageTargetType.Temp:
targetFolder = ApplicationData.Current.TemporaryFolder;
break;
}
if (targetPath.IsNeitherNullNorEmpty())
{
var splittedPath = targetPath.Split(new[] { '/', '\\' }, StringSplitOptions.RemoveEmptyEntries);
foreach (var folderName in splittedPath)
{
targetFolder = await targetFolder.CreateFolderAsync(folderName, CreationCollisionOption.OpenIfExists);
}
}
}
catch (Exception ex)
{
Debug.WriteLine("LocalStorageService.cs | getStorageFolderAsync | Error getting / creating folder in {0} for path {1}", targetType, targetPath);
// as the PathTooLongException is not public...
if (ex.HResult == -2147024690)
{
Debug.WriteLine("LocalStorageService.cs | getStorageFolderAsync | Path was to long");
}
throw;
}
return(targetFolder);
}
public async Task <Stream> ReadStreamFromStorageAsync(string fileName, StorageTargetType storageTargetType = StorageTargetType.Local, string targetPath = null)
{
try
{
var targetFolder = await getStorageFolderAsync(storageTargetType, targetPath);
var file = await targetFolder.GetFileAsync(fileName).AsTask().ConfigureAwait(false);
if (file != null)
{
var randomAccessStream = await file.OpenAsync(FileAccessMode.ReadWrite);
return(randomAccessStream.AsStream());
}
}
catch
{
Debug.WriteLine("LocalStorageService.cs | ReadStringFromStorageAsync | Error reading file {0}", fileName);
}
return(null);
}
public async Task <byte[]> ReadBytesFromStorageAsync(string fileName, StorageTargetType storageTargetType = StorageTargetType.Local, string targetPath = null)
{
try
{
var targetFolder = await getStorageFolderAsync(storageTargetType, targetPath);
var file = await targetFolder.GetFileAsync(fileName);
byte[] data;
using (var s = await file.OpenStreamForReadAsync())
{
data = new byte[s.Length];
await s.ReadAsync(data, 0, (int)s.Length);
}
return(data);
}
catch
{
Debug.WriteLine("LocalStorageService.cs | ReadBytesFromStorageAsync | Error reading file {0}", fileName);
}
return(null);
}
public async Task <bool> WriteStreamToStorageAsync(string fileName, Stream streamToWrite, StorageTargetType storageTargetType = StorageTargetType.Local, string targetPath = null)
{
try
{
var targetFolder = await getStorageFolderAsync(storageTargetType, targetPath);
var file = await targetFolder.CreateFileAsync(fileName, CreationCollisionOption.ReplaceExisting);
using (var outStream = await file.OpenStreamForWriteAsync())
{
await streamToWrite.CopyToAsync(outStream);
await outStream.FlushAsync();
}
return(true);
}
catch
{
Debug.WriteLine("LocalStorageService.cs | WriteStreamToStorageAsync | Error saving {0} to storage", fileName);
return(false);
}
}
public async Task <bool> WriteStringToStorageAsync(string fileName, string stringToWrite, StorageTargetType storageTargetType = StorageTargetType.Local, string targetPath = null)
{
try
{
var targetFolder = await getStorageFolderAsync(storageTargetType, targetPath);
var file = await targetFolder.CreateFileAsync(fileName, CreationCollisionOption.ReplaceExisting);
await FileIO.WriteTextAsync(file, stringToWrite);
return(true);
}
catch
{
Debug.WriteLine("LocalStorageService.cs | WriteStringToStorageAsync | Error saving {0} to storage", fileName);
return(false);
}
}
public async Task <IPortableStorageFile> CreateOrOpenFileAsync(string fileName, StorageTargetType storageTargetType, string optionalFileContent = null, string targetPath = null)
{
var targetFolder = await getStorageFolderAsync(storageTargetType, targetPath);
var file = await targetFolder.CreateFileAsync(fileName, CreationCollisionOption.OpenIfExists);
if (optionalFileContent.IsNeitherNullNorEmpty())
{
await FileIO.WriteTextAsync(file, optionalFileContent);
}
return(file.AsPortableStorageFile());
}
public async Task <List <IPortableStorageFile> > GetFilesListSortByDateAsync(string query, StorageTargetType storageTargetType = StorageTargetType.Local, string targetPath = null, bool deep = false)
{
var targetFolder = await getStorageFolderAsync(storageTargetType, targetPath);
var queryOptions = new QueryOptions(CommonFileQuery.DefaultQuery, new[] { query });
queryOptions.SortOrder.Add(new SortEntry()
{
PropertyName = "System.DateModified"
});
if (deep)
{
queryOptions.FolderDepth = FolderDepth.Deep;
}
var availableCachFiles = targetFolder.CreateFileQueryWithOptions(queryOptions);
var files = await availableCachFiles.GetFilesAsync();
return(files.Select(storageFile => storageFile.AsPortableStorageFile()).ToList());
}
internal static ElasticSanVolumeGroupData DeserializeElasticSanVolumeGroupData(JsonElement element)
{
IDictionary <string, string> tags = default;
AzureLocation location = default;
ResourceIdentifier id = default;
string name = default;
ResourceType type = default;
SystemData systemData = default;
Optional <ProvisioningStates> provisioningState = default;
Optional <StorageTargetType> protocolType = default;
Optional <EncryptionType> encryption = default;
Optional <NetworkRuleSet> networkAcls = default;
foreach (var property in element.EnumerateObject())
{
if (property.NameEquals("tags"))
{
Dictionary <string, string> dictionary = new Dictionary <string, string>();
foreach (var property0 in property.Value.EnumerateObject())
{
dictionary.Add(property0.Name, property0.Value.GetString());
}
tags = dictionary;
continue;
}
if (property.NameEquals("location"))
{
location = property.Value.GetString();
continue;
}
if (property.NameEquals("id"))
{
id = new ResourceIdentifier(property.Value.GetString());
continue;
}
if (property.NameEquals("name"))
{
name = property.Value.GetString();
continue;
}
if (property.NameEquals("type"))
{
type = property.Value.GetString();
continue;
}
if (property.NameEquals("systemData"))
{
systemData = JsonSerializer.Deserialize <SystemData>(property.Value.ToString());
continue;
}
if (property.NameEquals("properties"))
{
if (property.Value.ValueKind == JsonValueKind.Null)
{
property.ThrowNonNullablePropertyIsNull();
continue;
}
foreach (var property0 in property.Value.EnumerateObject())
{
if (property0.NameEquals("provisioningState"))
{
if (property0.Value.ValueKind == JsonValueKind.Null)
{
property0.ThrowNonNullablePropertyIsNull();
continue;
}
provisioningState = new ProvisioningStates(property0.Value.GetString());
continue;
}
if (property0.NameEquals("protocolType"))
{
if (property0.Value.ValueKind == JsonValueKind.Null)
{
property0.ThrowNonNullablePropertyIsNull();
continue;
}
protocolType = new StorageTargetType(property0.Value.GetString());
continue;
}
if (property0.NameEquals("encryption"))
{
if (property0.Value.ValueKind == JsonValueKind.Null)
{
property0.ThrowNonNullablePropertyIsNull();
continue;
}
encryption = new EncryptionType(property0.Value.GetString());
continue;
}
if (property0.NameEquals("networkAcls"))
{
if (property0.Value.ValueKind == JsonValueKind.Null)
{
property0.ThrowNonNullablePropertyIsNull();
continue;
}
networkAcls = NetworkRuleSet.DeserializeNetworkRuleSet(property0.Value);
continue;
}
}
continue;
}
}
return(new ElasticSanVolumeGroupData(id, name, type, systemData, tags, location, Optional.ToNullable(provisioningState), Optional.ToNullable(protocolType), Optional.ToNullable(encryption), networkAcls.Value));
}
