public static async Task ClearData() { Windows.Storage.StorageFolder localFolder = Windows.Storage.ApplicationData.Current.LocalFolder; StorageFile sampleFile_times_ms = await localFolder.CreateFileAsync(StorageRepos.times_ms, CreationCollisionOption.ReplaceExisting); await FileIO.WriteTextAsync(sampleFile_times_ms, ""); StorageFile sampleFile_times_sm = await localFolder.CreateFileAsync(StorageRepos.times_sm, CreationCollisionOption.ReplaceExisting); await FileIO.WriteTextAsync(sampleFile_times_sm, ""); StorageFile sampleFile_stations_ms = await localFolder.CreateFileAsync(StorageRepos.stations_ms, CreationCollisionOption.ReplaceExisting); await FileIO.WriteTextAsync(sampleFile_stations_ms, ""); StorageFile sampleFile_stations_sm = await localFolder.CreateFileAsync(StorageRepos.stations_sm, CreationCollisionOption.ReplaceExisting); await FileIO.WriteTextAsync(sampleFile_stations_sm, ""); //ApplicationData.Current.RoamingSettings.Values[StorageRepos.LastUpdateAt] = DateTime.Now; }
public async static void CreateEventFile() { Windows.Storage.StorageFolder localFolder = Windows.Storage.ApplicationData.Current.LocalFolder; await localFolder.CreateFileAsync("events.xml"); StorageFile sampleFile = await localFolder.CreateFileAsync("events.xml", CreationCollisionOption.ReplaceExisting); await FileIO.WriteTextAsync(sampleFile, "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n <events>\n </events>\n"); }
//Initialize the new Crypto object (initialized only once per app startup) public async void initCrypto() { this.strAsymmetricAlgName = AsymmetricAlgorithmNames.RsaPkcs1; this.asymmetricKeyLength = 512; //Checks SecureChat's folder if a key pair already exists and set keyPairExists boolean Windows.Storage.StorageFolder localAppFolder = Windows.Storage.ApplicationData.Current.LocalFolder; string cryptoFilePrivate = "SecureChatPrivateKeys.sckey"; //STORED AS BYTE DATA string cryptoFilePublic = "SecureChatPublicKey.sckey"; //STORED AS TEXT DATA if ((await localAppFolder.TryGetItemAsync(cryptoFilePublic) != null) && (await localAppFolder.TryGetItemAsync(cryptoFilePrivate) != null)) { this.keyPairExists = true; } else { this.keyPairExists = false; } //Load Keys depending on keyPairExists value if (this.keyPairExists == true) { //DIRECT IBUFFER //StorageFile loadedCryptoFilePublic = await localAppFolder.GetFileAsync(cryptoFilePublic); //this.buffPublicKey = await FileIO.ReadBufferAsync(loadedCryptoFilePublic); //FROM BYTE //StorageFile loadedCryptoFilePublic = await localAppFolder.GetFileAsync("BytePubKey.sckey"); //this.buffPublicKey = await FileIO.ReadBufferAsync(loadedCryptoFilePublic); //Open Public Key File. Convert key from STRING to BYTE and then convert to IBUFFER StorageFile loadedCryptoFilePublic = await localAppFolder.GetFileAsync(cryptoFilePublic); String publicKeyStringVersion = await FileIO.ReadTextAsync(loadedCryptoFilePublic); this.publicKeyByteVersion = Convert.FromBase64String(publicKeyStringVersion); this.buffPublicKey = this.publicKeyByteVersion.AsBuffer(); //Open Private Key File StorageFile loadedCryptoFilePrivate = await localAppFolder.GetFileAsync(cryptoFilePrivate); this.buffPrivateKeyStorage = await FileIO.ReadBufferAsync(loadedCryptoFilePrivate); } else { //Generate new key pair CryptographicKey temp = this.CreateAsymmetricKeyPair(strAsymmetricAlgName, asymmetricKeyLength, out buffPublicKey, out buffPrivateKeyStorage); //Convert public key from IBUFFER type to BYTE type. Convert from BYTE type to STRING type WindowsRuntimeBufferExtensions.CopyTo(this.buffPublicKey, this.publicKeyByteVersion); string publicKeyStringVersion = Convert.ToBase64String(this.publicKeyByteVersion); //Store keys in appropriate files (Public as PLAIN TEXT, Private as IBUFFER) await FileIO.WriteTextAsync((await localAppFolder.CreateFileAsync(cryptoFilePublic)), publicKeyStringVersion); await FileIO.WriteBufferAsync((await localAppFolder.CreateFileAsync(cryptoFilePrivate)), this.buffPrivateKeyStorage); } }
protected override async void OnNavigatedTo(NavigationEventArgs e) { //Select problem button Windows.Storage.StorageFolder storageFolder = Windows.Storage.ApplicationData.Current.LocalFolder; Windows.Storage.StorageFile problemInfo = await storageFolder.CreateFileAsync("problem.txt", Windows.Storage.CreationCollisionOption.OpenIfExists); var problemStream = await problemInfo.OpenAsync(Windows.Storage.FileAccessMode.ReadWrite); ulong problemSize = problemStream.Size; using (var inputStream = problemStream.GetInputStreamAt(0)) { using (var dataReader = new Windows.Storage.Streams.DataReader(inputStream)) { uint numBytesLoaded = await dataReader.LoadAsync((uint)problemSize); string problemContent = dataReader.ReadString(numBytesLoaded); if (problemContent == "") { selectProblemButton.Content = "choose a problem"; } else { selectProblemButton.Content = problemContent.ToString(); } } } problemStream.Dispose(); //Select room button Windows.Storage.StorageFile roomInfo = await storageFolder.CreateFileAsync("room.txt", Windows.Storage.CreationCollisionOption.OpenIfExists); var roomStream = await roomInfo.OpenAsync(Windows.Storage.FileAccessMode.ReadWrite); ulong roomSize = roomStream.Size; using (var inputStream = roomStream.GetInputStreamAt(0)) { using (var dataReader = new Windows.Storage.Streams.DataReader(inputStream)) { uint numBytesLoaded = await dataReader.LoadAsync((uint)roomSize); string roomContent = dataReader.ReadString(numBytesLoaded); if (roomContent == "") { selectRoomButton.Content = "choose a room"; } else { selectRoomButton.Content = roomContent.ToString(); } } } roomStream.Dispose(); }
private async void LoadFavorites() { FavouritesList = new List <FavouritesJSON>(); string filepath = @"Assets\Favorites.json"; StorageFolder folder = Windows.ApplicationModel.Package.Current.InstalledLocation; StorageFile file = await folder.GetFileAsync(filepath); // error here var JSONData = "e"; try { if ((bool)localSettings.Values["FirstFavRun"] == true) { localSettings.Values["FirstFavRun"] = false; StorageFile sfile = await localFolder.CreateFileAsync("Favorites.json", CreationCollisionOption.ReplaceExisting); await FileIO.WriteTextAsync(sfile, JSONData); JSONData = await Windows.Storage.FileIO.ReadTextAsync(file); } else { localSettings.Values["FirstFavRun"] = false; StorageFile ssfile = await localFolder.GetFileAsync("Favorites.json"); JSONData = await FileIO.ReadTextAsync(ssfile); } } catch { localSettings.Values["FirstFavRun"] = false; StorageFile sssfile = await localFolder.CreateFileAsync("Favorites.json", CreationCollisionOption.ReplaceExisting); await FileIO.WriteTextAsync(sssfile, JSONData); JSONData = await Windows.Storage.FileIO.ReadTextAsync(file); } localSettings.Values["FirstFavRun"] = false; StorageFile sampleFile = await localFolder.CreateFileAsync("Favorites.json", CreationCollisionOption.ReplaceExisting); await FileIO.WriteTextAsync(sampleFile, JSONData); FavouritesClass FavouritesListJSON = JsonConvert.DeserializeObject <FavouritesClass>(JSONData); foreach (var item in FavouritesListJSON.Websites) { FavouritesList.Add(new FavouritesJSON() { HeaderJSON = item.HeaderJSON, UrlJSON = item.UrlJSON, FavIconJSON = item.FavIconJSON, }); } Favorites.ItemsSource = FavouritesList; }
private async void DemoDataPersistenceCodeThroughFiles() { StorageFile localFileToWrite = await localFolder.CreateFileAsync("FileTest.txt", CreationCollisionOption.ReplaceExisting); await FileIO.WriteTextAsync(localFileToWrite, "This is a sample file!"); StorageFile localFileToRead = await localFolder.GetFileAsync("FileTest.txt"); string textRead = await FileIO.ReadTextAsync(localFileToRead); StorageFile localFileToDelete = await localFolder.GetFileAsync("FileTest.txt"); await localFileToDelete.DeleteAsync(); }
public async Task saveAppendTextFile(StorageFolder folder, string data, string key = null) { StorageFile myFile; if (key == null) { myFile = await folder.CreateFileAsync("myData.txt", CreationCollisionOption.OpenIfExists); } else { myFile = await folder.CreateFileAsync(key + ".txt", CreationCollisionOption.OpenIfExists); } await FileIO.AppendTextAsync(myFile, data); await FileIO.AppendTextAsync(myFile, Environment.NewLine); }
public async Task <bool> PersistObjectAsync <T>(string key, T value) { if (string.IsNullOrEmpty(key) || value == null) { return(false); } string xml = Serialize(value); var file = await settingsFolder.CreateFileAsync(key, CreationCollisionOption.ReplaceExisting); await FileIO.WriteTextAsync(file, xml); return(true); }
private async void SendMailClicked(object sender, RoutedEventArgs e) { if (isEmailInfoFilled()) { AnalysisSampleDataItem selectedItem = RecordGrid.SelectedItem as AnalysisSampleDataItem; if (selectedItem != null) { Windows.Storage.StorageFolder temporaryFolder = ApplicationData.Current.TemporaryFolder; StorageFile sampleFile = await temporaryFolder.CreateFileAsync(selectedItem.Name.Trim() + ".csv", CreationCollisionOption.ReplaceExisting); EmailInfoForm.IsOpen = false; AnalysisPageCmdbar.IsOpen = false; await FileIO.WriteTextAsync(sampleFile, ExtraModules.getFileDataForAnalysisItem(selectedItem)); AnalysisExportProgressRing.IsActive = true; AnalysisExportProgressRing.Visibility = Windows.UI.Xaml.Visibility.Visible; await ExtraModules.Send_Email(FromEmail.Text, FromPassword.Password, ToEmail.Text, Subject.Text, "Check from Health Organiser", sampleFile.Path); await sampleFile.DeleteAsync(StorageDeleteOption.PermanentDelete); AnalysisExportProgressRing.IsActive = false; AnalysisExportProgressRing.Visibility = Windows.UI.Xaml.Visibility.Collapsed; this.clearEmailInfoFields(); } else { EmailInfoForm.IsOpen = false; } } AnalysisPageCmdbar.IsOpen = false; }
private async void Submit_Click(object sender, RoutedEventArgs e) { String fileName = "Details.txt"; String name = Name.Text + Environment.NewLine; String email = Email.Text + Environment.NewLine; String address = Address.Text + Environment.NewLine; Windows.Storage.StorageFolder storageFolder = Windows.Storage.ApplicationData.Current.LocalFolder; Windows.Storage.StorageFile sampleFile = await storageFolder.CreateFileAsync("Details.txt", Windows.Storage.CreationCollisionOption.ReplaceExisting); Windows.Storage.StorageFolder localFolder = Windows.Storage.ApplicationData.Current.LocalFolder; Windows.Storage.StorageFile file = await localFolder.GetFileAsync(fileName); await FileIO.WriteTextAsync(file, name); // await FileIO.AppendTextAsync(file, name); await FileIO.AppendTextAsync(file, email); await FileIO.AppendTextAsync(file, address); Frame.Navigate(typeof(TicketSent)); }
async public static Task UnZipFile(StorageFile file, StorageFolder extractFolder = null) { using (var zipStream = await file.OpenStreamForReadAsync()) { using (MemoryStream zipMemoryStream = new MemoryStream((int)zipStream.Length)) { await zipStream.CopyToAsync(zipMemoryStream); using (var archive = new ZipArchive(zipMemoryStream, ZipArchiveMode.Read)) { foreach (ZipArchiveEntry entry in archive.Entries) { if (entry.Name != "") { using (Stream fileData = entry.Open()) { StorageFile outputFile = await extractFolder.CreateFileAsync(entry.Name, CreationCollisionOption.ReplaceExisting); using (Stream outputFileStream = await outputFile.OpenStreamForWriteAsync()) { await fileData.CopyToAsync(outputFileStream); await outputFileStream.FlushAsync(); } } } } } } } }
/// <summary> /// Saves /// </summary> /// <param name="errorMessage"></param> public async static void SaveError(string errorMessage) { string newCaseStart = $"\r\nDate: {DateTime.Now.ToShortDateString()}\r\n "; const string caseEnd = "\r\n- - -"; Windows.Storage.StorageFolder storageFolder = Windows.Storage.ApplicationData.Current.LocalFolder; Windows.Storage.StorageFile errorLog; //Check for existing file if (File.Exists(storageFolder.Path + "/InfoScreen-ErrorLog.txt")) { //Select file errorLog = await storageFolder.GetFileAsync("InfoScreen-ErrorLog.txt"); //Add to file await FileIO.AppendTextAsync(errorLog, $"{newCaseStart} {errorMessage} {caseEnd}"); } else { //Create or replace existing file. errorLog = await storageFolder.CreateFileAsync("InfoScreen-ErrorLog.txt", Windows.Storage.CreationCollisionOption.ReplaceExisting); await FileIO.WriteTextAsync(errorLog, $"" + newCaseStart + errorMessage + caseEnd); } }
//We use a protected override void to execute code as soon as the page is loaded into memory protected async override void OnNavigatedTo(NavigationEventArgs e) { Windows.Storage.StorageFolder storageFolder = Windows.Storage.ApplicationData.Current.LocalFolder; Windows.Storage.StorageFile signInInfo = await storageFolder.CreateFileAsync("signin.txt", Windows.Storage.CreationCollisionOption.OpenIfExists); var stream = await signInInfo.OpenAsync(Windows.Storage.FileAccessMode.ReadWrite); ulong size = stream.Size; using (var inputStream = stream.GetInputStreamAt(0)) { using (var dataReader = new Windows.Storage.Streams.DataReader(inputStream)) { uint numBytesLoaded = await dataReader.LoadAsync((uint)size); string signinAddress = dataReader.ReadString(numBytesLoaded); //string currentUser = emailBox.Text; if (signinAddress.ToString() == "") { emailBox.Text = "@wh-at.net"; } else { emailBox.Text = signinAddress.ToString(); Frame.Navigate(typeof(helpdesk)); } } } stream.Dispose(); }
//Ouput the new value of the Dropdown into Text async void DropdownValueChanged(Dropdown change) { #if UNITY_WSA && !UNITY_EDITOR Windows.Storage.StorageFolder storageFolder = Windows.Storage.ApplicationData.Current.LocalFolder; Windows.Storage.StorageFile file = await storageFolder.CreateFileAsync(gameDataFileName, Windows.Storage.CreationCollisionOption.OpenIfExists); string filePath = file.Path; #else string filePath = Path.Combine(Application.streamingAssetsPath, gameDataFileName); #endif if (File.Exists(filePath)) { // Read the json from the file into a string string dataAsJson = File.ReadAllText(filePath); // Pass the json to JsonUtility, and tell it to create a GameData object from it dynamic jsonObj = Newtonsoft.Json.JsonConvert.DeserializeObject(dataAsJson); jsonObj["loadedmap"] = m_Dropdown.options[change.value].text; string output = Newtonsoft.Json.JsonConvert.SerializeObject(jsonObj, Newtonsoft.Json.Formatting.Indented); //File.WriteAllText(filePath, output); #if UNITY_WSA && !UNITY_EDITOR await Windows.Storage.FileIO.WriteTextAsync(file, output); #else File.WriteAllText(filePath, output); #endif } else { Debug.LogError("Cannot load task data!"); } }
private const string filename = "UserPreference.txt"; //TODO: Move to constant file /// <summary> /// This checkes for strResponse - if not null, will try to write /// </summary> /// <param name="strResponse"></param> public async void CacheUserPreference(string strResponse) { roamingFolder = Windows.Storage.ApplicationData.Current.LocalFolder; StorageFile file = await roamingFolder.CreateFileAsync(filename,CreationCollisionOption.OpenIfExists); if (strResponse != null) await FileIO.AppendTextAsync(file, strResponse); }
public async static Task SaveFileToLocal(string fileName, string token) { Windows.Storage.StorageFolder newFolder = await Windows.Storage.AccessCache.StorageApplicationPermissions.FutureAccessList.GetFolderAsync(token); Windows.Storage.StorageFile newFile = await newFolder.CreateFileAsync(fileName, Windows.Storage.CreationCollisionOption.ReplaceExisting); Windows.Storage.StorageFolder storageFolder = Windows.Storage.ApplicationData.Current.LocalCacheFolder; Windows.Storage.StorageFile tragetFile = await storageFolder.GetFileAsync(fileName); var buffer = await Windows.Storage.FileIO.ReadBufferAsync(tragetFile); await Windows.Storage.FileIO.WriteBufferAsync(newFile, buffer); #region ReadWriteStream //string contentText = null; //using (var stream = await tragetFile.OpenAsync(Windows.Storage.FileAccessMode.Read)) //{ // ulong size = stream.Size; // var inputStream = stream.GetInputStreamAt(0); // var dataReader = new Windows.Storage.Streams.DataReader(inputStream); // uint numBytesLoaded = await dataReader.LoadAsync((uint)size); // contentText = dataReader.ReadString(numBytesLoaded); //} //using (var stream = await newFile.OpenAsync(Windows.Storage.FileAccessMode.ReadWrite)) //{ // var outputStream = stream.GetOutputStreamAt(0); // var dataWriter = new Windows.Storage.Streams.DataWriter(outputStream); // dataWriter.WriteString(contentText); // await dataWriter.StoreAsync(); // await outputStream.FlushAsync(); //} #endregion }
public async Task SaveMetaInfo(string key) { Windows.Storage.StorageFolder localFolder = Windows.Storage.ApplicationData.Current.LocalFolder; var file = await localFolder.CreateFileAsync(key + ChmMetaFileExtension, CreationCollisionOption.OpenIfExists); await SaveMetaInfo(file); }
/// <summary> /// Writes a string to a text file. /// </summary> /// <param name="text">The text to write.</param> /// <param name="fileName">Name of the file.</param> /// <param name="folder">The folder.</param> /// <param name="options"> /// The enum value that determines how responds if the fileName is the same /// as the name of an existing file in the current folder. Defaults to ReplaceExisting. /// </param> /// <returns></returns> public static async Task SaveAsync( this string text, string fileName, StorageFolder folder = null, CreationCollisionOption options = CreationCollisionOption.ReplaceExisting) { folder = folder ?? ApplicationData.Current.LocalFolder; var file = await folder.CreateFileAsync( fileName, options); using (var fs = await file.OpenAsync(FileAccessMode.ReadWrite)) { using (var outStream = fs.GetOutputStreamAt(0)) { using (var dataWriter = new DataWriter(outStream)) { if (text != null) dataWriter.WriteString(text); await dataWriter.StoreAsync(); dataWriter.DetachStream(); } await outStream.FlushAsync(); } } }
private async void CleanHistoryBtn_Click(object sender, RoutedEventArgs e) { Windows.Storage.StorageFolder localFolder = await Windows.Storage.ApplicationData.Current.LocalFolder.CreateFolderAsync("OCR_UKW_Project", Windows.Storage.CreationCollisionOption.OpenIfExists); var DataFile = await localFolder.CreateFileAsync("OCR_UKW_Project_UserData.txt", CreationCollisionOption.OpenIfExists); try { StorageFolder OCRFolder = await ApplicationData.Current.LocalFolder.GetFolderAsync("OCR_UKW_Project"); if (OCRFolder != null) { await OCRFolder.DeleteAsync(StorageDeleteOption.PermanentDelete); ApplicationData.Current.LocalSettings.Values[LBoxHistory.Name] = 0; } } catch (Exception ex) { Windows.UI.Popups.MessageDialog msg = new Windows.UI.Popups.MessageDialog(ex.ToString()); await msg.ShowAsync(); } LBoxHistory.Items.Clear(); this.Frame.Navigate(typeof(MainPage)); }
public async Task autoSaveMap() { try { String now = DateTime.Now.ToString("yyyyMMddHHmmssfff"); Windows.Storage.StorageFolder localFolder = Windows.Storage.ApplicationData.Current.LocalFolder; if (localFolder != null) { IReadOnlyList <StorageFile> dirFiles = await localFolder.GetFilesAsync(); if (dirFiles != null) { if (dirFiles.Count > maxAutoSaves) { String filename = dirFiles.First().Name; StorageFile firstfile = await localFolder.GetFileAsync(filename); await firstfile.DeleteAsync(); } } String name = "Autosave" + now + ".ppm"; Windows.Storage.StorageFile file = await localFolder.CreateFileAsync(name); filemanager.WriteFile(path, file); } } catch (Exception e) { System.Diagnostics.Debug.WriteLine("Autosave failed: Message:" + e.Message); } }
public static async Task OutputSensorDataAsync() { // ファイルの作成 すでに存在する場合は置き換える Windows.Storage.StorageFolder documentsLibrary = KnownFolders.DocumentsLibrary; Windows.Storage.StorageFile file = await documentsLibrary.CreateFileAsync(sensorDataFileName, Windows.Storage.CreationCollisionOption.ReplaceExisting); // ファイルへの書き込み var stream = await file.OpenAsync(Windows.Storage.FileAccessMode.ReadWrite); using (var outputStream = stream.GetOutputStreamAt(0)) { using (var dataWriter = new Windows.Storage.Streams.DataWriter(outputStream)) { dataWriter.WriteString("valueX valueY valueZ time\n"); if (Sensor_Values_Record_Time_List != null) { for (int i = 0; i < Sensor_Values_Record_Time_List.Count; i++) { dataWriter.WriteString($"{Math.Round(Sensor_ValueX_List[i], 3)} {Math.Round(Sensor_ValueY_List[i], 3)} {Math.Round(Sensor_ValueZ_List[i], 3)} {Math.Round(Sensor_Values_Record_Time_List[i], 2)}\n"); } } await dataWriter.StoreAsync(); await outputStream.FlushAsync(); } } stream.Dispose(); // Or use the stream variable (see previous code snippet) with a using statement as well. }
private async void download(object sender, RoutedEventArgs e) { var item = listview.SelectedItem as CloudBlockBlob; var blob = App.container.GetBlockBlobReference(item.Name); StorageFile file; try { if (listview.SelectedIndex != -1) { file = await temporaryFolder.CreateFileAsync(item.Name, CreationCollisionOption.ReplaceExisting); using (var fileStream = await file.OpenStreamForWriteAsync()) { var outputstream = fileStream.AsOutputStream(); //Hither InMemoryRandomAccessStream decstream = new InMemoryRandomAccessStream(); System.IO.Stream netstream = System.IO.WindowsRuntimeStreamExtensions.AsStreamForRead(decstream); //Hence Stream saveStr = new System.IO.MemoryStream(); IOutputStream winStr = System.IO.WindowsRuntimeStreamExtensions.AsOutputStream(saveStr); // var bufferstream = outputstream.AsStreamForWrite(UInt16.MaxValue); await blob.DownloadToStreamAsync(winStr); saveStr.Position = 0; saveStr.CopyTo(fileStream); fileStream.Flush(); } // Make sure it's an image file. imgbox.Source = new BitmapImage(new Uri(file.Path)); IbState.Text = "Success\n" + file.Path; } } catch (Exception ex) { IbState.Text += (ex.Message + "\n"); } }
private async void RenderInkImageAsync() { IReadOnlyList <InkStroke> currentStrokes = inkCanvas.InkPresenter.StrokeContainer.GetStrokes(); if (currentStrokes.Count > 0) { Windows.Storage.StorageFolder storageFolder = Windows.Storage.ApplicationData.Current.TemporaryFolder; Windows.Storage.StorageFile file = await storageFolder.CreateFileAsync($"{Guid.NewGuid()}.png", Windows.Storage.CreationCollisionOption.ReplaceExisting); if (file != null) { Windows.Storage.CachedFileManager.DeferUpdates(file); IRandomAccessStream stream = await file.OpenAsync(Windows.Storage.FileAccessMode.ReadWrite); using (IOutputStream outputStream = stream.GetOutputStreamAt(0)) { await inkCanvas.InkPresenter.StrokeContainer.SaveAsync(outputStream); await outputStream.FlushAsync(); } stream.Dispose(); } BitmapImage bm = new BitmapImage(new Uri($"ms-appdata:///temp/{file.Name}")); App.ViewModel.SelectedDocument.AnnotationImage = bm; } Frame.GoBack(); }
public async Task itializeClass() { QueueCycleMilliSeconds = 500; this.folder = Windows.Storage.ApplicationData.Current.LocalFolder; try { this.file = folder.CreateFileAsync("SparkQueueDB.txt", CreationCollisionOption.OpenIfExists).AsTask().Result; } catch (Exception ex) { this.Errors.Add("Queue Failed To Initialize"); this.Errors.Add(ex.Message.ToString()); } inboundQueue = new Queue(); outboundQueue = new Queue(); //if (Program.strPowerOuttageMissedDownEvent.Length > 1) //{ // this.Enqueue(Program.strPowerOuttageMissedDownEvent); // Program.strPowerOuttageMissedDownEvent = ""; //} InboundDataTimer = new Timer(new TimerCallback(ProcessInboundEvent), new Object(), 250, 250); OutboundDataTimer = new Timer(new TimerCallback(ProcessOutboundEvent), new Object(), 250, 250); this.file = null; this.folder = null; }
private async void Button_Click(object sender, RoutedEventArgs e) { var folderpicker = new Windows.Storage.Pickers.FolderPicker(); folderpicker.SuggestedStartLocation = Windows.Storage.Pickers.PickerLocationId.ComputerFolder; folderpicker.FileTypeFilter.Add("*"); Windows.Storage.StorageFolder folder = await folderpicker.PickSingleFolderAsync(); string pathstr = folder.Path; Windows.Storage.StorageFile file = await folder.CreateFileAsync("sample.txt", CreationCollisionOption.GenerateUniqueName); List <string> output = new List <string>(); foreach (StorageFile sfile in await folder.GetFilesAsync()) { output.Add(sfile.Name + "\n"); } stores.ItemsSource = output; if (!string.IsNullOrEmpty(path.Text) && !string.IsNullOrWhiteSpace(path.Text)) { //string Path = path.Text; //DataAccess.AddData(Path); //StoreDirectories.Stores = await DataAccess.GetStores(); //stores.ItemsSource = StoreDirectories.Stores; } }
private async void Button_Click_1(object sender, RoutedEventArgs e) { using (var captureStream = new InMemoryRandomAccessStream()) { var pngProperties = ImageEncodingProperties.CreatePng(); //pngProperties.Width = (uint)pictureBox1.Width; //pngProperties.Height = (uint)pictureBox1.Height; pngProperties.Width = (uint)PreviewFrameImage.ActualWidth; pngProperties.Height = (uint)PreviewFrameImage.ActualHeight; AddLog("キャプチャ開始"); //await mediaCapture.CapturePhotoToStreamAsync(pngProperties, captureStream); Windows.Storage.StorageFolder storageFolder = await StorageFolder.GetFolderFromPathAsync(Environment.GetFolderPath(Environment.SpecialFolder.Desktop)); Windows.Storage.StorageFile sampleFile = await storageFolder.CreateFileAsync("sample.bmp", Windows.Storage.CreationCollisionOption.ReplaceExisting); //await mediaCapture.CapturePhotoToStorageFileAsync(ImageEncodingProperties.CreatePng(), sampleFile); captureStream.Seek(0); AddLog("AsStream"); //ビットマップにして表示 System.IO.Stream stream = System.IO.WindowsRuntimeStreamExtensions.AsStream(captureStream); var img = System.Drawing.Bitmap.FromStream(stream); //this.pictureBox1.Image = img; //img.Save(Environment.SpecialFolder.Desktop + @"\aaa.bmp"); AddLog("表示"); // 画面に表示 var a = System.Windows.Media.Imaging.BitmapFrame.Create(stream, System.Windows.Media.Imaging.BitmapCreateOptions.None, System.Windows.Media.Imaging.BitmapCacheOption.OnLoad); PreviewFrameImage.Source = a; } }
/// <summary> /// 向AppData中的rtf文本中写入string /// </summary> /// <param name="fileName">AppData目录下的文件名,需要带拓展名</param> /// <param name="content">要写入的内容</param> /// <param name="tag">要选择的模式</param> /// <returns>文本信息</returns> public async Task SetStringToFile(string fileName, string content, int tag) { //ExportFile Service Windows.Storage.Pickers.FileSavePicker savePicker = new Windows.Storage.Pickers.FileSavePicker(); savePicker.SuggestedStartLocation = Windows.Storage.Pickers.PickerLocationId.DocumentsLibrary; // Dropdown of file types the user can save the file as savePicker.FileTypeChoices.Add("Rich Text", new List <string>() { ".rtf" }); // Default file name if the user does not type one in or select a file to replace savePicker.SuggestedFileName = "New Document"; Windows.Storage.StorageFolder storageFolder = Windows.Storage.ApplicationData.Current.LocalFolder; Windows.Storage.StorageFile file; if (tag == 1) { file = await storageFolder.CreateFileAsync(fileName, Windows.Storage.CreationCollisionOption.ReplaceExisting); } else { file = await storageFolder.GetFileAsync(fileName); } if (file != null) { System.IO.File.WriteAllText(file.Path, content); await new Windows.UI.Popups.MessageDialog("添加成功").ShowAsync(); } }
private async System.Threading.Tasks.Task StoreURLDataAsync(String url, String price) { Windows.Storage.StorageFolder storageFolder = Windows.Storage.ApplicationData.Current.LocalFolder; Windows.Storage.StorageFile file = await storageFolder.CreateFileAsync("urls.txt", Windows.Storage.CreationCollisionOption.OpenIfExists); await Windows.Storage.FileIO.AppendTextAsync(file, url + " -br- " + price); }
private async void lvwBlobs_ItemClick(object sender, ItemClickEventArgs e) { var item = e.ClickedItem as CloudBlockBlob; var blob = App.container.GetBlockBlobReference(item.Name); StorageFile file; try { Windows.Storage.StorageFolder temporaryFolder = ApplicationData.Current.TemporaryFolder; file = await temporaryFolder.CreateFileAsync(item.Name, CreationCollisionOption.ReplaceExisting); // ProcessBegin(); var downloadTask = blob.DownloadToFileAsync(file); await downloadTask; //downloadTask.Completed = (IAsyncAction asyncInfo, AsyncStatus asyncStatus) => //{ // ProcessEnd(); //}; // Make sure it's an image file. imgBlobItem.Source = new BitmapImage(new Uri(file.Path)); } catch (Exception ex) { statusAzure.Text = (ex.Message + "\n"); } }
public async void PrintPDF(Memo memo) { Reports = new Reports(memo); //var stream = new InMemoryRandomAccessStream(); //FileSavePicker fileSavePicker = new FileSavePicker(); WriterFormat format = WriterFormat.PDF; //fileSavePicker.SuggestedFileName = "ExportReport"; //var savedItem = await fileSavePicker.PickSaveFileAsync(); //if (savedItem != null) // Windows.Storage.StorageFolder storageFolder = Windows.Storage.ApplicationData.Current.LocalFolder; Windows.Storage.StorageFile savedItem = await storageFolder.CreateFileAsync("sample.pdf", Windows.Storage.CreationCollisionOption.ReplaceExisting); //var savedItem = await FileSavePicker.PickSaveFileAsync(); MemoryStream exportFileStream = new MemoryStream(); Assembly assembly = typeof(HomePage).GetTypeInfo().Assembly; // Ensure the report loaction and application name. Stream reportStream = assembly.GetManifestResourceStream("UwpApp.Report.Inv.rdlc"); BoldReports.UI.Xaml.ReportDataSourceCollection datas = new BoldReports.UI.Xaml.ReportDataSourceCollection(); datas.Add(new BoldReports.UI.Xaml.ReportDataSource { Name = "PatientInfo", Value = Reports.LoadReport() }); datas.Add(new BoldReports.UI.Xaml.ReportDataSource { Name = "MemoDetails", Value = Reports.loadmemodetail() }); ReportWriter writer = new ReportWriter(reportStream, datas); writer.ExportMode = ExportMode.Local; await writer.SaveASync(exportFileStream, format); try { using (IRandomAccessStream stream = await savedItem.OpenAsync(FileAccessMode.ReadWrite)) { // Write compressed data from memory to file using (Stream outstream = stream.AsStreamForWrite()) { byte[] buffer = exportFileStream.ToArray(); outstream.Write(buffer, 0, buffer.Length); outstream.Flush(); } } exportFileStream.Dispose(); } catch { } }
private async void save_Click(object sender, RoutedEventArgs e) { bool seen = false; for (int i = 0; i < dropdown.Items.Count; i++) { if (groupname == (string)(dropdown.Items[i] as ComboBoxItem).Content) { seen = true; } } if (!seen) { ComboBoxItem TI = new ComboBoxItem(); TI.Content = groupname; dropdown.Items.Add(TI); Windows.Storage.StorageFolder storageFolder = Windows.Storage.ApplicationData.Current.LocalFolder; Windows.Storage.StorageFile sampleFile = await storageFolder.CreateFileAsync("videos" + groupname + ".txt", Windows.Storage.CreationCollisionOption.ReplaceExisting); await Windows.Storage.FileIO.WriteTextAsync(sampleFile, vids.Text); } else { Windows.Storage.StorageFolder storageFolder = Windows.Storage.ApplicationData.Current.LocalFolder; Windows.Storage.StorageFile sampleFile = await storageFolder.CreateFileAsync("videos" + groupname + ".txt", Windows.Storage.CreationCollisionOption.ReplaceExisting); await Windows.Storage.FileIO.WriteTextAsync(sampleFile, vids.Text); return; } }
/// <summary> /// 创建并获取当前文件(临时文件夹) /// </summary> /// <param name="FileName"></param> /// <returns></returns> public async Task <Windows.Storage.StorageFile> CreatFile(string FileName) { Windows.Storage.StorageFolder storageFolder = Windows.Storage.ApplicationData.Current.TemporaryFolder; Windows.Storage.StorageFile sampleFile = await storageFolder.CreateFileAsync(FileName, Windows.Storage.CreationCollisionOption.ReplaceExisting); return(await storageFolder.GetFileAsync(FileName)); }
private async void Button_Click(object sender, RoutedEventArgs e) { /*参考文档: https://docs.microsoft.com/zh-cn/windows/uwp/files/quickstart-using-file-and-folder-pickers */ var picker = new Windows.Storage.Pickers.FileOpenPicker(); picker.ViewMode = Windows.Storage.Pickers.PickerViewMode.Thumbnail; picker.SuggestedStartLocation = Windows.Storage.Pickers.PickerLocationId.PicturesLibrary; picker.FileTypeFilter.Add("*"); Windows.Storage.StorageFolder storageFolder = Windows.Storage.ApplicationData.Current.LocalFolder; Windows.Storage.StorageFile imagefile = await storageFolder.CreateFileAsync("avatar", CreationCollisionOption.ReplaceExisting); imagefile = await picker.PickSingleFileAsync(); if (imagefile != null) //若选中了图片,则将该图片填充头像,并保存图像地址 { imgpath = imagefile.Path; localSettings.Containers[username.Text].Values["avatar"] = imgpath; ImageBrush brush = new ImageBrush(); BitmapImage bitmap = new BitmapImage(); using (var stream = await imagefile.OpenAsync(FileAccessMode.ReadWrite)) //需要使用文件流才能访问storagefile图片路径 { bitmap.SetSource(stream); } brush.ImageSource = bitmap; Avator.Fill = brush; } }
//save sessin to file: public static async void SaveSession() { if (InstaApi == null) { return; } if (!InstaApi.IsUserAuthenticated) { return; } _lastUser = _user; // Create file; replace if exists. Windows.Storage.StorageFolder storageFolder = Windows.Storage.ApplicationData.Current.LocalFolder; // mage mikhai chand ta id azash login koni hamzaman? are // bish az 5 ta bashe block mishi, dah ta 1a dare // dah ta yeka dare yani che:| 10 ta ja dare, bedone moshkel Windows.Storage.StorageFile File = await storageFolder.CreateFileAsync(_user + ".txt", Windows.Storage.CreationCollisionOption.ReplaceExisting); await Windows.Storage.FileIO.WriteTextAsync(File, InstaApi.GetStateDataAsString()); localSettings.Values["ihaveaaccount"] = "yes"; localSettings.Values["LastUser"] = _lastUser; }
/// <summary> /// 新账号数据保存 /// 参考文档 https://jingyan.baidu.com/article/67508eb47a05499cca1ce430.html /// </summary> /// <param name="id"></param> public async static Task <int> NewAccount(string uid) { if (uid != null) { Windows.Storage.StorageFolder storageFolder = Windows.Storage.ApplicationData.Current.LocalFolder; //调用API,获取本地存储文件夹对象 Windows.Storage.StorageFile serializeFile = await storageFolder.CreateFileAsync(uid + ".bat", CreationCollisionOption.ReplaceExisting); //创建本地存储文件对象,模式为覆盖 try { Stream fs = await serializeFile.OpenStreamForWriteAsync(); //创建文件写入的数据流对象(异步方法) using (XmlDictionaryWriter xdw = XmlDictionaryWriter.CreateTextWriter(fs, Encoding.UTF8)) { DataContractSerializer dcs = new DataContractSerializer(typeof(Dictionary <string, Contacts>)); dcs.WriteObject(xdw, new Dictionary <string, Contacts>()); } return(1); //无异常,返回值为1 } catch (Exception e) { var dialog = new MessageDialog(""); dialog.Content = "Create New Accout Exception"; await dialog.ShowAsync(); return(0); // 出现异常,返回值为0 } } else { return(0); } }
public static async Task WriteNewLogAsync(StorageFile file, StorageFolder folder, string fileName, string logString) { if (!(await FileUtil.DoesFileExistAsync(file, folder, fileName))) { file = await folder.CreateFileAsync(fileName); } await FileIO.AppendTextAsync(file, logString + Environment.NewLine); }
public static async Task<StorageFile> SetFile(StorageFolder folder, string fileName) { StorageFile file = null; if (!(await DoesFileExistAsync(file, folder, fileName))) { file = await folder.CreateFileAsync(fileName); } return file; }
async public static Task ZipFolder(StorageFolder sourceFolder, StorageFolder destnFolder, string zipFileName) { StorageFile zipFile = await destnFolder.CreateFileAsync(zipFileName, CreationCollisionOption.ReplaceExisting); Stream zipToCreate = await zipFile.OpenStreamForWriteAsync(); ZipArchive archive = new ZipArchive(zipToCreate, ZipArchiveMode.Update); await ZipFolderContents(sourceFolder, archive, sourceFolder.Path); archive.Dispose(); }
public async void download(String url, Folder folder) { var uri = new Uri(url); var downloader = new BackgroundDownloader(); StorageFile file = await folder.CreateFileAsync("100MB.zip", CreationCollisionOption.ReplaceExisting); DownloadOperation download = downloader.CreateDownload(uri, file); download.StartAsync(); }
public async static Task SaveAsync(this InkCanvas inkCanvas, string fileName, StorageFolder folder = null) { folder = folder ?? ApplicationData.Current.TemporaryFolder; var file = await folder.CreateFileAsync(fileName, CreationCollisionOption.ReplaceExisting); if (inkCanvas.InkPresenter.StrokeContainer.GetStrokes().Any()) { using (var stream = await file.OpenAsync(FileAccessMode.ReadWrite)) { await inkCanvas.InkPresenter.StrokeContainer.SaveAsync(stream); } } }
/// <summary> /// 要下载调用这个方法 /// </summary> /// <param name="url">下载的文件网址的来源</param> /// <returns></returns> public static async Task Start(string filename,string url,DownloadType type,StorageFolder folder=null) { try { Uri uri = new Uri(Uri.EscapeUriString(url), UriKind.RelativeOrAbsolute); BackgroundDownloader downloader = new BackgroundDownloader(); if (folder==null) { folder = await KnownFolders.MusicLibrary.CreateFolderAsync("kgdownload", CreationCollisionOption.OpenIfExists); switch (type) { case DownloadType.song: folder = await folder.CreateFolderAsync("song", CreationCollisionOption.OpenIfExists); downloader.TransferGroup = BackgroundTransferGroup.CreateGroup("song"); break; case DownloadType.mv: folder = await folder.CreateFolderAsync("mv", CreationCollisionOption.OpenIfExists); downloader.TransferGroup = BackgroundTransferGroup.CreateGroup("mv"); break; case DownloadType.other: folder = await folder.CreateFolderAsync("other", CreationCollisionOption.OpenIfExists); downloader.TransferGroup = BackgroundTransferGroup.CreateGroup("other"); break; default: break; } }else { downloader.TransferGroup = BackgroundTransferGroup.CreateGroup("other"); } //string name = uri.ToString().Substring(uri.ToString().LastIndexOf("/"), uri.ToString().Length); string name = filename; StorageFile file = await folder.CreateFileAsync(name, CreationCollisionOption.GenerateUniqueName); downloader.FailureToastNotification = DownloadedToast.Done(filename, DownloadedToast.DownResult.Fa); downloader.SuccessToastNotification = DownloadedToast.Done(filename, DownloadedToast.DownResult.Su); var download = downloader.CreateDownload(new Uri(url), file); TransferModel transfer = new TransferModel(); transfer.DownloadOperation = download; transfer.Source = download.RequestedUri.ToString(); transfer.Destination = download.ResultFile.Path; transfer.BytesReceived = download.Progress.BytesReceived; transfer.TotalBytesToReceive = download.Progress.TotalBytesToReceive; transfer.Progress = 0; transfers.Add(transfer); Progress<DownloadOperation> progressCallback = new Progress<DownloadOperation>(DownloadProgress); download.StartAsync().AsTask(cancelToken.Token, progressCallback); } catch { await new MessageDialog("链接已失效!").ShowAsync(); } }
internal async static Task MergeFolders(StorageFolder source, StorageFolder target) { foreach (StorageFile sourceFile in await source.GetFilesAsync()) { await sourceFile.CopyAndReplaceAsync(await target.CreateFileAsync(sourceFile.Name, CreationCollisionOption.OpenIfExists)); } foreach (StorageFolder sourceDirectory in await source.GetFoldersAsync()) { StorageFolder nextTargetSubDir = await target.CreateFolderAsync(sourceDirectory.Name, CreationCollisionOption.OpenIfExists); await MergeFolders(sourceDirectory, nextTargetSubDir); } }
private static async Task<IEnumerable<City>> CreateDefaultFileOfCities(StorageFolder folder) { var file = await folder.CreateFileAsync(SETTING_KEY); var cities = new City[] { new City() { Name="Namur", Country="Belgique" } }; await FileIO.WriteTextAsync(file, SerializeToJson(cities)); return cities; }
private static async Task<string> RenderPage(Windows.Data.Pdf.PdfPage page, StorageFolder output) { var pagePath = string.Format("{0}.png", page.Index); var pageFile = await output.CreateFileAsync(pagePath, CreationCollisionOption.ReplaceExisting); using (var imageStream = await pageFile.OpenAsync(FileAccessMode.ReadWrite)) { PdfPageRenderOptions pdfPageRenderOptions = new PdfPageRenderOptions(); pdfPageRenderOptions.IsIgnoringHighContrast = false; await page.RenderToStreamAsync(imageStream, pdfPageRenderOptions); await imageStream.FlushAsync(); } return output.Path.ToFolderPath() + pagePath; }
private async static Task<StorageFile> SaveAsync( Uri fileUri, StorageFolder folder, string fileName) { var file = await folder.CreateFileAsync(fileName, CreationCollisionOption.ReplaceExisting); var downloader = new BackgroundDownloader(); var download = downloader.CreateDownload( fileUri, file); var res = await download.StartAsync(); return file; }
public async static Task SaveAsync( Uri fileUri, StorageFolder folder, string fileName) { // Hitting System.UnauthorizedAccessException when the file already exists. // If they already have it, keep what is there. var file = await folder.CreateFileAsync(fileName, CreationCollisionOption.OpenIfExists); var downloader = new BackgroundDownloader(); var download = downloader.CreateDownload( fileUri, file); await download.StartAsync(); }
public async void Setup() { Folder = ApplicationData.Current.LocalFolder; //połącz do pliku jesli istnieje try { File = await Folder.GetFileAsync("json.txt"); } //utwórz gdy go nie ma catch { File = await Folder.CreateFileAsync("json.txt"); } }
public static async Task SaveImageAsyncFromUri(string filename, StorageFolder folder, Uri url, CreationCollisionOption option) { if(folder != null) { StorageFile file = await folder.CreateFileAsync(filename, option); HttpClient client = new HttpClient(); byte[] fileContent = await client.GetByteArrayAsync(url); Stream fileStream = await file.OpenStreamForWriteAsync(); fileStream.Write(fileContent, 0, fileContent.Length); fileStream.Flush(); fileStream.Dispose(); } }
private static async Task InflateEntryAsync(ZipArchiveEntry entry, StorageFolder destFolder, bool createSub = false) { string filePath = entry.FullName; if (!string.IsNullOrEmpty(filePath) && filePath.Contains("/") && !createSub) { // Create sub folder string subFolderName = Path.GetDirectoryName(filePath); StorageFolder subFolder; // Create or return the sub folder. subFolder = await destFolder.CreateFolderAsync(subFolderName, CreationCollisionOption.OpenIfExists); string newFilePath = Path.GetFileName(filePath); if (!string.IsNullOrEmpty(newFilePath)) { // Unzip file iteratively. await InflateEntryAsync(entry, subFolder, true); } } else { // Read uncompressed contents using (Stream entryStream = entry.Open()) { byte[] buffer = new byte[entry.Length]; entryStream.Read(buffer, 0, buffer.Length); // Create a file to store the contents StorageFile uncompressedFile = await destFolder.CreateFileAsync(entry.Name, CreationCollisionOption.ReplaceExisting); // Store the contents using (IRandomAccessStream uncompressedFileStream = await uncompressedFile.OpenAsync(FileAccessMode.ReadWrite)) { using (Stream outstream = uncompressedFileStream.AsStreamForWrite()) { outstream.Write(buffer, 0, buffer.Length); outstream.Flush(); } } } } }
public async void DownDanMu(string cid, StorageFolder folder) { try { wc = new WebClientClass(); string results = await wc.GetResults(new Uri("http://comment.bilibili.com/" + cid + ".xml")); //将弹幕存在在应用文件夹 //StorageFolder folder = ApplicationData.Current.LocalFolder; //StorageFolder DowFolder = await KnownFolders.VideosLibrary.CreateFolderAsync("Bili-Download", CreationCollisionOption.OpenIfExists); StorageFile fileWrite = await folder.CreateFileAsync(cid + ".xml", CreationCollisionOption.ReplaceExisting); await FileIO.WriteTextAsync(fileWrite, results); } catch (Exception) { //return null; } }
/// <summary> /// Saves the WriteableBitmap to a file in the given folder with the given file name. /// </summary> /// <param name="writeableBitmap">The writeable bitmap.</param> /// <param name="storageFolder">The storage folder.</param> /// <param name="fileName">Name of the file.</param> /// <param name="options"> /// The enum value that determines how responds if the fileName is the same /// as the name of an existing file in the current folder. Defaults to ReplaceExisting. /// </param> /// <returns></returns> public static async Task<StorageFile> SaveToFile( this WriteableBitmap writeableBitmap, StorageFolder storageFolder, string fileName, CreationCollisionOption options = CreationCollisionOption.ReplaceExisting) { StorageFile outputFile = await storageFolder.CreateFileAsync( fileName, options); Guid encoderId; var ext = Path.GetExtension(fileName); if (new[] { ".bmp", ".dib" }.Contains(ext)) { encoderId = BitmapEncoder.BmpEncoderId; } else if (new[] { ".tiff", ".tif" }.Contains(ext)) { encoderId = BitmapEncoder.TiffEncoderId; } else if (new[] { ".gif" }.Contains(ext)) { encoderId = BitmapEncoder.GifEncoderId; } else if (new[] { ".jpg", ".jpeg", ".jpe", ".jfif", ".jif" }.Contains(ext)) { encoderId = BitmapEncoder.JpegEncoderId; } else if (new[] { ".hdp", ".jxr", ".wdp" }.Contains(ext)) { encoderId = BitmapEncoder.JpegXREncoderId; } else //if (new [] {".png"}.Contains(ext)) { encoderId = BitmapEncoder.PngEncoderId; } await writeableBitmap.SaveToFile(outputFile, encoderId); return outputFile; }
public static async Task<StorageFile> CreateFileAsync(string path, StorageFolder 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) .ConfigureAwait(false); } return await folder.CreateFileAsync(fileName, option).AsTask().ConfigureAwait(false); }
// This is a private method, and does not require synchronization. We assume caller is // already holding the lock. private static async Task<StorageFile> GetOrCreateFileAsync(StorageFolder storageFolder, string fileName) { StorageFile storageFile = null; try { Debug.WriteLine("File location: {0}", storageFolder.Path); storageFile = await storageFolder.GetFileAsync(fileName); } catch (FileNotFoundException) { Debug.WriteLine("File not found: {0}", fileName); } if (storageFile == null) { storageFile = await storageFolder.CreateFileAsync(fileName); } return storageFile; }
private async Task RStorage(StorageFolder folder) { //name //作者 //简介 //目录 //脚注 string emptyStr = "<!--{0}-->\r\n"; StringBuilder str = new StringBuilder(); //<!--目录--> str.Append(string.Format(emptyStr, "name")); str.Append(folder.Name + "\r\n"); str.Append(string.Format(emptyStr, "name")); str.Append(string.Format(emptyStr, "作者")); str.Append(AuthoStr + "\r\n"); str.Append(string.Format(emptyStr, "作者")); str.Append(string.Format(emptyStr, "简介")); str.Append(Introduction); str.Append(string.Format(emptyStr, "简介")); str.Append(string.Format(emptyStr, "目录")); foreach (var temp in FolderStorage) { str.Append(string.Format("[{0}]({1})\r\n", temp.Name, temp.FolderStorage.Path.Replace( folder.Path, "."))); } str.Append(string.Format(emptyStr, "目录")); str.Append(string.Format(emptyStr, "脚注")); str.Append(Artis); str.Append(string.Format(emptyStr, "脚注")); StorageFile file = await folder.CreateFileAsync("README.md", CreationCollisionOption.ReplaceExisting); await FileIO.WriteTextAsync(file, str.ToString()); }
private static async void CreateFile(StorageFolder folder, string fileName) { await folder.CreateFileAsync(fileName, CreationCollisionOption.OpenIfExists); }
public static async Task CreateFile(string filename, StorageFolder folder) { // Create sample file; replace if exists. StorageFile sampleFile = await folder.CreateFileAsync(filename, CreationCollisionOption.ReplaceExisting); }
/// <summary> /// Private Methods & Testing Methods. /// </summary> private async Task<StorageFile> CreateFileToLocalStorageAsync(string path, StorageFolder folder) { string name; string[] list = ParseHelper.ParsePathAndName(path, ParseHelper.Mode.FULL_PATH, out name); // changed DIRECTORY to FULL_PATH foreach (string s in list) { folder = await folder.CreateFolderAsync(s, CreationCollisionOption.OpenIfExists); } return await folder.CreateFileAsync(name, CreationCollisionOption.OpenIfExists); }
public async Task<StorageFile> CreateFile(StorageFolder folder, string filename, CreationCollisionOption option) { return await folder.CreateFileAsync(filename, option); }
public static async Task<bool> AddDownload(string filename, string url, DownloadType type, StorageFolder folder = null) { try { var down = new BackgroundDownloader(); down.TransferGroup = BackgroundTransferGroup.CreateGroup("other"); if (folder == null) { folder = await KnownFolders.MusicLibrary.GetFolderAsync("kgdownload"); switch (type) { case DownloadType.song: folder = await folder.GetFolderAsync("song"); down.TransferGroup = BackgroundTransferGroup.CreateGroup("song"); break; case DownloadType.mv: folder = await folder.GetFolderAsync("mv"); down.TransferGroup = BackgroundTransferGroup.CreateGroup("mv"); break; case DownloadType.other: folder = await folder.GetFolderAsync("other"); down.TransferGroup = BackgroundTransferGroup.CreateGroup("other"); break; default: break; } } var files= (await folder.GetFilesAsync()).ToList(); foreach (var item in files) { await item.DeleteAsync(); } var file = await folder.CreateFileAsync(filename); down.FailureToastNotification = DownloadToast(filename, DownloadResult.Failure); down.SuccessToastNotification = DownloadToast(filename, DownloadResult.Success); var opera= down.CreateDownload(new Uri(url), file); opera.CostPolicy = BackgroundTransferCostPolicy.Always; opera.StartAsync(); return true; } catch (Exception) { return false; } }
private async static Task<StorageFile> GetFile(StorageFolder folder) { return await folder.CreateFileAsync("PowerOuttageHandler.txt", CreationCollisionOption.ReplaceExisting); }