private static async Task<IFolder> _EnsureFolderExistsAsync(string name, IFolder parent)
{
if (parent == null) throw new ArgumentNullException("parent");
return
await
parent.CreateFolderAsync(name, CreationCollisionOption.OpenIfExists).ConfigureAwait(false);
}
public static async Task Copy(IFolder source, IFolder target)
{
foreach (IFolder f in await source.GetFoldersAsync())
{
if (f.Name.StartsWith("."))
{
continue;
}
await Copy(f, await target.CreateFolderAsync(f.Name, CreationCollisionOption.GenerateUniqueName).ConfigureAwait(false)).ConfigureAwait(false);
}
foreach (IFile f in await source.GetFilesAsync())
{
if (f.Name.StartsWith("."))
{
continue;
}
await Copy(f, await target.CreateFileAsync(f.Name, CreationCollisionOption.GenerateUniqueName).ConfigureAwait(false)).ConfigureAwait(false);
}
}
/// <summary>
/// Leia um arquivo local com base no full path.
/// </summary>
/// <returns>Data stream do arquivo</returns>
/// <param name="nomeDoArquivo">nome do arquivo com extensao e full path.</param>
public Stream LerArquivo(string nomeDoArquivo)
{
if (nomeDoArquivo == null)
{
return(null);
}
IFolder rootFolder = FileSystem.Current.LocalStorage;
IFolder folder = rootFolder.CreateFolderAsync("smartpromoterfiles",
CreationCollisionOption.OpenIfExists).Result;
var checkResult = folder.CheckExistsAsync(nomeDoArquivo).Result;
if (checkResult == ExistenceCheckResult.FileExists)
{
IFile file = folder.GetFileAsync(nomeDoArquivo).Result;
var result = file.OpenAsync(FileAccess.Read).Result;
return(result);
}
return(null);
}
public async static Task <Stream> ReadFromFile(string folder, string fileName)
{
Stream ret = null;
try
{
IFolder rootFolder = FileSystem.Current.LocalStorage;
IFolder fld = await rootFolder.CreateFolderAsync(folder, CreationCollisionOption.OpenIfExists);
IFile file = await fld.GetFileAsync(fileName);
ret = await file.OpenAsync(FileAccess.Read);
}
catch (Exception)
{
}
return(ret);
}
public async Task CreateNestedFolder()
{
// Arrange
IFolder rootFolder = TestFileSystem.LocalStorage;
string subFolderName = "NestedSubFolder";
IFolder subFolder = await rootFolder.CreateFolderAsync(subFolderName, CreationCollisionOption.FailIfExists);
string leafFolderName = "NestedLeafFolder";
// Act
IFolder testFolder = await subFolder.CreateFolderAsync(leafFolderName, CreationCollisionOption.FailIfExists);
// Assert
Assert.AreEqual(leafFolderName, testFolder.Name);
Assert.AreEqual(PortablePath.Combine(rootFolder.Path, subFolderName, leafFolderName), testFolder.Path, "Leaf folder path");
// Cleanup
await subFolder.DeleteAsync();
}
public async void ShareReport()
{
IFileSystem fileSystem = FileSystem.Current;
IFolder rootFolder = fileSystem.LocalStorage;
IFolder reportsFolder = await rootFolder.CreateFolderAsync("reports", CreationCollisionOption.OpenIfExists);
var txtFile = await reportsFolder.CreateFileAsync("report.txt", CreationCollisionOption.ReplaceExisting);
using (StreamWriter sw = new StreamWriter(txtFile.Path))
{
foreach (var ce in CategoryExpensesCollection)
{
sw.WriteLine($"{ce.Category} - {ce.ExpensesPercentage}");
}
}
var shareDependency = DependencyService.Get <IShare>();
await shareDependency.Show("Expense Report", "Here is your expenses report", txtFile.Path);
}
public MainPageViewModel()
{
登入Command = new DelegateCommand(async() =>
{
if (使用這登入資訊紀錄.記憶密碼 == true)
{
string fooStr = JsonConvert.SerializeObject(使用這登入資訊紀錄);
// 取得這個應用程式的所在目錄
IFolder rootFolder = FileSystem.Current.LocalStorage;
// 產生要儲存資料的資料夾
IFolder sourceFolder = await rootFolder.CreateFolderAsync("MyDatas", CreationCollisionOption.ReplaceExisting);
// 建立要儲存資料的檔案
IFile sourceFile = await sourceFolder.CreateFileAsync("使用這登入資訊紀錄.dat", CreationCollisionOption.ReplaceExisting);
await sourceFile.WriteAllTextAsync(fooStr);
}
});
}
/*--- Method: protected ---------------------------------------------------------------------------------------------------------------------------------------*/
/// <summary> DBファイル生成を実行します。
/// </summary>
/// <param name="pDbFolderPath"> カレントフォルダからDBフォルダへのパス </param>
/// <param name="pDbFileName"> DBファイルの名称 </param>
/// <returns> 操作結果 </returns>
protected virtual async Task <List <SQLiteOperationLog> > CreateDbFileAsync(string pDbFolderPath, string pDbFileName)
{
List <SQLiteOperationLog> results = new List <SQLiteOperationLog>();
// パラメータチェック
if (string.IsNullOrEmpty(pDbFileName))
{
results.Add(this.CreateLog(SQLiteOperationResult.Failure, "<Param Error> DbFileName Empty."));
// Todo: SQLite => 続行が危険な気がするから、ここ例外投げちゃおうかな…
}
else
{
// ルートフォルダを取得する
IFolder rootFolder = FileSystem.Current.LocalStorage;
// フォルダチェック
if (!string.IsNullOrWhiteSpace(pDbFolderPath) && await rootFolder.CheckExistsAsync(pDbFolderPath) == ExistenceCheckResult.NotFound)
{
await rootFolder.CreateFolderAsync(pDbFolderPath, CreationCollisionOption.FailIfExists);
results.Add(await this.CreateLogAsync(SQLiteOperationResult.Success, string.Format("Create New Folder Success. => {0}", Path.Combine(rootFolder.Path, pDbFolderPath))));
}
// DBファイル存在チェック
var dbFullPath = Path.Combine(pDbFolderPath, pDbFileName);
if (await rootFolder.CheckExistsAsync(dbFullPath) == ExistenceCheckResult.NotFound)
{
// 存在しなかった場合、新たにDBファイルを作成
this.DbFile = await rootFolder.CreateFileAsync(dbFullPath, CreationCollisionOption.ReplaceExisting);
results.Add(await this.CreateLogAsync(SQLiteOperationResult.Success, string.Format("Create New {0} Success. => {1}", pDbFileName, Path.Combine(rootFolder.Path, dbFullPath))));
}
else
{
// 存在した場合、ファイルオープン
this.DbFile = await rootFolder.CreateFileAsync(dbFullPath, CreationCollisionOption.OpenIfExists);
results.Add(await this.CreateLogAsync(SQLiteOperationResult.Success, string.Format("{0} Open Success. => {1}", pDbFileName, Path.Combine(rootFolder.Path, dbFullPath))));
}
}
return(results);
}
/// <summary>
/// 將所指定的字串寫入到指定目錄的檔案內
/// </summary>
/// <param name="folderName">目錄名稱</param>
/// <param name="filename">檔案名稱</param>
/// <param name="content">所要寫入的文字內容</param>
/// <returns></returns>
public static async Task WriteToDataFileAsync(string folderPath, string folderName, string filename, string content)
{
IFolder rootFolder = FileSystem.Current.LocalStorage;
if (string.IsNullOrEmpty(folderName))
{
throw new ArgumentNullException("folderName");
}
if (string.IsNullOrEmpty(filename))
{
throw new ArgumentNullException("filename");
}
if (string.IsNullOrEmpty(content))
{
throw new ArgumentNullException("content");
}
#region 建立與取得指定路徑內的資料夾
try
{
string[] fooPaths = folderName.Split(new string[] { "/" }, StringSplitOptions.RemoveEmptyEntries);
IFolder folder = rootFolder;
foreach (var item in fooPaths)
{
folder = await folder.CreateFolderAsync(item, CreationCollisionOption.OpenIfExists);
}
IFile file = await folder.CreateFileAsync(filename, CreationCollisionOption.ReplaceExisting);
#endregion
await file.WriteAllTextAsync(content);
}
catch (Exception ex)
{
Debug.WriteLine(ex.ToString());
}
finally
{
}
}
private async void CreateFolderStructure()
{
try
{
IFolder rootFolder = await FileSystem.Current.GetFolderFromPathAsync(System.IO.Path.Combine(Android.OS.Environment.ExternalStorageDirectory.Path));
var subpaths = new[] { "Android", "data", "com.Ministerio.AudioApp", "files" };
foreach (var dir in subpaths)
{
if (!string.IsNullOrEmpty(dir))
{
rootFolder = await rootFolder.CreateFolderAsync(dir, CreationCollisionOption.OpenIfExists);
}
}
}
catch (Exception e)
{
Console.WriteLine("Failed to log! " + e.Message);
}
}
private async void loadSavedLoginData()
{
// get hold of the file system
IFolder rootFolder = FileSystem.Current.LocalStorage;
// create a folder, if one does not exist already
IFolder folder = await rootFolder.CreateFolderAsync("Folder", CreationCollisionOption.OpenIfExists);
// create a file, overwriting any existing file
IFile file = await folder.CreateFileAsync("Account.txt", CreationCollisionOption.OpenIfExists);
var text = await file.ReadAllTextAsync();
var splitData = text.Split(new string[] { "," }, StringSplitOptions.None);
if (splitData.Length == 2)
{
Username = splitData[0];
Password = splitData[1];
}
}
public static async Task <RankingData> LoadAsync()
{
var json = "";
IFolder rootFolder = FileSystem.Current.LocalStorage;
var folder = await rootFolder.CreateFolderAsync("Ranking", CreationCollisionOption.OpenIfExists);
var exists = await folder.CheckExistsAsync("ranking.drf");
if (exists == (ExistenceCheckResult.NotFound))
{
return(RankingData.Zero());
}
else if (exists == (ExistenceCheckResult.FileExists))
{
var file = await folder.GetFileAsync("ranking.drf");
json = await file.ReadAllTextAsync();
}
return(Newtonsoft.Json.JsonConvert.DeserializeObject <RankingData>(json));
}
/// <summary>
/// Get names of all log files
/// </summary>
public static async Task <List <string> > GetLogs()
{
var rv = new List <string>();
try
{
IFolder rootFolder = FileSystem.Current.LocalStorage;
IFolder folder = await rootFolder.CreateFolderAsync("data",
CreationCollisionOption.OpenIfExists);
var files = await folder.GetFilesAsync();
foreach (var file in files)
{
rv.Add(file.Name);
}
}
catch { }
return(rv);
}
private async void Delete_MenuItem_Clicked(object sender, EventArgs e)
{
var menuItem = sender as MenuItem;
if (menuItem != null)
{
var survey = menuItem.BindingContext as Survey;
var result = await DisplayAlert(Lang.Resource.deleting, Lang.Resource.detailsMessageDeleteSurvey + survey.Title_Property + Lang.Resource.survey, Lang.Resource.btnCancelMessage, Lang.Resource.btnOkMessage);
if (result)
{
return;
}
if (CheckNetwork.Check_Connectivity())
{
SurveysServices S_S = new SurveysServices();
S_S.Set_UrlApi("DeleteSurvey/" + survey.Id + "/" + survey.User);
await S_S.DeleteSurveysAsync();
folder = FileSystem.Current.LocalStorage;
folder = await folder.CreateFolderAsync("foldersurveys" + username, CreationCollisionOption.OpenIfExists);
file = await folder.CreateFileAsync("filesurveys" + username, CreationCollisionOption.OpenIfExists);
string content = await file.ReadAllTextAsync();
ListSurveys = Serializable_Survey.deserialize(content).ToList();
for (int i = 0; i < ListSurveys.Count; i++)
{
if (ListSurveys[i].Id == survey.Id)
{
ListSurveys.RemoveAt(i);
}
}
content = Serializable_Survey.serialize(ListSurveys);
await file.WriteAllTextAsync(content);
Full_Lists_Surveys();
}
}
}
private async void HandleConnectivityChanged(object sender, ConnectivityChangedEventArgs e)
{
if (e.IsConnected)
{
string Content;
// Post Responsed Surveys
folder = FileSystem.Current.LocalStorage;
List <Survey> surveys = new List <Survey>();
ExistenceCheckResult result = await folder.CheckExistsAsync("ShareResponsedSurveys");
if (result == ExistenceCheckResult.FolderExists)
{
folder = await folder.CreateFolderAsync("ShareResponsedSurveys", CreationCollisionOption.OpenIfExists);
file = await folder.CreateFileAsync("ShareResponsedSurveys", CreationCollisionOption.OpenIfExists);
Content = await file.ReadAllTextAsync();
if (String.IsNullOrEmpty(Content) || String.IsNullOrWhiteSpace(Content))
{
return;
}
surveys = Serializable_Survey.deserialize(Content).ToList();
foreach (Survey S in surveys)
{
SurveysServices S_S = new SurveysServices();
S_S.Set_UrlApi("ShareResponsedSurveys/");
await S_S.PostSurveysAsync(S);
}
folder = FileSystem.Current.LocalStorage;
folder = await folder.GetFolderAsync("ShareResponsedSurveys");
await folder.DeleteAsync();
}
// Receive Surveys
ReceiveSurveys();
// Receive Responsed Surveys
ReceiveResponsedSurveys();
}
}
public async Task WriteAllTextOverwritesExistingContents()
{
// Arrange
IFolder rootFolder = TestFileSystem.LocalStorage;
IFolder testFolder = await rootFolder.CreateFolderAsync("WriteAllTextFolder", CreationCollisionOption.FailIfExists);
IFile testFile = await testFolder.CreateFileAsync("testfile.txt", CreationCollisionOption.FailIfExists);
await testFile.WriteAllTextAsync("A man a plan a canal panama!");
// Act
await testFile.WriteAllTextAsync("42");
// Assert
string contents = await testFile.ReadAllTextAsync();
Assert.AreEqual("42", contents);
// Cleanup
await testFolder.DeleteAsync();
}
/// <summary>
/// Saving Values to the Storage...
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="Key"></param>
/// <param name="ValueToSave"></param>
/// <returns></returns>
public async Task Save_Value(String filename, Set1 set1)
{
XDocument doc = new XDocument();
using (var writer = doc.CreateWriter())
{
var serializer = new XmlSerializer(typeof(Set1));
serializer.Serialize(writer, set1);
}
//get the folder name and path
IFolder rootFolder = FileSystem.Current.LocalStorage;
// create a new subfolder in the local folder
IFolder folder = await rootFolder.CreateFolderAsync("Set1",
CreationCollisionOption.OpenIfExists);
//create a file
IFile file = await folder.CreateFileAsync(filename,
CreationCollisionOption.ReplaceExisting);
await file.WriteAllTextAsync(doc.ToString());
}
private async void GetUsers()
{
Users = await R_S.GetRegistersAsync();
folder = FileSystem.Current.LocalStorage;
folder = await folder.CreateFolderAsync("folderUser", CreationCollisionOption.OpenIfExists);
file = await folder.CreateFileAsync("fileUser", CreationCollisionOption.OpenIfExists);
string AccountUser = await file.ReadAllTextAsync();
User register = Serializable_Account.deserialize(AccountUser).ElementAt(0);
Users = Users.Where(user => user.Email != register.Email).ToList();
ListUsers.ItemsSource = Users;
await Task.Delay(400);
ActivityIndicator.IsRunning = false;
contentpage.IsVisible = true;
}
private PwDatabase CreateTestDatabase(
out IOConnectionInfo ci,
out CompositeKey key,
out IFile file)
{
IFolder folder = SpecialFolder.Current.Local;
IFolder testData = folder.CreateFolderAsync("TestData",
CreationCollisionOption.OpenIfExists).Result;
file = testData.CreateFileAsync("1.kdbx",
CreationCollisionOption.ReplaceExisting).Result;
ci = new IOConnectionInfo();
ci.Path = file.Path;
key = new CompositeKey();
key.AddUserKey(new KcpPassword("0"));
var db = new PwDatabase();
db.New(ci, key);
return(db);
}
public async Task CreateFileSubFolder()
{
// Arrange
IFolder folder = TestFileSystem.LocalStorage;
string subFolderName = nameof(CreateFileSubFolder);
IFolder subFolder = await folder.CreateFolderAsync(subFolderName, CreationCollisionOption.FailIfExists);
string fileName = "fileToCreateInSubFolder.txt";
// Act
IFile file = await subFolder.CreateFileAsync(fileName, CreationCollisionOption.FailIfExists);
// Assert
Assert.AreEqual(fileName, file.Name);
Assert.AreEqual(Path.Combine(folder.Path, subFolderName, fileName), file.Path, "File Path");
// Cleanup
await file.DeleteAsync();
await subFolder.DeleteAsync();
}
/// <summary>
/// Gravar um arquivo no diretorio local.
/// </summary>
/// <returns>full path com extensao do arquivo inserido localmente</returns>
/// <param name="arquivo">Data stream do arquivo.</param>
/// <param name="nomeDoArquivo">Nome do arquivo com extensao.</param>
public string GravarArquivo(Stream arquivo, string nomeDoArquivo)
{
try
{
IFolder rootFolder = FileSystem.Current.LocalStorage;
IFolder folder = rootFolder.CreateFolderAsync("smartpromoterfiles",
CreationCollisionOption.OpenIfExists).Result;
IFile file = folder.CreateFileAsync(nomeDoArquivo,
CreationCollisionOption.ReplaceExisting).Result;
using (Stream stream = file.OpenAsync(FileAccess.ReadAndWrite).Result)
{
arquivo.Seek(0, SeekOrigin.Begin);
arquivo.CopyTo(stream);
}
return(file.Name);
}
catch (Exception)
{
return(null);
}
}
/// <summary>
/// Reads all schemas.
/// </summary>
/// <returns>The all schemas.</returns>
public static List <Survey> ReadAllSchemas()
{
IFolder rootFolder = FileSystem.Current.LocalStorage;
var folderTask = rootFolder.CreateFolderAsync(Constants.schemasFolder, CreationCollisionOption.OpenIfExists);
IFolder folder = folderTask.Result;
var filesTask = folder.GetFilesAsync();
IList <IFile> files = filesTask.Result;
List <Survey> surveys = new List <Survey> ();
foreach (IFile f in files)
{
var fileContentTaks = f.ReadAllTextAsync();
string fileContent = fileContentTaks.Result;
Survey s = JSonTranslator.Deserialize <Survey> (fileContent);
surveys.Add(s);
}
;
return(surveys);
}
public override async Task Load()
{
await base.Load();
if (_playDataPath == null)
{
return;
}
IFolder rootFolder = FileSystem.Current.LocalStorage;
var folder = await rootFolder.CreateFolderAsync("PlayData", CreationCollisionOption.OpenIfExists);
var file = await folder.GetFileAsync(_playDataPath);
string json = await file.ReadAllTextAsync();
json = Encode.Deflate.Decode(json);
_playData = Newtonsoft.Json.JsonConvert.DeserializeObject <PlayData>(json);
}
public async Task <string> GetUserName()
{
User register = null;
try
{
folder = FileSystem.Current.LocalStorage;
folder = await folder.CreateFolderAsync("folderUser", CreationCollisionOption.OpenIfExists);
file = await folder.CreateFileAsync("fileUser", CreationCollisionOption.OpenIfExists);
string AccountUser = await file.ReadAllTextAsync();
register = Serializable_Account.deserialize(AccountUser).ElementAt(0);
}
catch (Exception ex)
{
DependencyService.Get <SnackBar>().ShowSnackBar("Error ... cann't access to device storage");
}
return(register.UserName);
}
/// <summary>
/// save image from local. (wait)
/// </summary>
/// <param name="item"></param>
/// <returns></returns>
private static async Task saveImageByteToLocal(string fileName, string containerName, byte[] buffer)
{
///// 1. get image from local. (wait)
// Access the file system for the current platform.
IFileSystem fileSystem = FileSystem.Current;
// Get the root directory of the file system for our application.
IFolder rootFolder = fileSystem.LocalStorage;
// Create another folder, if one doesn't already exist.
IFolder photosFolder = await rootFolder.CreateFolderAsync(containerName, CreationCollisionOption.OpenIfExists);
// Get File
IFile file = await photosFolder.CreateFileAsync(fileName, CreationCollisionOption.ReplaceExisting);
if (file != null)
{
using (System.IO.Stream stream = await file.OpenAsync(PCLStorage.FileAccess.ReadAndWrite))
{
await stream.WriteAsync(buffer, 0, buffer.Length);
}
}
}
private static async Task <IFile> GetFile(IFolder target, string path)
{
if (path == null || path == "" || path.StartsWith(".") || path.EndsWith("/"))
{
return(null);
}
int i = path.IndexOf('/');
if (i >= 0)
{
string folder = path.Substring(0, i);
if (folder != "" && !folder.StartsWith(".") && !folder.StartsWith("/"))
{
return(await GetFile(await target.CreateFolderAsync(folder, CreationCollisionOption.OpenIfExists), path.Substring(i + 1)));
}
return(null);
}
else
{
return(await target.CreateFileAsync(path, CreationCollisionOption.GenerateUniqueName));
}
}
async Task DownloadLocalStorage()
{
IFolder rootFolder = FileSystem.Current.LocalStorage;
Debug.WriteLine($"Root Flder name :{rootFolder.Name}");
Debug.WriteLine($"Root Flder path :{rootFolder.Path}");
IFolder folder = await rootFolder.CreateFolderAsync("temp", CreationCollisionOption.OpenIfExists);
Debug.WriteLine($"MySubFolder Flder name :{folder.Name}");
Debug.WriteLine($"MySubFolder Flder path :{folder.Path}");
var filename = "zd861_5.jpg";
var rrr = await folder.CheckExistsAsync(filename);
if (rrr == ExistenceCheckResult.FileExists)
{
Debug.WriteLine($"{filename} is exists");
}
if (rrr == ExistenceCheckResult.NotFound)
{
Debug.WriteLine($"{filename} is not fount");
}
IFile file = await folder.CreateFileAsync(filename, CreationCollisionOption.ReplaceExisting);
var client = new HttpClient();
using (var jpg = await client.GetStreamAsync("http://img31.otofotki.pl/obrazki/zd861_5.jpg"))
{
// populate the file with some text
using (var filestream = await file.OpenAsync(FileAccess.ReadAndWrite))
{
jpg.CopyTo(filestream);
image.Source = file.Path;
activityIndicator.IsRunning = false;
}
}
}
private async Task <FileTransReq> SetupTransmitionForNewFile(FileMeta fileDetails, int bufferSize)
{
//create a folder to store the file
IFolder root = await fileSystem.GetFolderFromPathAsync("./");
if (await root.CheckExistsAsync(DefaultFilePath) == ExistenceCheckResult.NotFound)
{
//create folder
await root.CreateFolderAsync(DefaultFilePath, CreationCollisionOption.FailIfExists);
}
IFolder tempFolder = await fileSystem.GetFolderFromPathAsync(DefaultFilePath);
//create empty file stream
IFile newFile = await tempFolder.CreateFileAsync(fileDetails.FileName, CreationCollisionOption.ReplaceExisting);
Stream fileStream = await newFile.OpenAsync(PCLStorage.FileAccess.ReadAndWrite);
//return file trans. object
FileTransReq fileTrans = new FileTransReq(fileDetails, fileStream, bufferSize);
return(fileTrans);
}
public void Open_With_Wrong_Password_Test()
{
IFolder folder = SpecialFolder.Current.Local;
IFolder testData = folder.CreateFolderAsync("TestData",
CreationCollisionOption.OpenIfExists).Result;
IFile file = testData.CreateFileAsync("1.kdbx",
CreationCollisionOption.ReplaceExisting).Result;
var fileStream = file.OpenAsync(PCLStorage.FileAccess.ReadAndWrite).Result;
var assembly = typeof(PwDatabaseTests).GetTypeInfo().Assembly;
var stream = assembly.GetManifestResourceStream(
"KeePass2PCL.Test.UWP.TestData.1.kdbx");
using (var reader = new BinaryReader(stream))
using (var fileWriter = new BinaryWriter(fileStream))
{
fileWriter.Write(reader.ReadBytes((int)stream.Length));
}
var ci = new IOConnectionInfo();
ci.Path = file.Path;
var key = new CompositeKey();
key.AddUserKey(new KcpPassword("0"));
var db = new PwDatabase();
bool wasException = false;
try
{
db.Open(ci, key, null);
}
catch (InvalidCompositeKeyException)
{
wasException = true;
}
Assert.IsTrue(wasException);
file.DeleteAsync().Wait();
testData.DeleteAsync().Wait();
}
public async Task NestedFolderWithSameName()
{
// Arrange
IFolder rootFolder = TestFileSystem.LocalStorage;
string folderName = "NestedFolderName";
IFolder level1 = await rootFolder.CreateFolderAsync(folderName, CreationCollisionOption.FailIfExists);
// Act
IFolder level2 = await level1.CreateFolderAsync(folderName, CreationCollisionOption.FailIfExists);
// Assert
Assert.AreEqual(Path.Combine(rootFolder.Path, folderName, folderName), level2.Path);
IList <IFolder> level1Folders = await level1.GetFoldersAsync();
IList <IFolder> level2Folders = await level2.GetFoldersAsync();
Assert.AreEqual(1, level1Folders.Count, "Level 1 folder count");
Assert.AreEqual(0, level2Folders.Count, "Level 2 folder count");
// Cleanup
await level1.DeleteAsync();
}
public static async Task <bool> DeleteFileInFolder(string folderName, string filename)
{
bool result = true;
try {
IFolder localFolder = FileSystem.Current.LocalStorage;
localFolder = await localFolder.CreateFolderAsync(folderName, CreationCollisionOption.OpenIfExists);
IFile localFileToDelete = await localFolder.GetFileAsync(filename);
if (localFileToDelete != null)
{
await localFileToDelete.DeleteAsync();
}
}
catch (Exception e) {
result = false;
Debug.WriteLine(e.StackTrace);
}
return(result);
}
private static async Task<IFolder> _EnsureFolderExistsAsync(string name, IFolder parent)
{
if (parent == null) throw new ArgumentNullException(nameof(parent));
return
await
parent.CreateFolderAsync(name, CreationCollisionOption.OpenIfExists).DontMarshall();
}