/// <summary>
/// Save the stream into a PDF file with provided file name.
/// </summary>
public async static void Save(string filename, MemoryStream stream)
{
StorageFile stFile;
//Get process windows handle to open the dialog in application process.
IntPtr windowHandle = System.Diagnostics.Process.GetCurrentProcess().MainWindowHandle;
if (!Windows.Foundation.Metadata.ApiInformation.IsTypePresent("Windows.Phone.UI.Input.HardwareButtons"))
{
//Create file save picker to save a PDF file.
FileSavePicker savePicker = new FileSavePicker();
savePicker.DefaultFileExtension = ".pdf";
savePicker.SuggestedFileName = filename;
savePicker.FileTypeChoices.Add("PDF document files", new List <string>()
{
".pdf"
});
WinRT.Interop.InitializeWithWindow.Initialize(savePicker, windowHandle);
stFile = await savePicker.PickSaveFileAsync();
}
else
{
StorageFolder local = ApplicationData.Current.LocalFolder;
stFile = await local.CreateFileAsync(filename, CreationCollisionOption.ReplaceExisting);
}
if (stFile != null)
{
using (IRandomAccessStream zipStream = await stFile.OpenAsync(FileAccessMode.ReadWrite))
{
//Write compressed data from memory to file
using (Stream outstream = zipStream.AsStreamForWrite())
{
outstream.SetLength(0);
//Save the stream as PDF file.
byte[] buffer = stream.ToArray();
outstream.Write(buffer, 0, buffer.Length);
outstream.Flush();
}
}
//Create message dialog box.
MessageDialog msgDialog = new MessageDialog("Do you want to view the document?", "File created");
UICommand yesCmd = new UICommand("Yes");
msgDialog.Commands.Add(yesCmd);
UICommand noCmd = new UICommand("No");
msgDialog.Commands.Add(noCmd);
WinRT.Interop.InitializeWithWindow.Initialize(msgDialog, windowHandle);
//Showing a dialog box.
IUICommand cmd = await msgDialog.ShowAsync();
if (cmd.Label == yesCmd.Label)
{
// Launch the saved PDF file.
await Windows.System.Launcher.LaunchFileAsync(stFile);
}
}
}
public async Task SaveAsync(T Obj)
{
try
{
if (Obj != null)
{
StorageFile file = null;
StorageFolder folder = GetFolder(storageType);
if (string.IsNullOrEmpty(fileName))
{
fileName = FileName(Obj);
}
file = await folder.CreateFileAsync(fileName, CreationCollisionOption.ReplaceExisting);
IRandomAccessStream writeStream = await file.OpenAsync(FileAccessMode.ReadWrite);
Stream outStream = Task.Run(() => writeStream.AsStreamForWrite()).Result;
serializer.Serialize(outStream, Obj);
outStream.Dispose();
}
}
catch (System.Exception ex)
{
}
}
private async Task <StorageFile> SaveContract(Stream stream)
{
stream.Position = 0;
StorageFile stFile;
FileSavePicker fileSavePicker = new FileSavePicker();
fileSavePicker.SuggestedFileName = "SFPdfRTL";
fileSavePicker.FileTypeChoices.Add(".pdf", new List <string> {
".pdf"
});
fileSavePicker.SuggestedStartLocation = PickerLocationId.Desktop;
stFile = await fileSavePicker.PickSaveFileAsync();
if (stFile != null)
{
IRandomAccessStream fileStream = await stFile.OpenAsync(FileAccessMode.ReadWrite);
Stream st = fileStream.AsStreamForWrite();
st.SetLength(0);
st.Write((stream as MemoryStream).ToArray(), 0, (int)stream.Length);
st.Flush();
st.Dispose();
fileStream.Dispose();
}
return(stFile);
}
//保存图片到本地
private async void savePictureAppBarButton_Click(object sender, RoutedEventArgs e)
{
FileSavePicker fileSavePicker = new FileSavePicker();
fileSavePicker.SuggestedStartLocation = PickerLocationId.PicturesLibrary;
fileSavePicker.FileTypeChoices.Add("Picture", new List <string>()
{
".jpg"
});
fileSavePicker.SuggestedFileName = "image";
var outputFile = await fileSavePicker.PickSaveFileAsync();
if (outputFile == null)
{
// The user cancelled the picking operation
return;
}
//请求流文件保存即可保存高清图
HttpClient client = new HttpClient();
Stream Stream = await client.GetStreamAsync(new Uri(url));
using (IRandomAccessStream stream = await outputFile.OpenAsync(FileAccessMode.ReadWrite))
{
await Stream.CopyToAsync(stream.AsStreamForWrite());
}
}
/// <inheritdoc/>
public async Task <string> WriteFileAsync(Stream stream, string nameWithExt, string localDirName = null)
{
StorageFolder dir;
if (string.IsNullOrWhiteSpace(localDirName))
{
dir = ApplicationData.Current.LocalFolder;
}
else
{
dir = await ApplicationData.Current.LocalFolder.CreateFolderAsync(
localDirName,
CreationCollisionOption.OpenIfExists);
}
StorageFile storageFile = await dir.CreateFileAsync(
nameWithExt,
CreationCollisionOption.ReplaceExisting);
using IRandomAccessStream fileStream = await storageFile.OpenAsync(FileAccessMode.ReadWrite);
await stream.CopyToAsync(fileStream.AsStreamForWrite());
await fileStream.FlushAsync();
return(storageFile.Path);
}
/// <summary>
/// Store an instance of T to Windows.Storage.ApplicationData with a specified handle.
/// Specification of a handle supports storage and deletion of different instances of T.
/// </summary>
/// <param name="Obj">Object to be saved</param>
/// <param name="Handle">User-defined handle for the stored object</param>
public async Task SaveAsync(T Obj, string Handle)
{
if (Obj == null)
{
throw new ArgumentNullException("Obj");
}
if (Handle == null)
{
throw new ArgumentNullException("Handle");
}
StorageFile file = null;
string fileName = Handle;
StorageFolder folder = GetFolder(storageType);
file = await folder.CreateFileAsync(fileName, CreationCollisionOption.ReplaceExisting);
IRandomAccessStream writeStream = await file.OpenAsync(FileAccessMode.ReadWrite);
using (Stream outStream = Task.Run(() => writeStream.AsStreamForWrite()).Result)
{
serializer.Serialize(outStream, Obj);
await outStream.FlushAsync();
}
}
public async void UpdateAndClose(StorageFile storageFile, object obj)
{
using (IRandomAccessStream stream = await storageFile.OpenAsync(FileAccessMode.ReadWrite))
{
var binFormatter = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
using (Stream streamNew = stream.AsStreamForWrite())
{
if (obj is List <LibaryItem> )
{
binFormatter.Serialize(streamNew, ListOfItems);
}
else
{
throw new ArgumentException("invalid list");
}
if (obj is List <Employee> )
{
binFormatter.Serialize(streamNew, ListOfEmployees);
}
else
{
throw new ArgumentException("invalid list");
}
}
}
}
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 { }
}
/// <summary>
/// Saves all data that this repository has
/// </summary>
/// <param name="rootFolder">Folder in which to save the data</param>
public async Task Save(StorageFolder rootFolder)
{
StorageFolder modelFolder = await GetFolder(rootFolder);
// If all data was deleted then delete all the files
if (modelProperty().Count == 0)
{
// Create a new folder for this model, deleting the old one while it does
modelFolder = await rootFolder.CreateFolderAsync(ModelName + "s", CreationCollisionOption.ReplaceExisting);
}
// Loop each instance in the list
foreach (T model in modelProperty())
{
// Create an XmlSerializer for serializing the data
XmlSerializer xmlSerializer = new XmlSerializer(model.GetType());
// Create a file for the model
// We replace existing files so that it overwrites old data
StorageFile file = await modelFolder.CreateFileAsync(model.ID.ToString(), CreationCollisionOption.ReplaceExisting);
// A random access stream is used to push data to the file
IRandomAccessStream fileRandomAccessStream = await file.OpenAsync(FileAccessMode.ReadWrite);
// Used to disposing and flushing data which helps for memory conservation
IOutputStream fileOutputStream = fileRandomAccessStream.GetOutputStreamAt(0);
// Serialize the data to the file
xmlSerializer.Serialize(fileRandomAccessStream.AsStreamForWrite(), model);
// Dispose of and flush the file streams (Do flush asynchronously so it doesn't jam the thread)
fileRandomAccessStream.Dispose();
await fileOutputStream.FlushAsync();
fileOutputStream.Dispose();
}
}
public async Task <bool> SaveAsync(T Obj, string FileName)
{
FileName = FileName + ".xml";
try
{
if (Obj != null)
{
StorageFile file = null;
StorageFolder folder = GetFolder(storageType);
file = await folder.CreateFileAsync(FileName, CreationCollisionOption.ReplaceExisting);
using (IRandomAccessStream writeStream = await file.OpenAsync(FileAccessMode.ReadWrite))
{
using (Stream outStream = Task.Run(() => writeStream.AsStreamForWrite()).Result)
{
serializer.Serialize(outStream, Obj);
outStream.Dispose();
return(true);
}
}
}
}
catch (Exception)
{
throw;
}
return(false);
}
public static async Task <Boolean> SerializeToXmlFile <T>(string fileName, T serializationSource)
{
try
{
StorageFile file = await ApplicationData.Current.LocalFolder.CreateFileAsync(
fileName, CreationCollisionOption.ReplaceExisting);
using (IRandomAccessStream stream = await file.OpenAsync(FileAccessMode.ReadWrite))
{
DataContractSerializer serializer = new DataContractSerializer(typeof(T));
XmlWriterSettings settings = new XmlWriterSettings();
settings.Indent = true;
settings.NewLineHandling = NewLineHandling.Entitize;
XmlWriter writer = XmlWriter.Create(stream.AsStreamForWrite(), settings);
var ser = new XmlSerializer(typeof(T));
ser.Serialize(writer, serializationSource);
return(true);
}
}
catch (Exception e)
{
Debug.WriteLine(e.Message);
return(false);
}
}
public static async void Save(string filename)
{
StorageFile file = await ApplicationData.Current.LocalFolder.CreateFileAsync(filename, CreationCollisionOption.ReplaceExisting);
using (IRandomAccessStream writeStream = await file.OpenAsync(FileAccessMode.ReadWrite))
{
Stream s = writeStream.AsStreamForWrite();
XmlWriterSettings settings = new XmlWriterSettings();
settings.Async = true;
using (XmlWriter writer = XmlWriter.Create(s, settings))
{
writer.WriteStartDocument();
writer.WriteStartElement("Problems");
foreach (TrafficProblem problem in Problems)
{
writer.WriteStartElement("Problem");
writer.WriteElementString("Reason", problem.Reason);
writer.WriteEndElement();
}
writer.WriteEndElement();
writer.WriteEndDocument();
await writer.FlushAsync();
}
}
}
public async void WriteToXmlFileAsync(Person person)
{
StorageFolder storageFolder = KnownFolders.DocumentsLibrary;
StorageFile storageFile = await storageFolder.GetFileAsync("xmluppgift_1.xml");
using (IRandomAccessStream streamWriter = await storageFile.OpenAsync(FileAccessMode.ReadWrite))
{
Stream stream = streamWriter.AsStreamForWrite();
XmlWriterSettings settings = new XmlWriterSettings()
{
Indent = true,
IndentChars = (" "),
CloseOutput = true
};
using (XmlWriter xmlWriter = XmlWriter.Create(stream, settings))
{
xmlWriter.WriteStartElement($"person");
xmlWriter.WriteElementString($"FirstName", $"{ person.FirstName}");
xmlWriter.WriteElementString($"LastName", $"{ person.LastName}");
xmlWriter.WriteElementString($"Age", $"{ person.Age}");
xmlWriter.WriteElementString($"Email", $"{ person.Email}");
xmlWriter.Flush();
}
}
}
/// <summary>
/// Get file stream from bytes array
/// </summary>
/// <param name="bytes">Serialized stream</param>
/// <returns>File random access stream</returns>
private async Task <IRandomAccessStream> bytesToStream(byte[] bytes)
{
StorageFile file;
IRandomAccessStream filestream = null;
try
{
file = await KnownFolders.MusicLibrary.GetFileAsync("RecievedFile");
await file.DeleteAsync(StorageDeleteOption.PermanentDelete);
}
catch (Exception ex)
{
}
finally
{
try
{
file = await KnownFolders.MusicLibrary.CreateFileAsync("RecievedFile");
filestream = await file.OpenAsync(FileAccessMode.ReadWrite);
await filestream.AsStreamForWrite().WriteAsync(bytes, 0, bytes.Length);
}
catch (Exception)
{
//something goes wrong
}
}
return(filestream);
}
private async void GenerateStream()
{
_accessStream = await _file.OpenAsync(FileAccessMode.ReadWrite);
_classicStream = _accessStream.AsStreamForWrite();
_streamWriter = new StreamWriter(_classicStream, _encoding);
}
private async Task DoWork(IBackgroundTaskInstance taskInstance)
{
var settings = ApplicationData.Current.RoamingSettings;
string text = "";
foreach (var item in ApplicationData.Current.RoamingSettings.Values)
{
text += item.ToString();
}
string typeFile = (string)settings.Values["typeFile"];
ApplicationData.Current.RoamingSettings.Values.Clear();
StorageFile stFile;
StorageFolder localFolder = Windows.Storage.ApplicationData.Current.TemporaryFolder;
stFile = await localFolder.CreateFileAsync("temp.txt", CreationCollisionOption.ReplaceExisting);
if (stFile != null)
{
using (IRandomAccessStream zipStream = await stFile.OpenAsync(FileAccessMode.ReadWrite))
{
using (Stream outstream = zipStream.AsStreamForWrite())
{
byte[] buffer = System.Text.Encoding.Default.GetBytes(text);
outstream.Write(buffer, 0, buffer.Length);
outstream.Flush();
}
}
}
}
public WindowsUniversalFileStream(string fileName, StorageFolder directory, FileAccessMode mode, CreationCollisionOption collisionOptions, StorageOpenOptions openOptions, int length = 1024 * 80, int writeBufferSize = 1024 * 80, int readBufferSize = 1024 * 80)
{
if (fileName == null || fileName == string.Empty)
{
throw new ArgumentNullException("path");
}
Directory = directory;
FileName = fileName;
Mode = mode;
CollisionOptions = collisionOptions;
OpenOptions = openOptions;
WriteBufferSize = writeBufferSize;
ReadBufferSize = readBufferSize;
RandomAccessStream = Directory.CreateFileAsync(FileName, collisionOptions).AsTask().Result.OpenAsync(mode, openOptions).AsTask().Result;
ReadStream = RandomAccessStream.AsStreamForRead(ReadBufferSize);
ReadStream.SetLength(length);
if (mode == FileAccessMode.ReadWrite)
{
WriteStream = RandomAccessStream.AsStreamForWrite(WriteBufferSize);
}
}
private async void button2_Click(object sender, RoutedEventArgs e)
{
//Create file open picker and set the .pdf file type.
FileOpenPicker openPicker = new FileOpenPicker();
openPicker.SuggestedStartLocation = PickerLocationId.DocumentsLibrary;
openPicker.ViewMode = PickerViewMode.List;
openPicker.FileTypeFilter.Add(".pdf");
//Get process windows handle to open the dialog in application process.
IntPtr windowHandle = System.Diagnostics.Process.GetCurrentProcess().MainWindowHandle;
WinRT.Interop.InitializeWithWindow.Initialize(openPicker, windowHandle);
//Pick the single file.
StorageFile stFile = await openPicker.PickSingleFileAsync();
if (stFile != null)
{
//Get the file name and update the file name in textbox.
SecondPdf.Text = stFile.Name;
//Read the PDF file as file stream.
IRandomAccessStream fileStream = await stFile.OpenAsync(FileAccessMode.ReadWrite);
secondDocumentStream = fileStream.AsStreamForWrite();
}
}
public static async Task <StorageFile> WriteableBitmapToStorageFile(ushort[,] image, bool isScaleValues, List <KeyValuePair <string, string> > metadata)
{
//Setup image maxVal.
var imgHeight = image.GetLength(0);
var imgWidth = image.GetLength(1);
float maxVal = 1;
if (isScaleValues)
{
for (int i = 0; i < imgHeight; i++)
{
for (int j = 0; j < imgWidth; j++)
{
if (maxVal < image[i, j])
{
maxVal = image[i, j];
}
}
}
}
string FileName = "MyFile.png";
var file =
await
Windows.Storage.ApplicationData.Current.TemporaryFolder.CreateFileAsync(FileName,
CreationCollisionOption.GenerateUniqueName);
using (IRandomAccessStream stream = await file.OpenAsync(FileAccessMode.ReadWrite))
{
ImageInfo imgInfo = new ImageInfo(imgWidth, imgHeight, 16, false, true, false);
PngWriter wrt = new PngWriter(stream.AsStreamForWrite(), imgInfo);
PngMetadata da = wrt.GetMetadata();
foreach (var item in metadata)
{
if (item.Value != null)
{
da.SetText(item.Key, item.Value);
}
}
ImageLines imLines = new ImageLines(imgInfo, ImageLine.ESampleType.INT, false, 0, imgHeight, 1);
for (int i = 0; i < imLines.ImgInfo.Rows; i++)
{
for (int j = 0; j < imLines.ImgInfo.Cols; j++)
{
if (isScaleValues)
{
imLines.Scanlines[i][j] = (ushort)(ushort.MaxValue * (double)image[i, j] / maxVal);
}
else
{
imLines.Scanlines[i][j] = image[i, j];
}
}
}
wrt.WriteRowsInt(imLines.Scanlines);
wrt.End();
}
return(file);
}
/// <summary>
/// Unzips ZipArchiveEntry asynchronously.
/// </summary>
/// <param name="entry">The entry which needs to be unzipped</param>
/// <param name="filePath">The entry's full name</param>
/// <param name="unzipFolder">The unzip folder</param>
/// <returns></returns>
private static async Task UnzipZipArchiveEntryAsync(ZipArchiveEntry entry, string filePath, StorageFolder unzipFolder)
{
if (IfPathContainDirectory(filePath))
{
// Create sub folder
string subFolderName = Path.GetDirectoryName(filePath);
bool isSubFolderExist = await IfFolderExistsAsync(unzipFolder, subFolderName);
StorageFolder subFolder;
if (!isSubFolderExist)
{
// Create the sub folder.
subFolder =
await unzipFolder.CreateFolderAsync(subFolderName, CreationCollisionOption.ReplaceExisting);
}
else
{
// Just get the folder.
subFolder =
await unzipFolder.GetFolderAsync(subFolderName);
}
// All sub folders have been created yet. Just pass the file name to the Unzip function.
string newFilePath = Path.GetFileName(filePath);
if (!string.IsNullOrEmpty(newFilePath))
{
// Unzip file iteratively.
await UnzipZipArchiveEntryAsync(entry, newFilePath, subFolder);
}
}
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 unzipFolder.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 Task SaveAsXmlAsync <T>(storage.StorageFile file) where T : VMBase
{
xmlser.XmlSerializer ser = new xmlser.XmlSerializer(typeof(T));
using (IRandomAccessStream myFileStream = await file.OpenAsync(storage.FileAccessMode.ReadWrite))
{
Stream wStream = myFileStream.AsStreamForWrite();
ser.Serialize(wStream, this);
}
}
/// <summary>
/// method to compress files
/// </summary>
public async void Compress()
{
// Retrieve files to compress
// Created new file to store compressed files
//This will create a file under the selected folder in the name “Compressed.zip”
StorageFile zipFile = await SelectedFolder.CreateFileAsync("Compressed.zip", CreationCollisionOption.ReplaceExisting);
// Create stream to compress files in memory (ZipArchive can't stream to an IRandomAccessStream, see
// http://social.msdn.microsoft.com/Forums/en-US/winappswithcsharp/thread/62541424-ba7d-43d3-9585-1fe53dc7d9e2
// for details on this issue)
using (MemoryStream zipMemoryStream = new MemoryStream())
{
InProgress = true;
// Create zip archive
using (ZipArchive zipArchive = new ZipArchive(zipMemoryStream, ZipArchiveMode.Create))
{
// For each file to compress...
foreach (StorageFile fileToCompress in filesToCompress)
{
BasicProperties fileProp = await fileToCompress.GetBasicPropertiesAsync();
if (fileProp.Size > 0)
{
//Read the contents of the file
byte[] buffer = WindowsRuntimeBufferExtensions.ToArray(await FileIO.ReadBufferAsync(fileToCompress));
string fileEntry = fileToCompress.Path.Replace(zipFile.Path.Replace(zipFile.Name, string.Empty), string.Empty);
// Create a zip archive entry
ZipArchiveEntry entry = zipArchive.CreateEntry(fileEntry, CompressionLevelSelected);
// And write the contents to it
using (Stream entryStream = entry.Open())
{
await entryStream.WriteAsync(buffer, 0, buffer.Length);
}
}
}
}
using (IRandomAccessStream zipStream = await zipFile.OpenAsync(FileAccessMode.ReadWrite))
{
// Write compressed data from memory to file
using (Stream outstream = zipStream.AsStreamForWrite())
{
byte[] buffer = zipMemoryStream.ToArray();
outstream.Write(buffer, 0, buffer.Length);
outstream.Flush();
}
}
InProgress = false;
StatusMessage = "Files Zipped...";
}
}
public void SetScoreData(string data)
{
StorageFile file = ApplicationData.Current.LocalFolder.CreateFileAsync(scoreFilePath, CreationCollisionOption.ReplaceExisting).GetResults();
IRandomAccessStream writeStream = file.OpenAsync(FileAccessMode.ReadWrite).GetResults();
using (Stream outStream = Task.Run(() => writeStream.AsStreamForWrite()).Result)
using (var tw = new StreamWriter(outStream))
{
tw.WriteAsync(data).Wait();
}
}
public async Task WriteExcuseAsync()
{
using (IRandomAccessStream stream = await excuseFile.OpenAsync(FileAccessMode.ReadWrite))
using (Stream outputStream = stream.AsStreamForWrite())
{
DataContractSerializer serializer = new DataContractSerializer(typeof(Excuse));
serializer.WriteObject(outputStream, CurrentExcuse);
}
await new MessageDialog("Excuse written to " + excuseFile.Name).ShowAsync();
await UpdateFileDateAsync();
}
public static async Task saveAllSettingsAsync(StorageFile file, ApplicationSettings settings)
{
IRandomAccessStream stream = await file.OpenAsync(FileAccessMode.ReadWrite);
string str = JsonConvert.SerializeObject((ApplicationSettings)settings);
StreamWriter writer = new StreamWriter(stream.AsStreamForWrite());
writer.Write(str);
writer.Flush();
writer.Close();
}
private static async Task WriteToVoiceCommandDefinitionAsync(IEnumerable <Contact> contacts)
{
try
{
//create file in public folder
StorageFolder storageFolder = ApplicationData.Current.LocalFolder;
StorageFile publicVoiceCommandFile = await storageFolder.CreateFileAsync("VoiceCommandDefinition.xml", CreationCollisionOption.ReplaceExisting);
Uri uri = new Uri("ms-appx:///Common/Cortana/VoiceCommandDefinition.xml");
StorageFile privateVoiceCommandFile = await StorageFile.GetFileFromApplicationUriAsync(uri);
string stringData = await FileIO.ReadTextAsync(privateVoiceCommandFile);
//write sring to created file
await FileIO.WriteTextAsync(publicVoiceCommandFile, stringData);
}
catch (Exception ex)
{
Debug.WriteLine("error: " + ex);
}
//StorageFile myFile = await ApplicationData.Current.LocalFolder.GetFileAsync("Cortana/VoiceCommandDefinition.xml");
StorageFile vcf = await ApplicationData.Current.LocalFolder.GetFileAsync("VoiceCommandDefinition.xml");
using (IRandomAccessStream writeStream = await vcf.OpenAsync(FileAccessMode.ReadWrite))
{
XNamespace defaultNs = "http://schemas.microsoft.com/voicecommands/1.2";
// convert IRandomAccessStream to IO.Stream
Stream s = writeStream.AsStreamForWrite();
//xml
XDocument document = XDocument.Load(s);
var element = document.Root.Elements().FirstOrDefault();
element.Add(new XElement(defaultNs + "PhraseList", new XAttribute("Label", "nutzer")));
var PhraseList = element.Element(defaultNs + "PhraseList");
foreach (var item in contacts)
{
PhraseList.Add(new XElement("Item", item.Name));
}
s.Seek(0, SeekOrigin.Begin);
document.Save(s);
}
////get asets folder
//StorageFolder appInstalledFolder = Package.Current.InstalledLocation;
//StorageFolder assetsFolder = await appInstalledFolder.GetFolderAsync("Cortana");
////move file from public folder to assets
//await vcf.MoveAsync(assetsFolder, "VoiceCommandDefinition.xml", NameCollisionOption.ReplaceExisting);
}
public static async void Serialize <T>(IStorageFile file, T obj)
{
using (IRandomAccessStream stream = await file.OpenAsync(FileAccessMode.ReadWrite))
{
using (StreamWriter writer = new StreamWriter(stream.AsStreamForWrite(), Encoding.UTF8))
{
XmlSerializer xs = new XmlSerializer(typeof(T));
xs.Serialize(writer, obj);
}
}
}
public async void SaveGame(object sender, RoutedEventArgs e)
{
game.Time = DateTime.Now;
StorageFile f = await def.GetFileAsync("sgd.dat");
IRandomAccessStream iras = await f?.OpenAsync(FileAccessMode.ReadWrite);
iras.Size = 0;
//using (Stream s = Task.Run(() => iras.AsStreamForWrite()).Result) Serializer.Serialize(s, game);
using (Stream s = Task.Run(() => iras.AsStreamForWrite()).Result) serializer.Serialize(s, game);
SaveCard.Begin();
}
async Task <StorageFile> Save(MemoryStream stream, string filename)
{
stream.Position = 0;
StorageFile stFile;
//if (!(Windows.Foundation.Metadata.ApiInformation.IsTypePresent("Windows.Phone.UI.Input.HardwareButtons")))
//{
// FileSavePicker savePicker = new FileSavePicker();
// savePicker.DefaultFileExtension = ".docx";
// savePicker.SuggestedFileName = filename;
// savePicker.FileTypeChoices.Add("Word Documents", new List<string>() { ".docx" });
// stFile = await savePicker.PickSaveFileAsync();
//}
//else
//{
StorageFolder local = Windows.Storage.ApplicationData.Current.LocalFolder;
stFile = await local.CreateFileAsync(filename, CreationCollisionOption.ReplaceExisting);
//}
if (stFile != null)
{
using (IRandomAccessStream zipStream = await stFile.OpenAsync(FileAccessMode.ReadWrite))
{
// Write compressed data from memory to file
using (Stream outstream = zipStream.AsStreamForWrite())
{
byte[] buffer = stream.ToArray();
outstream.Write(buffer, 0, buffer.Length);
outstream.Flush();
}
}
}
return(stFile);
}
private async void writeToXml(SavedData savedData, string fileName)
{
XmlSerializer xmlSerializer = new XmlSerializer(savedData.GetType());
StorageFile file = await ApplicationData.Current.LocalFolder.CreateFileAsync(fileName, CreationCollisionOption.ReplaceExisting);
using (IRandomAccessStream writeStream = await file.OpenAsync(FileAccessMode.ReadWrite))
{
using (XmlWriter xmlWriter = XmlWriter.Create(writeStream.AsStreamForWrite()))
{
xmlSerializer.Serialize(xmlWriter, savedData);
}
}
}
