public static async Task SaveStringAsFile(string content, storage.StorageFile file) { using (var stream = await file.OpenStreamForWriteAsync()) { await storage.FileIO.WriteTextAsync(file, content); } }
public static async Task<bool> WriteTextIntoFileAsync(string text, StorageFile file) { try { if (file != null) { using (var fileStream = await file.OpenStreamForWriteAsync().ConfigureAwait(false)) { using (var writer = new StreamWriter(fileStream)) { fileStream.SetLength(0); // avoid leaving crap at the end if overwriting a file that was longer fileStream.Seek(0, SeekOrigin.Begin); await writer.WriteAsync(text).ConfigureAwait(false); await fileStream.FlushAsync(); await writer.FlushAsync(); return true; } } } } catch (Exception ex) { await Logger.AddAsync(ex.ToString(), Logger.FileErrorLogFilename).ConfigureAwait(false); } return false; }
/// <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 SaveBytesAsFile(byte[] bytes, storage.StorageFile file) { using (var stream = await file.OpenStreamForWriteAsync()) { await stream.WriteAsync(bytes, 0, bytes.Length); } }
private async Task Download(string url,StorageFile file,bool cover) { var http = new HttpClient(); byte[] response = { }; string betterUrl = url; if(cover) { var pos = betterUrl.IndexOf(".jpg"); if (pos != -1) betterUrl = betterUrl.Insert(pos, "l"); } //get bytes try { await Task.Run(async () => response = await http.GetByteArrayAsync(betterUrl)); } catch (Exception) { await Task.Run(async () => response = await http.GetByteArrayAsync(url)); } var fs = await file.OpenStreamForWriteAsync(); //get stream var writer = new DataWriter(fs.AsOutputStream()); writer.WriteBytes(response); //write await writer.StoreAsync(); await writer.FlushAsync(); writer.Dispose(); }
public async Task SaveConfigurationsToFileAsync(IEnumerable<ServiceConfiguration> configurations, StorageFile storageFile) { string data = await _serializer.SerializeAsync(configurations.ToArray()); using (Stream stream = await storageFile.OpenStreamForWriteAsync()) { await _zipper.WriteCompressedDataToStreamAsync(stream, data); } }
public static Task RendererImageAsync(StorageFile file, SvgImageRendererSettings settings, CancellationToken token) { return ThreadPool.RunAsync(_ => { using (var stream = file.OpenStreamForWriteAsync().GetAwaiter().GetResult()) { RendererImage(stream, settings); } }).AsTask(token); }
protected static async Task<Stream> GetStreamBasedOnDirection(StorageFile file, TransferDirection direction) { switch (direction) { case TransferDirection.Up: return await file.OpenStreamForReadAsync(); case TransferDirection.Down: return await file.OpenStreamForWriteAsync(); } return null; }
public static async void SetTagsSharp(TagsPackage tagsPck, StorageFile file, int nRetries = 5) //Using TagLibSharp { try { var fileStream = await file.OpenStreamForWriteAsync(); var tagFile = TagLib.File.Create(new StreamFileAbstraction(file.Name, fileStream, fileStream)); tagFile.Tag.Title = tagsPck.title; tagFile.Tag.Performers = new[] {tagsPck.artist}; tagFile.Tag.Album = tagsPck.album; if (tagsPck.ThumbSource != null) { TagLib.Id3v2.AttachedPictureFrame pic = new TagLib.Id3v2.AttachedPictureFrame { TextEncoding = StringType.Latin1, Type = PictureType.FrontCover }; var uri = new Uri(tagsPck.ThumbSource); if (!uri.IsFile) { var rass = RandomAccessStreamReference.CreateFromUri(uri); IRandomAccessStream stream = await rass.OpenReadAsync(); pic.Data = ByteVector.FromStream(stream.AsStream()); pic.MimeType = "image/jpeg"; stream.Dispose(); } else { StorageFile thumb = await StorageFile.GetFileFromPathAsync(tagsPck.ThumbSource); var thumbStream = await thumb.OpenStreamForReadAsync(); pic.Data = ByteVector.FromFile(new StreamFileAbstraction("Cover", thumbStream, thumbStream)); pic.MimeType = thumb.Name.Contains(".png") ? "image/png" : "image/jpeg"; thumbStream.Dispose(); } tagFile.Tag.Pictures = new IPicture[1] {pic}; } tagFile.Save(); fileStream.Dispose(); } catch (Exception exc) { Debug.WriteLine("TagsProcessing : " + exc.Message); await Task.Delay(TimeSpan.FromSeconds(5)); if (nRetries >= 0) SetTagsSharp(tagsPck, file, nRetries - 1); } }
async private void SaveWithFilepickerAndDownload(object sender, RoutedEventArgs e) { var 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("Video", new List <string>() { ".mp4", ".mkv" }); // Default file name if the user does not type one in or select a file to replace savePicker.SuggestedFileName = "New File"; Windows.Storage.StorageFile file = await savePicker.PickSaveFileAsync(); if (file != null) { // Prevent updates to the remote version of the file until // we finish making changes and call CompleteUpdatesAsync. Windows.Storage.CachedFileManager.DeferUpdates(file); var stream = await file.OpenStreamForWriteAsync(); getYoutubeFileProps(stream); // write to file // await Windows.Storage.FileIO.WriteTextAsync(file, file.Name); // Let Windows know that we're finished changing the file so // the other app can update the remote version of the file. // Completing updates may require Windows to ask for user input. Windows.Storage.Provider.FileUpdateStatus status = await Windows.Storage.CachedFileManager.CompleteUpdatesAsync(file); if (status == Windows.Storage.Provider.FileUpdateStatus.Complete) { this.StatusText.Text = "File " + file.Name + " was saved."; Debug.WriteLine("File created Successfully. Download started"); } else { this.StatusText.Text = "File " + file.Name + " couldn't be saved."; } } else { this.StatusText.Text = "Operation cancelled."; } }
private async void write() { try { file = await ApplicationData.Current.LocalFolder.CreateFileAsync(filename, CreationCollisionOption.ReplaceExisting); using (Stream stream = await file.OpenStreamForWriteAsync()) { new DataContractJsonSerializer(typeof(ObservableCollection<Music>)) .WriteObject(stream, collection); } } catch { } }
public async Task WriteMenuCardToFileAsync(MenuCard menuCard, StorageFile storageFile) { var menuCardData = new MenuCardData(menuCard); var knownTypes = new Type[] { typeof(MenuItemData) }; var cardStream = new MemoryStream(); var serializer = new DataContractSerializer(typeof(MenuCardData), knownTypes); serializer.WriteObject(cardStream, menuCardData); using (Stream fileStream = await storageFile.OpenStreamForWriteAsync()) { cardStream.Seek(0, SeekOrigin.Begin); await cardStream.CopyToAsync(fileStream); await fileStream.FlushAsync(); } }
public async Task<StorageFile> DownloadFileToStorageAsync(string filename, Uri source, StorageFile outputFile) { using (HttpClient client = new HttpClient()) { byte[] buffer = await client.GetByteArrayAsync(source); // Download file filename = filename != "/" ? filename : Guid.NewGuid().ToString(); outputFile = await ApplicationData.Current.LocalFolder.CreateFileAsync(filename, CreationCollisionOption.ReplaceExisting); // TODO: Autodelete guids after eg. 2 weeks using (Stream stream = await outputFile.OpenStreamForWriteAsync()) { stream.Write(buffer, 0, buffer.Length); } } return outputFile; }
/// <summary> /// Saves a string to a file using the WP8 APIs - not supported in WP7.1 /// </summary> /// <param name="logData">string data to save</param> public async static Task SaveToLocalFolderAsync(List <LogData> lista) { // Get a reference to the Local Folder Windows.Storage.StorageFolder localFolder = Windows.Storage.ApplicationData.Current.LocalFolder; // Create the file in the local folder, or if it already exists, just open it Windows.Storage.StorageFile storageFile = await localFolder.CreateFileAsync("Stool.store", CreationCollisionOption.OpenIfExists); Stream writeStream = await storageFile.OpenStreamForWriteAsync(); using (var writer = new BinaryWriter(writeStream)) { writer.Write(lista.Count); foreach (var el in lista) { //writer.Write(el.Log); writer.Write(el.Log); writer.Write(el.DateTime.ToString()); } } }
private async void SerializeQuotes(DeskQuote[] quotes) { string path = ".\\quotes.json"; int width = Convert.ToInt32(this.widthInput.Text); int depth = Convert.ToInt32(this.depthInput.Text); int drawers = Convert.ToInt32(this.numDrawers.Text); Desk desk = new Desk(width, depth, drawers, (Desk.DesktopMaterial)materialChoice.SelectedValue); DeskQuote current = new DeskQuote(this.nameBox.Text, (int)this.rushOrderDays.SelectedValue, desk); //Windows.Storage.StorageFolder storageFolder = Windows.Storage.ApplicationData.Current.LocalFolder; //Windows.Storage.StorageFile sampleFile = await storageFolder.GetFileAsync(path); // var stream = await sampleFile.OpenAsync(Windows.Storage.FileAccessMode.ReadWrite); List <DeskQuote> deskQuoteList = new List <DeskQuote>(); foreach (DeskQuote quote in quotes) { deskQuoteList.Add(quote); } deskQuoteList.Add(current); var json = JsonConvert.SerializeObject(deskQuoteList); Windows.Storage.StorageFolder storageFolder = Windows.Storage.ApplicationData.Current.LocalFolder; Windows.Storage.StorageFile file = await storageFolder.CreateFileAsync( path, Windows.Storage.CreationCollisionOption.ReplaceExisting); //StorageFile file = await StorageFile.GetFileFromApplicationUriAsync(new Uri("ms-appdata:///local/quotes.json")); using (Stream stream = await file.OpenStreamForWriteAsync()) { byte[] toBytes = Encoding.UTF8.GetBytes(json.ToString()); await stream.WriteAsync(toBytes, 0, toBytes.Length); } this.deskQuote = current; }
public static async Task <List <string> > saveCollectionAsync() { var roamingFolder = Windows.Storage.ApplicationData.Current.RoamingFolder; Windows.Storage.StorageFile collectionFile = await roamingFolder.CreateFileAsync("Collected.txt", CreationCollisionOption.ReplaceExisting); Stream collectionStream = await collectionFile.OpenStreamForWriteAsync(); using (StreamWriter writer = new StreamWriter(collectionStream)) { foreach (string collectedCommand in collection) { await writer.WriteAsync(collectedCommand + "\n"); } //string collectedCommand; //while ((collectedCommand = reader.ReadLine()) != null) //{ // collection.Add(collectedCommand); // Add to list. //} } return(collection); }
public static async Task writeBinaryASync(object value, StorageFile file) { var s = await file.OpenStreamForWriteAsync(); writeBinary(value, s); }
/// <summary> /// Serialises the data from the In-Memory context, represented by the /// UnitOfWork, to the underlying XML file. /// </summary> /// <param name="UnitOfWork">The instance of the Music Collection being persisted</param> /// <param name="dataFile">The instance of the XML source file</param> /// <returns>A Task so that the call runs asynchronously</returns> public static async Task Serialise(IUnitOfWork UnitOfWork, StorageFile dataFile) { // Now serialise the MusicCollection Albums only as XML and write to the file. using (StreamWriter writer = new StreamWriter(await dataFile.OpenStreamForWriteAsync())) { XmlSerializer serialiser = new XmlSerializer(typeof(List<Album>)); serialiser.Serialize(writer, UnitOfWork.Albums); } }
public static async Task SerializeToFileAsync(Object obj, Type objectType, StorageFile file) { try { AppEventSource.Log.Debug("Suspension: Serializing object..." + objectType.ToString()); // Serialize the session state synchronously to avoid asynchronous access to shared state MemoryStream viewerData = new MemoryStream(); DataContractSerializer serializer = new DataContractSerializer(objectType); serializer.WriteObject(viewerData, obj); AppEventSource.Log.Debug("Suspension: Object serialized to memory. " + objectType.ToString()); // Get an output stream for the SessionState file and write the state asynchronously using (Stream fileStream = await file.OpenStreamForWriteAsync()) { viewerData.Seek(0, SeekOrigin.Begin); await viewerData.CopyToAsync(fileStream); } AppEventSource.Log.Debug("Suspension: Object saved to file. " + file.Name); } catch (Exception e) { AppEventSource.Log.Error("Suspension: Error when serializing object. Exception: " + e.Message); MessageDialog messageDialog = new MessageDialog("Error when saving" + objectType.ToString() + " to file: " + file.Name + "\n" + e.Message); messageDialog.Commands.Add(new UICommand("OK", null, 0)); await messageDialog.ShowAsync(); } }
public static async Task HttpGetFileAsync(string url, StorageFile targetFile, Action<int, int> progressAction, CancellationToken token = new CancellationToken()) { using (var httpFilter = new HUwpHttpFilter()) using (var client = new HttpClient(httpFilter)) using (var response = await client.SendRequestAsync(new HttpRequestMessage(HttpMethod.Get, new Uri(url)), HttpCompletionOption.ResponseHeadersRead)) { response.EnsureSuccessStatusCode(); using (var resStream = await response.Content.ReadAsInputStreamAsync()) using (var classicResStream = resStream.AsStreamForRead()) { var resContentLength = response.Content.Headers.ContentLength; using (var fileStream = await targetFile.OpenStreamForWriteAsync()) { var buf = new byte[1000000]; var offset = 0; fileStream.Seek(0, SeekOrigin.Begin); while (true) { int read = await classicResStream.ReadAsync(buf, 0, buf.Length, token); progressAction.Invoke(offset, (int)resContentLength); if (read <= 0) break; await fileStream.WriteAsync(buf, 0, read, token); offset += read; } progressAction.Invoke((int)resContentLength, (int)resContentLength); } } } }
private static async Task RemoveFileFromZipHelper(StorageFile zipFile, StorageFile file) { if ( zipFile == null || !Path.GetExtension(zipFile.Name) .Equals(".epub", StringComparison.OrdinalIgnoreCase) ) { throw new ArgumentException("Invalid argument..."); } Stream zipMemoryStream = await zipFile.OpenStreamForWriteAsync(); using (ZipArchive zipArchive = new ZipArchive(zipMemoryStream, ZipArchiveMode.Update)) { ZipArchiveEntry currentEntry = null; String fileName = "OEBPS/" + file.Name; // Unzip compressed file iteratively. foreach (ZipArchiveEntry entry in zipArchive.Entries) { if (entry.FullName == fileName) { currentEntry = entry; } } if (currentEntry != null) { currentEntry.Delete(); } zipArchive.Dispose(); } zipMemoryStream.Dispose(); }
/// <summary> /// Get the response stream returned by a HTTP get request and save it to a local file. /// </summary> /// <param name="uri">Uri to request.</param> /// <param name="targetFile">StorageFile to save the stream to.</param> /// <returns>True if success.</returns> public static async Task GetHttpStreamToStorageFileAsync( this Uri uri, StorageFile targetFile) { var content = await GetHttpContentAsync(uri); using (content) { using (var fileStream = await targetFile.OpenStreamForWriteAsync()) { var bytes = await content.Content.ReadAsByteArrayAsync(); await fileStream.WriteAsync(bytes, 0, bytes.Length); await fileStream.FlushAsync(); } } }
private static async Task AddFileToZipHelper(StorageFile zipFile, StorageFile file) { if ( zipFile == null || !Path.GetExtension(zipFile.Name) .Equals(".epub", StringComparison.OrdinalIgnoreCase) ) { throw new ArgumentException("Invalid argument..."); } Stream zipMemoryStream = await zipFile.OpenStreamForWriteAsync(); // Create zip archive to access compressed files in memory stream using (ZipArchive zipArchive = new ZipArchive(zipMemoryStream, ZipArchiveMode.Update)) { ZipArchiveEntry currentEntry = null; var fileName = "OEBPS/" + file.Name; // Unzip compressed file iteratively. foreach (ZipArchiveEntry entry in zipArchive.Entries) { Debug.WriteLine(entry.FullName); Debug.WriteLine(fileName); if (entry.FullName == fileName) { currentEntry = entry; } } if (currentEntry == null) { // make a new entry currentEntry = zipArchive.CreateEntry(fileName); } var contentType = file.ContentType; // TODO: catch other file types! using (var entryStream = currentEntry.Open()) using (BinaryWriter writer = new BinaryWriter(entryStream)) { IBuffer buffer = await FileIO.ReadBufferAsync(file); DataReader reader = DataReader.FromBuffer(buffer); byte[] fileContent = new byte[reader.UnconsumedBufferLength]; reader.ReadBytes(fileContent); writer.Write(fileContent); writer.Dispose(); reader.Dispose(); } zipArchive.Dispose(); } zipMemoryStream.Dispose(); }
private async Task<bool> removeDataFromFileAsync(string lineToRemove) { _removeDataLock.Wait(); bool result = false; StorageFolder folder = Windows.Storage.ApplicationData.Current.LocalFolder; StorageFile file = await folder.GetFileAsync("SparkQueueDB.txt"); var lines = new ArrayList(); using (var reader = new StreamReader(await file.OpenStreamForReadAsync())) { string line = ""; while ((line = reader.ReadLine()) != null) { lines.Add(line); } } try { file = await folder.CreateFileAsync("SparkQueueDB.txt", CreationCollisionOption.ReplaceExisting); using (StreamWriter writer = new StreamWriter(await file.OpenStreamForWriteAsync())) { foreach (var l in lines) { if (l.ToString() != lineToRemove) { writer.WriteLine(l); } else { Debug.WriteLine("LINE BEING REMOVED"); } } result = true; } } catch (Exception) { throw; } _removeDataLock.Release(); return result; }
private async void photoChooserTask_Completed(object sender, PhotoResult e) { // no photo selected if (e.ChosenPhoto == null) return; // get the file stream and file name Stream photoStream = e.ChosenPhoto; string fileName = Path.GetFileName(e.OriginalFileName); // persist data into isolated storage file = await ApplicationData.Current.LocalFolder.CreateFileAsync(fileName, CreationCollisionOption.ReplaceExisting); using (Stream current = await file.OpenStreamForWriteAsync()) { await photoStream.CopyToAsync(current); } // how to read the data later file = await ApplicationData.Current.LocalFolder.GetFileAsync(fileName); Stream imageStream = await file.OpenStreamForReadAsync(); // display the file as image BitmapImage bi = new BitmapImage(); bi.SetSource(imageStream); }
private async Task DownloadToFile(string url, StorageFile newFile, Action<int> onProgress) { var client = new HttpClient(); var operation = client.GetAsync(new Uri(url)); operation.Progress = (r, p) => { int percentage = 0; if (p.TotalBytesToReceive != null) percentage = (int)((p.BytesReceived / p.TotalBytesToReceive) * 100); onProgress?.Invoke(percentage); }; var resp = await operation; resp.EnsureSuccessStatusCode(); using (var writeStream = await newFile.OpenStreamForWriteAsync()) await resp.Content.WriteToStreamAsync(writeStream.AsOutputStream()); }
private async Task<bool> Save2Async(StorageFile file = null) { //for (int i = 0; i < 100000000; i++) //wait a few seconds, for testing //{ // String aaa = i.ToString(); //} await Logger.AddAsync("MetaBriefcase about to save", Logger.FileErrorLogFilename, Logger.Severity.Info).ConfigureAwait(false); bool result = false; // save xml properties try { _localDataSemaphore.WaitOne(); if (file == null) { file = await GetDirectory() .TryGetItemAsync(FILENAME).AsTask().ConfigureAwait(false) as StorageFile; } string savedData = string.Empty; if (file != null) { using (var localFileContent = await file.OpenStreamForReadAsync().ConfigureAwait(false)) { using (StreamReader streamReader = new StreamReader(localFileContent)) { savedData = streamReader.ReadToEnd(); } } } using (var memoryStream = new MemoryStream()) { var serializer = new DataContractSerializer(typeof(MetaBriefcase)); serializer.WriteObject(memoryStream, this); string currentMetaBriefcase = string.Empty; memoryStream.Seek(0, SeekOrigin.Begin); using (StreamReader streamReader = new StreamReader(memoryStream)) { currentMetaBriefcase = streamReader.ReadToEnd(); if (!currentMetaBriefcase.Trim().Equals(savedData.Trim())) { if (file == null) { file = await GetDirectory() .CreateFileAsync(FILENAME, CreationCollisionOption.ReplaceExisting).AsTask().ConfigureAwait(false); } using (var fileStream = await file.OpenStreamForWriteAsync().ConfigureAwait(false)) { fileStream.SetLength(0); // avoid leaving crap at the end if overwriting a file that was longer memoryStream.Seek(0, SeekOrigin.Begin); await memoryStream.CopyToAsync(fileStream).ConfigureAwait(false); await memoryStream.FlushAsync().ConfigureAwait(false); await fileStream.FlushAsync().ConfigureAwait(false); } } } } Debug.WriteLine("ended method MetaBriefcase.SaveAsync()"); result = true; } catch (Exception ex) { Logger.Add_TPL(ex.ToString(), Logger.FileErrorLogFilename); } finally { // save non-xml properties result = result & RegistryAccess.TrySetValue(ConstantData.REG_MBC_IS_ELEVATED, IsElevated.ToString()); SemaphoreExtensions.TryRelease(_localDataSemaphore); } return result; }
public async Task<bool> writePackageAsync(StorageFile file, Deck outDeck) { this.deck = outDeck; StorageFolder tmpFolder = ApplicationData.Current.TemporaryFolder; //create a MemoryStream to build ZipArchive in Memory using (MemoryStream zipStream = new MemoryStream()) { //Create ZipArchive using MemoryStream using (ZipArchive archive = new ZipArchive(zipStream,ZipArchiveMode.Create,true)) { //leave zipstream open so we can copy from it later. //Write File(s) to ZipArchive as entries //for every image referenced by a card, we'll need to copy them over String[] segments; ZipArchiveEntry en; foreach (Card c in this.deck.cards) { if (c.hasSideAImage()) { segments = c.sideAImage.UriSource.Segments; StorageFile inFile = await tmpFolder.GetFileAsync(segments[segments.Count() - 1]); //to be copied using (Stream s = await inFile.OpenStreamForReadAsync()) //incoming stream { en = archive.CreateEntry(segments[segments.Count() - 1]); using (Stream sout = en.Open()) //outgoing stream. Can't use en.Open() directly because it won't get properly disposed. { await s.CopyToAsync(sout); } } } if (c.hasSideBImage()) { segments = c.sideBImage.UriSource.Segments; StorageFile inFile = await tmpFolder.GetFileAsync(segments[segments.Count() - 1]); //to be copied using (Stream s = await inFile.OpenStreamForReadAsync()) //incoming stream { en = archive.CreateEntry(segments[segments.Count() - 1]); using (Stream sout = en.Open()) //outgoing stream. Can't use en.Open() directly because it won't get properly disposed. { await s.CopyToAsync(sout); } } } } //Then we write the deck description file deckToXml(); en = archive.CreateEntry("deckdescription.xml"); using (StreamWriter sw = new StreamWriter(en.Open())) { sw.Write(this.deckXml); } } //Copy MemoryStream (entire Zip Archive) to file specified zipStream.Position = 0; using (Stream s = await file.OpenStreamForWriteAsync()) { zipStream.CopyTo(s); } } return true; }
/// <summary> /// Writes INI data to a text file. /// </summary> /// <param name="file"> /// Path to the file. /// </param> /// <param name="parsedData"> /// IniData to be saved as an INI file. /// </param> /// <param name="fileEncoding"> /// Specifies the encoding used to create the file. /// </param> public async Task WriteFile(StorageFile file, IniData parsedData, Encoding fileEncoding = null) { // The default value can't be assigned as a default parameter value because it is not // a constant expression. if (fileEncoding == null) fileEncoding = Encoding.Unicode; if (parsedData == null) throw new ArgumentNullException("parsedData"); var stream = await file.OpenStreamForWriteAsync(); using (StreamWriter sr = new StreamWriter(stream, fileEncoding)) { WriteData(sr, parsedData); } }
public async Task WriteDataToFileAsync(StorageFile file, byte[] data) { using (var s = await file.OpenStreamForWriteAsync()) { await s.WriteAsync(data, 0, data.Length); } }