public async Task CopyResource(string resourceName, string targetName, IFolder targetFolder) { using (Stream resource = typeof(IFileService).GetTypeInfo().Assembly.GetManifestResourceStream(resourceName)) { if (resource == null) { throw new ArgumentException("No such resource", "resourceName"); } var file = await targetFolder.CreateFileAsync(targetName, CreationCollisionOption.ReplaceExisting); using (var output = await file.OpenAsync(FileAccess.ReadAndWrite)) { await resource.CopyToAsync(output); } } }
public async Task StoreEventAsync(InstrumentationEvent instrumentationEvent) { if (string.IsNullOrEmpty(instrumentationEvent?.ToJson().ToString())) { LoggingService.Log("Invalid Event", LoggingLevel.Error); return; } if (await ShouldStoreEventAsync().ConfigureAwait(false)) { var fileName = instrumentationEvent.EventId + FilenameSuffix; //Open file IFile file = await _rootDir.CreateFileAsync(fileName, CreationCollisionOption.OpenIfExists); //Wrtie to file after encrypting contents await file.WriteAllTextAsync(Encrypt(instrumentationEvent.ToJson().ToString(), EncryptionKey)).ConfigureAwait(false); } }
public static void Reset() { try { IFolder rootFolder = FileSystem.Current.LocalStorage; // create a folder, if one does not exist already IFolder folder = rootFolder.CreateFolderAsync(GlobalVar.DataFolderName, CreationCollisionOption.OpenIfExists).GetAwaiter().GetResult(); // create a file, overwriting any existing file IFile file = folder.CreateFileAsync(GlobalVar.DataFileName + ".txt", CreationCollisionOption.ReplaceExisting).GetAwaiter().GetResult(); GlobalVar.DataToSave = new dynamic[] { null, "false" }; } catch (Exception exc) { } }
protected override async void OnStart() { // Handle when your app starts 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($"Temp Flder name :{folder.Name}"); Debug.WriteLine($"Temp Flder path :{folder.Path}"); IFile file = await folder.CreateFileAsync("MyTest.txt", CreationCollisionOption.OpenIfExists); await file.WriteAllTextAsync("Hello I'm Jimmy"); }
private async void ReceiveSurveys() { SurveysServices S_S1 = new SurveysServices(); ControlFile controlFile = new ControlFile(); string username = await controlFile.GetUserName(); S_S1.Set_UrlApi("ReceiveSurveysShared/" + username); List <Survey> ReceivedSurveys = await S_S1.GetSurveysAsync(); ExistenceCheckResult result = await folder.CheckExistsAsync("Receivedsurveys"); if (result == ExistenceCheckResult.FolderExists) { folder = await folder.CreateFolderAsync("Receivedsurveys", CreationCollisionOption.OpenIfExists); file = await folder.CreateFileAsync("Receivedsurveys", CreationCollisionOption.OpenIfExists); string Content = await file.ReadAllTextAsync(); List <Survey> OldreceiveSurveys = Serializable_Survey.deserialize(Content).ToList(); if (OldreceiveSurveys.Count < ReceivedSurveys.Count) { var player = Plugin.SimpleAudioPlayer.CrossSimpleAudioPlayer.Current; player.Load("NotificationReceive.mp3"); player.Play(); Plugin.LocalNotifications.CrossLocalNotifications.Current.Show(Lang.Resource.receivesurveys, Lang.Resource.BodyreceiveSurvey, 0); } } else if (result != ExistenceCheckResult.FolderExists && ReceivedSurveys.Count > 0) { var player = Plugin.SimpleAudioPlayer.CrossSimpleAudioPlayer.Current; player.Load("NotificationReceive.mp3"); player.Play(); Plugin.LocalNotifications.CrossLocalNotifications.Current.Show(Lang.Resource.receivesurveys, Lang.Resource.BodyreceiveSurvey, 0); } folder = FileSystem.Current.LocalStorage; folder = await folder.CreateFolderAsync("Receivedsurveys", CreationCollisionOption.ReplaceExisting); file = await folder.CreateFileAsync("Receivedsurveys", CreationCollisionOption.ReplaceExisting); string content = Serializable_Survey.serialize(ReceivedSurveys); await file.WriteAllTextAsync(content); }
private async void Save(object sender, EventArgs e) { if (!CheckNetwork.Check_Connectivity()) { return; } stackQuestions.Opacity = 0.5; ActivityIndicator.IsRunning = true; 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); foreach (Survey S in ListSurveys) { if (S.Id == survey.Id) { S.Title_Property = Title.Text; S.Description_Property = Description.Text; survey = S; SurveysServices S_S = new SurveysServices(); S_S.Set_UrlApi("EditSurveys/" + username); await S_S.PutSurveysAsync(survey); break; } } title.Text = Title.Text; description.Text = Description.Text; content = Serializable_Survey.serialize(ListSurveys.ToList()); await file.WriteAllTextAsync(content); Cancel(sender, e); await Task.Delay(500); ActivityIndicator.IsRunning = false; stackQuestions.Opacity = 1; }
private async Task ProcessHtmlFile(IFile sourceFile, IFolder outputFolder) { this.BuildHandler.SignalBuildEvent("Processing HTML file " + sourceFile.Path); string rawHtml = await sourceFile.ReadAllTextAsync(); // Inject the templates Dictionary <string, string> values = new Dictionary <string, string>(); string outputHtml = null; this.TemplateServices.InjectTemplateRecursive(rawHtml, this.Templates, out outputHtml, ref values); // Inject template values outputHtml = this.TemplateServices.InjectTemplateValues(outputHtml, values); // Write out the processed html to the output folder await outputFolder.CreateFileAsync(sourceFile.Name, outputHtml); }
public static async Task <string> GetPathForFile(string filename) { System.Diagnostics.Debug.WriteLine("Core.GetPathForFile()"); // 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(folderName, CreationCollisionOption.OpenIfExists); // create a file if one does not exist already IFile file = await folder.CreateFileAsync(filename, CreationCollisionOption.OpenIfExists); System.Diagnostics.Debug.WriteLine("Path for file: " + file.Path); // get path return(file.Path); }
public async Task PCLGenaratePdf(string path) { IFolder rootFolder = await FileSystem.Current.GetFolderFromPathAsync(path); IFolder folder = await rootFolder.CreateFolderAsync("folder", CreationCollisionOption.OpenIfExists); IFile file = await folder.CreateFileAsync("file.pdf", CreationCollisionOption.ReplaceExisting); using (var fs = await file.OpenAsync(FileAccess.ReadAndWrite)) { var document = new Document(PageSize.A4, 25, 25, 30, 30); PdfWriter writer = PdfWriter.GetInstance(document, fs); document.Open(); document.Add(new Paragraph("heloo everyone")); document.Close(); writer.Close(); } }
/// <summary> /// /// </summary> /// <returns></returns> /// <remarks>When saving, this method ignores null values to reduce file size.</remarks> public override async Task <bool> SyncAsync() { //RWM: Serialize the table to a file. if (localCacheFolder == null) { //RWM: Shouldn't happen but better safe than sorry. localCacheFolder = await FileSystem.Current.LocalStorage.CreateFolderAsync(CacheFolderName, CreationCollisionOption.OpenIfExists); } if (localCacheFile == null) { //RWM: Shouldn't happen but better safe than sorry. localCacheFile = await localCacheFolder.CreateFileAsync(CacheFileName, CreationCollisionOption.ReplaceExisting); } var contents = JsonConvert.SerializeObject(items, Formatting.None, jsonIgnoreNullsSettings); await localCacheFile.WriteAllTextAsync(contents); return(true); }
public static async Task AppendLineToFileAsync(string fileName, string line) { try { #if UWP var folder = ApplicationData.Current.LocalFolder; var file = await folder.CreateFileAsync(fileName, CreationCollisionOption.OpenIfExists); await FileIO.AppendLinesAsync(file, new List <string>() { line }); #else IFolder folder = FileSystem.Current.LocalStorage; IFile file = await folder.CreateFileAsync(fileName, CreationCollisionOption.OpenIfExists); await file.AppendAllLinesAsync(new List <string>() { line }); #endif } catch { /* Avoid any exception at this point. */ } }
public MainPageViewModel(INavigationService navigationService) { _navigationService = navigationService; LogoutCommand = new DelegateCommand(async() => { IFolder fooFolder = await PCLStorage.FileSystem.Current.LocalStorage. CreateFolderAsync("MyData", CreationCollisionOption.OpenIfExists); IFile fooFile = await fooFolder.CreateFileAsync("UserInfo.txt", CreationCollisionOption.OpenIfExists); var fooItem = new UserInfo() { ID = "", Name = "" }; var fooJSON = JsonConvert.SerializeObject(fooItem); await fooFile.WriteAllTextAsync(fooJSON); _navigationService.NavigateAsync("/LoginPage"); }); }
async protected override void OnAppearing() { base.OnAppearing(); IFolder rootfolder = FileSystem.Current.LocalStorage; Debug.WriteLine($"rootfolder Name:{rootfolder.Name}"); Debug.WriteLine($"rootfolder Paht:{rootfolder.Path}"); IFolder folder = await rootfolder.CreateFolderAsync("temp", CreationCollisionOption.OpenIfExists); Debug.WriteLine($"folder Name:{folder.Name}"); Debug.WriteLine($"folder Paht:{folder.Path}"); IFile file = await folder.CreateFileAsync("MyTest.txt", CreationCollisionOption.OpenIfExists); await file.WriteAllTextAsync("Hello Ming"); }
public async Task SaveToLocal() { try { IFolder rootFolder = FileSystem.Current.LocalStorage; IFolder folder = await rootFolder.CreateFolderAsync("RMMT", CreationCollisionOption.OpenIfExists); IFile file = await folder.CreateFileAsync("", CreationCollisionOption.ReplaceExisting); await file.WriteAllTextAsync("42"); } catch (Exception) { _commonFun.AlertLongText("操作异常,请重试。-->LocalRegistScoreViewModel"); return; } }
protected override async void OnAppearing() { base.OnAppearing(); var rootFolder = FileSystem.Current.LocalStorage; _localFolder = await rootFolder.CreateFolderAsync(FOLDER, CreationCollisionOption.OpenIfExists); _localFile = await _localFolder.CreateFileAsync(FILE, CreationCollisionOption.OpenIfExists); var result = ""; result = await _localFile.ReadAllTextAsync(); if (result.Length > 0) { FillListView(result); } }
public async Task Initialize() { try { IFolder rootFolder = FileSystem.Current.LocalStorage; IFolder folder = rootFolder.CreateFolderAsync("app-settings", CreationCollisionOption.OpenIfExists).Result; // following call made sync to aviod deadlocks this.file = folder.CreateFileAsync(configFile, CreationCollisionOption.OpenIfExists).Result; this.isInitialized = true; } catch (Exception ex) { Debug.WriteLine(ex.Message); throw; } }
async Task ExecuteLoadItemsCommand() { if (IsBusy) { await Task.Delay(300); } IsBusy = true; try { Items.Clear(); IFolder rootFolder = FileSystem.Current.LocalStorage; IFolder folder = await rootFolder.CreateFolderAsync("DolentaCache", CreationCollisionOption.OpenIfExists); string fileName = "favourites.txt"; IFile file = await folder.CreateFileAsync(fileName, CreationCollisionOption.OpenIfExists); string content = await file.ReadAllTextAsync(); List <Offer> Favs = new List <Offer>(); try { Favs = JsonConvert.DeserializeObject <List <Offer> >(content); } catch (System.NullReferenceException) { Console.WriteLine("Nie bylo"); Favs = new List <Offer>(); } foreach (Offer temp in Favs) { Items.Add(temp); } } catch (Exception ex) { Debug.WriteLine(ex); } finally { IsBusy = false; } }
private async Task OnGetImage() { var settings = new ImageConstructionSettings { Padding = 12, StrokeColor = Color.FromRgb(25, 25, 25), BackgroundColor = Color.FromRgb(225, 225, 225), DesiredSizeOrScale = 2f }; var image = await padView.GetImageStreamAsync(SignatureImageFormat.Png, settings); if (image == null) { return; } IFolder rootFolder = FileSystem.Current.LocalStorage; IFolder folder = await rootFolder.CreateFolderAsync("MySubFolder", CreationCollisionOption.OpenIfExists); IFile file = await folder.CreateFileAsync("answer.png", CreationCollisionOption.ReplaceExisting); using (var fooStream = await file.OpenAsync(FileAccess.ReadAndWrite)) { await image.CopyToAsync(fooStream); } //var page = new ContentPage //{ // Title = "Signature", // Content = new Image // { // Aspect = Aspect.AspectFit, // Source = ImageSource.FromStream(() => image) // } //}; //await Navigation.PushAsync(page); }
public async void WriteFileLocally(MemoryStream imageStream, string filename, CallbackOnFinished callbackOnFinished) { IFolder localFolder = FileSystem.Current.LocalStorage; IFile localFile = null; localFolder = await localFolder.CreateFolderAsync(localFolderName, CreationCollisionOption.OpenIfExists); bool fileCreated = false; int counter = 0; while (!fileCreated) { try { filename += ".jpg"; localFile = await localFolder.CreateFileAsync(filename, CreationCollisionOption.FailIfExists); fileCreated = true; } catch (Exception e) { //file exists counter++; filename = StorageUtility.UpdateFilename(filename, counter); } } using (Stream stream = await localFile.OpenAsync(FileAccess.ReadAndWrite)) { imageStream.Position = 0; imageStream.CopyTo(stream); stream.Flush(); } bool sendingResult = await SendFilePicToServer(localFile.Path, "file"); if (sendingResult) { await localFile.DeleteAsync(); } //chiamare la callback operazione conclusa callbackOnFinished(); }
public static async Task <string> CopyTodoItemFileAsync(string itemId, string filePath) { IFolder localStorage = FileSystem.Current.LocalStorage; string fileName = Path.GetFileName(filePath); string targetPath = await GetLocalFilePathAsync(itemId, fileName); var sourceFile = await localStorage.GetFileAsync(filePath); var sourceStream = await sourceFile.OpenAsync(FileAccess.Read); var targetFile = await localStorage.CreateFileAsync(targetPath, CreationCollisionOption.ReplaceExisting); using (var targetStream = await targetFile.OpenAsync(FileAccess.ReadAndWrite)) { await sourceStream.CopyToAsync(targetStream); } return(targetPath); }
public static async Task <bool> CreateEmptyFileInFolder(string folderName, string filename) { bool result = true; try { IFolder localFolder = FileSystem.Current.LocalStorage; localFolder = await localFolder.CreateFolderAsync(folderName, CreationCollisionOption.OpenIfExists); IFile localFile = await localFolder.CreateFileAsync(filename, CreationCollisionOption.FailIfExists); } catch (Exception e) { result = false; Debug.WriteLine(e.StackTrace); } return(result); }
async Task WriteXmlResultFile(ResultSummary result) { string outputFolderName = Path.GetDirectoryName(Options.ResultFilePath); string outputXmlReportName = Path.GetFileName(Options.ResultFilePath); await CreateFolderRecursive(outputFolderName); IFolder outputFolder = await FileSystem.Current.GetFolderFromPathAsync(outputFolderName, CancellationToken.None); IFile xmlResultFile = await outputFolder.CreateFileAsync(outputXmlReportName, CreationCollisionOption.ReplaceExisting); using (var resultFileStream = new StreamWriter(await xmlResultFile.OpenAsync(FileAccess.ReadAndWrite))) { var xml = result.GetTestXml().ToString(); await resultFileStream.WriteAsync(xml); } }
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:p}"); } } IShare shareDependency = DependencyService.Get <IShare>(); await shareDependency.Show("Expense Report", "Here is your expenses report", txtFile.Path); }
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); } }
public async Task WriteAndReadFile() { // Arrange IFolder folder = TestFileSystem.LocalStorage; IFile file = await folder.CreateFileAsync("readWriteFile.txt", CreationCollisionOption.FailIfExists); string contents = "And so we beat on, boats against the current, born back ceaselessly into the past."; // Act await file.WriteAllTextAsync(contents); string readContents = await file.ReadAllTextAsync(); // Assert Assert.AreEqual(contents, readContents); // Cleanup await file.DeleteAsync(); }
public async Task OpenFileForReadAndWrite() { // Arrange IFolder folder = TestFileSystem.LocalStorage; string fileName = "fileToOpenForReadAndWrite"; IFile file = await folder.CreateFileAsync(fileName, CreationCollisionOption.FailIfExists); // Act using (Stream stream = await file.OpenAsync(FileAccess.ReadAndWrite)) { // Assert Assert.IsTrue(stream.CanWrite); Assert.IsTrue(stream.CanRead); Assert.IsTrue(stream.CanSeek); } // Cleanup await file.DeleteAsync(); }
public async Task <bool> CreateReport(string name) { try { IFolder rootFolder = FileSystem.Current.LocalStorage; folder = await rootFolder.CreateFolderAsync("Reports", CreationCollisionOption.OpenIfExists).ConfigureAwait(false); file = await folder.CreateFileAsync(name, CreationCollisionOption.ReplaceExisting); //await file.WriteAllTextAsync("42"); } catch (Exception ex) { throw new Exception("Error with file creation: " + ex.Message); } return(await Task.FromResult(true)); }
public bool CreateFile(string fileName, string content) { if (LogFolder == null) { return(false); } // ToDo: change default document path: /data/user/0/uwgb.dylanhoffman.m_obd_2/files/MOBD2_LOGS/"filename" try { LogFile = LogFolder.CreateFileAsync(fileName, CreationCollisionOption.ReplaceExisting).Result; LogFile.WriteAllTextAsync(content); return(true); } catch { return(false); } }
public async Task <IFile> GetFileFromFolder(string folderName, string fileName) { // Bu method ile klasörden dosya çağırıyoruz. CreationCollisionOption durumlarından OpenIfexits seçili eğer dosya var ise dosyayı dönüyor. IFolder rootFolder = FileSystem.Current.LocalStorage; var exits = await FolderExists(folderName); if (exits) { IFolder requestedFolder = await rootFolder.GetFolderAsync(folderName); IFile requestedFile = await requestedFolder.CreateFileAsync(fileName, CreationCollisionOption.OpenIfExists); return(requestedFile); } else { return(null); } }
internal static async Task <string> ReadFileAsync(IFolder rootFolder) { //IFolder rootFolder = FileSystem.Current.LocalStorage; //IFolder folder = await rootFolder.GetFolderAsync(Constants.StorageSubFolder); // create a folder, if one does not exist already IFolder folder = await rootFolder.CreateFolderAsync(Constants.StorageSubFolder, CreationCollisionOption.OpenIfExists); if (folder == null) { return(null); } // create a file, overwriting any existing file IFile file = await folder.CreateFileAsync(Constants.StorageFileName, CreationCollisionOption.OpenIfExists); //IFile file = await folder.GetFileAsync(Constants.StorageFileName); var contents = await file.ReadAllTextAsync(); return(contents); }
public static async Task<bool> DownloadFileAsync(IFolder folder, string url, string fileName) { using (var client = new HttpClient()) using (var response = await client.GetAsync(url)) { if (response.StatusCode == System.Net.HttpStatusCode.OK) { Stream temp = await response.Content.ReadAsStreamAsync(); IFile file = await folder.CreateFileAsync(fileName, CreationCollisionOption.ReplaceExisting); using (var fs = await file.OpenAsync(PCLStorage.FileAccess.ReadAndWrite)) { await temp.CopyToAsync(fs); fs.Close(); return true; } } else { Debug.WriteLine("NOT FOUND " + url); return false; } } }
public static async Task<IFile> CreateFileAsync(string path, IFolder folder, CreationCollisionOption option = CreationCollisionOption.OpenIfExists) { if (path.StartsWith("/") || path.StartsWith("\\")) path = path.Substring(1); var parts = path.Split('/'); var fileName = parts.Last(); if (parts.Length > 1) { folder = await EnsureFolderExistsAsync(path.Substring(0, path.Length - fileName.Length), folder) .DontMarshall(); } return await folder.CreateFileAsync(fileName, option).DontMarshall(); }
public async void createCleanFileSystem(IFolder fileSystem) { IFile file = await fileSystem.CreateFileAsync("PhoneData.txt", CreationCollisionOption.ReplaceExisting); string baseString = "a\nUVA,\n"; ///GOTO: settings page if this is modified await file.WriteAllTextAsync(baseString); var navPage = new NavigationPage(new CarouselTutorialPage()); MainPage = navPage; }
public async void createFileSystem(IFolder fileSystem) { var loc = await App.dbWrapper.GetLocation(); var cloudList = await App.dbWrapper.GetAvailableClouds(loc[0], loc[1]); string cloudNamesString = ""; for(int i =0; i<cloudList.Count; i++) { cloudNamesString +=(cloudList[i].Title) + ","; System.Diagnostics.Debug.WriteLine(cloudList[i].Title); } IFile file = await fileSystem.CreateFileAsync("PhoneData.txt", CreationCollisionOption.ReplaceExisting); string baseString = "a\nUVA,"+cloudNamesString+"\n"; ///GOTO: settings page if this is modified await file.WriteAllTextAsync(baseString); var navPage = new NavigationPage(new CarouselTutorialPage()); MainPage = navPage; }