Faced the same. I ended up using a temporary file stream with random access.
This is copied from
windows.storage.applicationdata.temporaryfolder , which is not actually implemented, so I created the file in a local folder instead (be sure to delete it afterwards, since you want something temporary?).
and
windows.storage.streams.inmemoryrandomaccessstream
here is a slightly accepted code sample:
private async void TransferData()//object sender, RoutedEventArgs e) { Windows.Storage.StorageFolder temporaryFolder = ApplicationData.Current.LocalFolder; // Write data to a file StorageFile sampleFile = await temporaryFolder.CreateFileAsync("tempStream.txt", Windows.Storage.CreationCollisionOption.ReplaceExisting); IRandomAccessStream acccessStream = await sampleFile.OpenAsync(FileAccessMode.ReadWrite); // Initialize the in-memory stream where data will be stored. using (var stream = acccessStream) { // Create the data writer object backed by the in-memory stream. using (var dataWriter = new Windows.Storage.Streams.DataWriter(stream)) { dataWriter.UnicodeEncoding = Windows.Storage.Streams.UnicodeEncoding.Utf8; dataWriter.ByteOrder = Windows.Storage.Streams.ByteOrder.LittleEndian; // Parse the input stream and write each element separately. string[] inputElements = "this;really;works".Split(';'); foreach (string inputElement in inputElements) { uint inputElementSize = dataWriter.MeasureString(inputElement); dataWriter.WriteUInt32(inputElementSize); dataWriter.WriteString(inputElement); System.Diagnostics.Debug.WriteLine("Wrote: " + inputElement); } // Send the contents of the writer to the backing stream. await dataWriter.StoreAsync(); // For the in-memory stream implementation we are using, the flushAsync call // is superfluous,but other types of streams may require it. await dataWriter.FlushAsync(); // In order to prolong the lifetime of the stream, detach it from the // DataWriter so that it will not be closed when Dispose() is called on // dataWriter. Were we to fail to detach the stream, the call to // dataWriter.Dispose() would close the underlying stream, preventing // its subsequent use by the DataReader below. dataWriter.DetachStream(); } // Create the input stream at position 0 so that the stream can be read // from the beginning. using (var inputStream = stream.GetInputStreamAt(0)) { using (var dataReader = new Windows.Storage.Streams.DataReader(inputStream)) { // The encoding and byte order need to match the settings of the writer // we previously used. dataReader.UnicodeEncoding = Windows.Storage.Streams.UnicodeEncoding.Utf8; dataReader.ByteOrder = Windows.Storage.Streams.ByteOrder.LittleEndian; // Once we have written the contents successfully we load the stream. await dataReader.LoadAsync((uint)stream.Size); var receivedStrings = ""; // Keep reading until we consume the complete stream. while (dataReader.UnconsumedBufferLength > 0) { // Note that the call to readString requires a length of "code units" // to read. This is the reason each string is preceded by its length // when "on the wire". uint bytesToRead = dataReader.ReadUInt32(); receivedStrings += dataReader.ReadString(bytesToRead) + "\n"; } // Populate the ElementsRead text block with the items we read // from the stream. System.Diagnostics.Debug.WriteLine("Read: " + receivedStrings); } } } }
be sure to use windows.storage namespaces.
the key is the line:
IRandomAccessStream acccessStream = pending sampleFile.OpenAsync (FileAccessMode.ReadWrite);
I am not sure what the consequences of speed are.