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