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