public async Task When_DeleteFile() { var _folder = Windows.Storage.ApplicationData.Current.LocalFolder; Assert.IsNotNull(_folder, "cannot get LocalFolder - error outside tested method"); Windows.Storage.StorageFile _file = null; try { _file = await _folder.CreateFileAsync(_filename, Windows.Storage.CreationCollisionOption.FailIfExists); Assert.IsNotNull(_file, "cannot create file - error outside tested method"); } catch { Assert.Fail("CreateFile exception - error outside tested method"); } // try delete file try { await _file.DeleteAsync(); } catch { Assert.Fail("DeleteAsync exception - error in tested method"); } // check if method works var _fileAfter = await _folder.TryGetItemAsync("test-deletingfile.txt"); Assert.IsNull(_fileAfter, "file is not deleted - tested method fails"); }
//Delete a file public async Task DeleteFile() { Windows.Storage.StorageFile sampleFile = await textfileFolder.GetFileAsync(FileName + ".txt"); await sampleFile.DeleteAsync(); }
async void TranscodeCancel(object sender, RoutedEventArgs e) { try { _cts.Cancel(); _cts.Dispose(); _cts = new CancellationTokenSource(); if (_OutputFile != null) { await _OutputFile.DeleteAsync(); } } catch (Exception exception) { TranscodeError(exception.Message); } }
/// <summary> /// Deletes the changelog. /// </summary> public static async void DeleteChangelog() { Windows.Storage.StorageFolder storageFolder = Windows.Storage.ApplicationData.Current.LocalFolder; Windows.Storage.StorageFile file = await storageFolder.GetFileAsync("Changelog.txt"); await file.DeleteAsync(StorageDeleteOption.Default); }
private async Task DeleteTempFile(StorageFile f) { try { await f.DeleteAsync(); } catch { // ignore } }
public async void Create() { // Create sample file; replace if exists. Windows.Storage.StorageFolder storageFolder = Windows.Storage.ApplicationData.Current.LocalFolder; Windows.Storage.StorageFile sampleFile = await storageFolder.CreateFileAsync("Untitled.txt", Windows.Storage.CreationCollisionOption.ReplaceExisting); File = await _FileService.LoadAsync(sampleFile); await sampleFile.DeleteAsync(Windows.Storage.StorageDeleteOption.PermanentDelete); }
public static async Task<bool> DeleteFileAsync(StorageFile file) { try { await file.DeleteAsync(StorageDeleteOption.PermanentDelete); return true; } catch (Exception ex) { Debug.WriteLine("Failed to delete file: " + ex); return false; } }
async void TranscodeFailure(TranscodeFailureReason reason) { try { if (_OutputFile != null) { await _OutputFile.DeleteAsync(); } } catch (Exception exception) { } }
private async void clearDataStorage(IUICommand command) { string DataFile = @"Assets\storage.txt"; Windows.Storage.StorageFolder storageFolder = Windows.ApplicationModel.Package.Current.InstalledLocation; Windows.Storage.StorageFile sampleFile = await storageFolder.GetFileAsync(DataFile); // REMOVE FILE await sampleFile.DeleteAsync(); // CREATE NEW FILE await storageFolder.CreateFileAsync(DataFile, Windows.Storage.CreationCollisionOption.ReplaceExisting); txtData.Text = "Data byla smazána!"; }
private async void DeleteFile_OnClick(object sender, RoutedEventArgs e) { if (listBox.SelectedItem == null) { return; } ListBoxItem item = (ListBoxItem)listBox.SelectedItem; if (item.Tag is Windows.Storage.StorageFile) { Windows.Storage.StorageFile file = (Windows.Storage.StorageFile)item.Tag; await file.DeleteAsync(); } ScanDir(currentFolder); }
/// <summary> /// Outputs the changes to online db. /// </summary> /// <returns></returns> public static async Task OutputChanges() { MySqlConnection dbConnection = DbConnection.getConnection(); Windows.Storage.StorageFolder storageFolder = Windows.Storage.ApplicationData.Current.LocalFolder; Windows.Storage.StorageFile file = await storageFolder.GetFileAsync("Changelog.txt"); IList <string> data = await FileIO.ReadLinesAsync(file); List <string> queries = data.ToList(); foreach (var queryItem in queries) { using (dbConnection) { try { dbConnection.Open(); var query = dbConnection.CreateCommand(); query.CommandText = queryItem; query.ExecuteReader(); dbConnection.Close(); } catch (MySqlException) { break; } } } using (dbConnection) { try { dbConnection.Open(); await file.DeleteAsync(StorageDeleteOption.Default); DataAccess.InitializeDatabase(); dbConnection.Close(); } catch (Exception) { } } }
private async Task <Windows.Storage.StorageFile> ReencodePhotoAsync(Windows.Storage.StorageFile tempStorageFile, Windows.Storage.FileProperties.PhotoOrientation photoRotation) { Windows.Storage.Streams.IRandomAccessStream inputStream = null; Windows.Storage.Streams.IRandomAccessStream outputStream = null; Windows.Storage.StorageFile photoStorage = null; try { String newPhotoFilename = photoId + "_" + photoCount.ToString() + ".jpg"; inputStream = await tempStorageFile.OpenAsync(Windows.Storage.FileAccessMode.Read); var decoder = await Windows.Graphics.Imaging.BitmapDecoder.CreateAsync(inputStream); photoStorage = await currentFolder.CreateFileAsync(newPhotoFilename, Windows.Storage.CreationCollisionOption.GenerateUniqueName); outputStream = await photoStorage.OpenAsync(Windows.Storage.FileAccessMode.ReadWrite); outputStream.Size = 0; var encoder = await Windows.Graphics.Imaging.BitmapEncoder.CreateForTranscodingAsync(outputStream, decoder); var properties = new Windows.Graphics.Imaging.BitmapPropertySet(); properties.Add("System.Photo.Orientation", new Windows.Graphics.Imaging.BitmapTypedValue(photoRotation, Windows.Foundation.PropertyType.UInt16)); await encoder.BitmapProperties.SetPropertiesAsync(properties); await encoder.FlushAsync(); } finally { if (inputStream != null) { inputStream.Dispose(); } if (outputStream != null) { outputStream.Dispose(); } var asyncAction = tempStorageFile.DeleteAsync(Windows.Storage.StorageDeleteOption.PermanentDelete); } return(photoStorage); }
/// <summary> /// Tries to delete file n times , each try is postponed by 5 seconds. /// </summary> /// <param name="nRetries"></param> /// <param name="file"></param> public static void TryToRemoveFile(int nRetries,StorageFile file) { Task.Run( async () => { try { await file.DeleteAsync(StorageDeleteOption.PermanentDelete); } catch (Exception) { if (nRetries > 0) { await Task.Delay(TimeSpan.FromSeconds(5)); TryToRemoveFile(nRetries - 1,file); } } }); }
public static async Task resetFolders() { Windows.Storage.StorageFolder localfolder = Windows.Storage.ApplicationData.Current.LocalFolder; Windows.Storage.StorageFile firstfile = await localfolder.GetFileAsync("firsttime"); await firstfile.DeleteAsync(); var folders = await localfolder.GetFoldersAsync(); foreach (Windows.Storage.StorageFolder folder in folders) { await folder.DeleteAsync(); } Windows.Storage.StorageFolder stor = await Windows.Storage.ApplicationData.Current.LocalFolder.CreateFolderAsync("thumbs", Windows.Storage.CreationCollisionOption.FailIfExists); Uri uri = new Uri("ms-appx:///Assets/bookImage.jpg"); Windows.Storage.StorageFile file = await Windows.Storage.StorageFile.GetFileFromApplicationUriAsync(uri); Windows.Storage.StorageFolder imageFolder = await Windows.Storage.ApplicationData.Current.LocalFolder.GetFolderAsync("thumbs"); await file.CopyAsync(imageFolder, "default.jpg"); }
public async void Delete(FlipView display) { try { collection = new ObservableCollection<Music>(); display.ItemsSource = Collection; file = await ApplicationData.Current.LocalFolder.GetFileAsync(filename); await file.DeleteAsync(); } catch { } }
/// <summary> /// Attempts to upload the given file, and will recursively retry until the MaxRetries limit is reached. /// </summary> /// <param name="file">The file to upload. Assumes calling method has sole access to the file. Will delete the file after uploading</param> /// <param name="tryNumber">The number of the attempt being made. Should always initially be called with a value of 1</param> /// <returns></returns> private async Task uploadWithRetry(StorageFile file, int tryNumber = 1) { HttpResponseMessage response = await oneDriveConnector.UploadFileAsync(file, String.Format("{0}/{1}", App.Controller.XmlSettings.OneDriveFolderPath, DateTime.Now.ToString("yyyy_MM_dd"))); bool success = await parseResponse(response, tryNumber); var events = new Dictionary<string, string>(); if (success) { numberUploaded++; await file.DeleteAsync(); this.lastUploadTime = DateTime.Now; } else if (tryNumber <= MaxTries) { events.Add("Retrying upload", tryNumber.ToString()); TelemetryHelper.TrackEvent("FailedToUploadPicture - Next Retry Beginning", events); await uploadWithRetry(file, ++tryNumber); } else { events.Add("Max upload attempts reached", tryNumber.ToString()); TelemetryHelper.TrackEvent("FailedToUploadPicture - All Retries failed", events); } }
internal static async Task ExportTimetable(string exportFileName, StorageFile destinationFile) { try { var sourceFile = await (await GetTimetableDirectory()).GetFileAsync(exportFileName); await sourceFile.CopyAndReplaceAsync(destinationFile); return; } catch { } await destinationFile.DeleteAsync(); await new MessageDialog(Strings.TimetableIOExportError, Strings.MessageBoxWarningCaption).ShowAsync(); }
public static async Task<Object> DeserializeFromFileAsync(Type objectType, StorageFile file, bool deleteFile = false) { if (file == null) return null; try { Object obj; AppEventSource.Log.Debug("Suspension: Checking file..." + file.Name); // Get the input stream for the file using (IInputStream inStream = await file.OpenSequentialReadAsync()) { // Deserialize the Session State DataContractSerializer serializer = new DataContractSerializer(objectType); obj = serializer.ReadObject(inStream.AsStreamForRead()); } AppEventSource.Log.Debug("Suspension: Object loaded from file. " + objectType.ToString()); // Delete the file if (deleteFile) { await file.DeleteAsync(); deleteFile = false; AppEventSource.Log.Info("Suspension: File deleted. " + file.Name); } return obj; } catch (Exception e) { AppEventSource.Log.Error("Suspension: Error when deserializing object. Exception: " + e.Message); MessageDialog messageDialog = new MessageDialog("Error when deserializing App settings: " + file.Name + "\n" + "The PDF file is not affected.\n " + "Details: \n" + e.Message); messageDialog.Commands.Add(new UICommand("Reset Settings", null, 0)); messageDialog.Commands.Add(new UICommand("Ignore", null, 1)); IUICommand command = await messageDialog.ShowAsync(); switch ((int)command.Id) { case 0: // Delete file deleteFile = true; break; default: deleteFile = false; break; } return null; } finally { // Delete the file if error occured if (deleteFile) { await file.DeleteAsync(); AppEventSource.Log.Info("Suspension: File deleted due to error. " + file.Name); } } }
private async Task<bool> TryDeleteFileAsync(StorageFile file) { try { await file.DeleteAsync(); return true; } catch (IsolatedStorageException) { return false; } }
public async static Task<bool> SafeFileDelete(StorageFile file) { if (file == null) { return false; } try { await file.DeleteAsync(); } catch (FileNotFoundException) { // Ignore } catch (Exception) { var tempPath = GetUndeletedFilesDirectory(); await WriteFile(Path.Combine(tempPath, string.Format("{0}.txt", Guid.NewGuid())), file.Path); return false; } return true; }
public static async Task DeleteFileAsync(StorageFile file) { if (file != null) await file.DeleteAsync(); }
private async Task <bool> WriteBytesToFile(byte[] audio) { int ctr = 0; string fileName = "audioData.dat"; Windows.Storage.StorageFile audioFile = null; while (true) //HACK { while (true) //HACK { try { audioFile = await storageFolder.GetFileAsync(fileName); if (audioFile != null) { await audioFile.DeleteAsync(); } break; } catch (Exception e) { if (e.Message.IndexOf("The system cannot find the file specified") == -1) { int ignoreForNow = 1; } else { break; } } } try { audioFile = await storageFolder.CreateFileAsync(fileName, CreationCollisionOption.ReplaceExisting); await FileIO.WriteBytesAsync(audioFile, audio); break; } catch (Exception e) { try //TODO - Remove inner exception { audioFile = await storageFolder.GetFileAsync(fileName); await audioFile.DeleteAsync(); } catch (Exception ex) { int ignoreForNow = 1; } if (ctr > 5) { throw e; } else { ctr++; } } } return(true); //HACK }
/// <summary> /// This is used to delete the temporary created file /// used in the Share charm and other functions. /// </summary> public async Task deleteUsedFile() { // Deletes the temporary created file. if (imageOriginal.dstPixels != null) { file = await ApplicationData.Current.LocalFolder.GetFileAsync("temp.jpg"); await file.DeleteAsync(); } }
private static async Task DeleteSchedule(BusStop stop, StorageFile file, params string[] routes) { if (routes == null || routes.Length == 0) { await file.DeleteAsync(); } else { WeekSchedule baseSchedule = (await LoadSchedule(stop.ID)) ?? new WeekSchedule(); baseSchedule.RemoveRoutes(routes); if (baseSchedule.IsEmpty) await DeleteSchedule(stop, file); else await OverwriteScheduleAsync(baseSchedule, stop); } }
public async Task DeleteAsync(StorageFile file) { await file.DeleteAsync(StorageDeleteOption.PermanentDelete); }
public async void StartDownload(StorageFile fileDownload) { try { var fs = await fileDownload.OpenAsync(FileAccessMode.ReadWrite); Stream stream = await Response.Content.ReadAsStreamAsync(); IInputStream inputStream = stream.AsInputStream(); ulong totalBytesRead = 0; while (true) { if (CancelTask) { await fileDownload.DeleteAsync(StorageDeleteOption.PermanentDelete); break; } // Read from the web. IBuffer buffer = new Windows.Storage.Streams.Buffer(1024); buffer = await inputStream.ReadAsync( buffer, buffer.Capacity, InputStreamOptions.None); if (buffer.Length == 0) { break; } // Report progress. totalBytesRead += buffer.Length; OnDownloadProgress(totalBytesRead, FileSizeMb); // Write to file. await fs.WriteAsync(buffer); } inputStream.Dispose(); fs.Dispose(); OnDownloadComplete(); } catch (Exception ex) { OnDownloadCancel(ex.Message); } }
public async void DownloadStart(Uri source,StorageFile destinationFile) { try { BackgroundDownloader downloader = new BackgroundDownloader(); DownloadOperation download = downloader.CreateDownload(source, destinationFile); DownloadStarted(); await download.StartAsync(); Tracker myTracker = EasyTracker.GetTracker(); int progress = (int)(100 * (download.Progress.BytesReceived / (double)download.Progress.TotalBytesToReceive)); if (progress >= 100) { myTracker.SendEvent("Downloads", "Download Finished using Share Target", "Download Successfull using Share Target", 1); BasicProperties basic = await download.ResultFile.GetBasicPropertiesAsync(); string size; double siz = basic.Size; // ulong mb = ulong.Parse(1000000); if (siz > 1000000) { double s = siz / 1000000; size = s.ToString() + "MB"; } else { double s = siz / 1000; size = s.ToString() + "KB"; } DatabaseController.AddDownload(destinationFile.Name, download.ResultFile.Path, download.ResultFile.DateCreated.DateTime.ToString(), size); DowloadFinish(destinationFile); } else { BasicProperties basic = await download.ResultFile.GetBasicPropertiesAsync(); double siz = basic.Size; if (siz == 0) { await destinationFile.DeleteAsync(); myTracker.SendEvent("Downloads", "Download Failed due to Server Error", null, 3); MessageDialog m = new MessageDialog("Server is down. Try again later", "Fatal Error"); await m.ShowAsync(); } } } catch(Exception ex) { Debug.WriteLine(ex.ToString()); } /* var authClient = new LiveAuthClient(); var authResult = await authClient.LoginAsync(new string[] { "wl.skydrive", "wl.skydrive_update" }); if (authResult.Session == null) { throw new InvalidOperationException("You need to sign in and give consent to the app."); } var liveConnectClient = new LiveConnectClient(authResult.Session); string skyDriveFolder = await CreateDirectoryAsync(liveConnectClient, "PDF Me - Saved PDFs", "me/skydrive"); */ }
public static async Task <Windows.Storage.StorageFolder> extractFiles(Windows.Storage.StorageFile zipfilename) { Windows.Storage.StorageFolder storfolder = null; try { // Create stream for compressed files in memory using (MemoryStream zipMemoryStream = new MemoryStream()) { using (Windows.Storage.Streams.IRandomAccessStream zipStream = await zipfilename.OpenAsync(Windows.Storage.FileAccessMode.Read)) { // Read compressed data from file to memory stream using (Stream instream = zipStream.AsStreamForRead()) { byte[] buffer = new byte[1024]; while (instream.Read(buffer, 0, buffer.Length) > 0) { zipMemoryStream.Write(buffer, 0, buffer.Length); } } } storfolder = await Windows.Storage.ApplicationData.Current.LocalFolder.CreateFolderAsync(zipfilename.DisplayName, Windows.Storage.CreationCollisionOption.GenerateUniqueName); // Create zip archive to access compressed files in memory stream using (ZipArchive zipArchive = new ZipArchive(zipMemoryStream, ZipArchiveMode.Read)) { // For each compressed file... foreach (ZipArchiveEntry entry in zipArchive.Entries) { // ... read its uncompressed contents using (Stream entryStream = entry.Open()) { if (entry.Name != "") { string fileName = entry.FullName.Replace("/", @"\"); byte[] buffer = new byte[entry.Length]; entryStream.Read(buffer, 0, buffer.Length); // Create a file to store the contents Windows.Storage.StorageFile uncompressedFile = await storfolder.CreateFileAsync(fileName, Windows.Storage.CreationCollisionOption.ReplaceExisting); // Store the contents using (Windows.Storage.Streams.IRandomAccessStream uncompressedFileStream = await uncompressedFile.OpenAsync(Windows.Storage.FileAccessMode.ReadWrite)) { using (Stream outstream = uncompressedFileStream.AsStreamForWrite()) { outstream.Write(buffer, 0, buffer.Length); outstream.Flush(); } } } } } } } } catch { if (storfolder != null) { await storfolder.DeleteAsync(); } return(null); } finally { zipfilename.DeleteAsync(); } return(storfolder); }