public ref class DataReader sealed : IClosable, IDataReader

/// [Windows.Foundation.Metadata.Activatable(Windows.Storage.Streams.IDataReaderFactory, 65536, Windows.Foundation.UniversalApiContract)]
/// [Windows.Foundation.Metadata.ContractVersion(Windows.Foundation.UniversalApiContract, 65536)]
/// [Windows.Foundation.Metadata.MarshalingBehavior(Windows.Foundation.Metadata.MarshalingType.Agile)]
/// [Windows.Foundation.Metadata.Threading(Windows.Foundation.Metadata.ThreadingModel.Both)]
class DataReader final : IClosable, IDataReader

/// [Windows.Foundation.Metadata.ContractVersion(Windows.Foundation.UniversalApiContract, 65536)]
/// [Windows.Foundation.Metadata.MarshalingBehavior(Windows.Foundation.Metadata.MarshalingType.Agile)]
/// [Windows.Foundation.Metadata.Threading(Windows.Foundation.Metadata.ThreadingModel.Both)]
/// [Windows.Foundation.Metadata.Activatable(Windows.Storage.Streams.IDataReaderFactory, 65536, "Windows.Foundation.UniversalApiContract")]
class DataReader final : IClosable, IDataReader

[Windows.Foundation.Metadata.Activatable(typeof(Windows.Storage.Streams.IDataReaderFactory), 65536, typeof(Windows.Foundation.UniversalApiContract))]
[Windows.Foundation.Metadata.ContractVersion(typeof(Windows.Foundation.UniversalApiContract), 65536)]
[Windows.Foundation.Metadata.MarshalingBehavior(Windows.Foundation.Metadata.MarshalingType.Agile)]
[Windows.Foundation.Metadata.Threading(Windows.Foundation.Metadata.ThreadingModel.Both)]
public sealed class DataReader : System.IDisposable, IDataReader

[Windows.Foundation.Metadata.ContractVersion(typeof(Windows.Foundation.UniversalApiContract), 65536)]
[Windows.Foundation.Metadata.MarshalingBehavior(Windows.Foundation.Metadata.MarshalingType.Agile)]
[Windows.Foundation.Metadata.Threading(Windows.Foundation.Metadata.ThreadingModel.Both)]
[Windows.Foundation.Metadata.Activatable(typeof(Windows.Storage.Streams.IDataReaderFactory), 65536, "Windows.Foundation.UniversalApiContract")]
public sealed class DataReader : System.IDisposable, IDataReader

function DataReader(inputStream)

Public NotInheritable Class DataReader
Implements IDataReader, IDisposable

下面的代码示例演示如何向内存中流写入和读取字符串。 有关 C# 和 C++/CX 中的完整示例应用程序，请参阅 序列化和反序列化数据示例 。

using System;
using System.Diagnostics;
using Windows.Foundation;
using Windows.UI.Xaml;
using Windows.UI.Xaml.Controls;
using Windows.UI.Xaml.Navigation;
// This is the click handler for the 'Copy Strings' button.  Here we will parse the
// strings contained in the ElementsToWrite text block, write them to a stream using
// DataWriter, retrieve them using DataReader, and output the results in the
// ElementsRead text block.
private async void TransferData(object sender, RoutedEventArgs e)
    // Initialize the in-memory stream where data will be stored.
    using (var stream = new Windows.Storage.Streams.InMemoryRandomAccessStream())
        // 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 = ElementsToWrite.Text.Split(';');
            foreach (string inputElement in inputElements)
                uint inputElementSize = dataWriter.MeasureString(inputElement);
                dataWriter.WriteUInt32(inputElementSize);
                dataWriter.WriteString(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.
                ElementsRead.Text = receivedStrings;
#include "pch.h"
#include "WriteReadStream.h" // header file for WriteReadStream.xaml.
#include <sstream>
#include <winrt/Windows.Foundation.h>
#include <winrt/Windows.Storage.Streams.h>
using namespace winrt;
std::array<winrt::hstring, 5> m_inputElements{ L"Hello", L"World", L"1 2 3 4 5", L"Très bien!", L"Goodbye" };
WriteReadStream::WriteReadStream()
    InitializeComponent();
    // Populate the text block with the input elements.
    std::wstringstream stringstream;
    for (winrt::hstring const& element : m_inputElements)
        stringstream << element.c_str() << L";";
    ElementsToWrite().Text(stringstream.str().c_str());
// This is the click handler for the 'Copy Strings' button. Here we will parse the
// strings contained in the ElementsToWrite text block, write them to a stream using
// DataWriter, retrieve them using DataReader, and output the results in the
// ElementsRead text block.
winrt::Windows::Foundation::IAsyncAction WriteReadStream::TransferData(
    Windows::Foundation::IInspectable const& /* sender */,
    Windows::UI::Xaml::RoutedEventArgs const& /* args */)
    // Initialize the in-memory stream where data will be stored.
    Windows::Storage::Streams::InMemoryRandomAccessStream stream;
    // Create the DataWriter object backed by the in-memory stream. When
    // dataWriter goes out of scope, it closes the underlying stream.
    Windows::Storage::Streams::DataWriter dataWriter{ stream };
    dataWriter.UnicodeEncoding(Windows::Storage::Streams::UnicodeEncoding::Utf16LE);
    dataWriter.ByteOrder(Windows::Storage::Streams::ByteOrder::LittleEndian);
    // Create the data reader by using the input stream set at position 0 so that 
    // the stream will be read from the beginning regardless of the position that
    // the original stream ends up in after the store.
    Windows::Storage::Streams::IInputStream inputStream{ stream.GetInputStreamAt(0) };
    Windows::Storage::Streams::DataReader dataReader{ inputStream };
    // The encoding and byte order need to match the settings of the writer that
    // we previously used.
    dataReader.UnicodeEncoding(Windows::Storage::Streams::UnicodeEncoding::Utf16LE);
    dataReader.ByteOrder(Windows::Storage::Streams::ByteOrder::LittleEndian);
    // Write the input data to the output stream. Serialize the elements by writing
    // each string separately, preceded by its length in bytes.
    for (winrt::hstring const& element : m_inputElements)
        dataWriter.WriteUInt32(element.size());
        dataWriter.WriteString(element);
    // Send the contents of the writer to the backing stream.
    unsigned int bytesStored{ co_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.
    if (co_await dataWriter.FlushAsync())
            // Once we've written the contents successfully, we load the stream.
            unsigned int bytesLoaded{ co_await dataReader.LoadAsync((unsigned int)stream.Size()) };
            std::wstringstream readFromStream;
            // 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".
                unsigned int bytesToRead{ dataReader.ReadUInt32() };
                readFromStream << dataReader.ReadString(bytesToRead).c_str() << std::endl;
            // Populate the ElementsRead text block with the items we read from the stream
            ElementsRead().Text(readFromStream.str().c_str());
        catch (winrt::hresult_error const& ex)
            ElementsRead().Text(L"Error: " + ex.message());
#include "pch.h"
#include "WriteReadStream.xaml.h"
using namespace Concurrency;
using namespace DataReaderWriter;
using namespace Platform;
using namespace Windows::Storage::Streams;
using namespace Windows::UI::Xaml;
using namespace Windows::UI::Xaml::Controls;
using namespace Windows::UI::Xaml::Navigation;
Array<String^>^ _inputElements = ref new Array<String^>
    "Hello", "World", "1 2 3 4 5", "Très bien!", "Goodbye"
WriteReadStream::WriteReadStream()
    InitializeComponent();
    // Populate the text block with the input elements.
    ElementsToWrite->Text = "";
    for (unsigned int i = 0; i < _inputElements->Length; i++)
        ElementsToWrite->Text += _inputElements[i] + ";";
// Invoked when this page is about to be displayed in a Frame.
void WriteReadStream::OnNavigatedTo(NavigationEventArgs^ e)
    // Get a pointer to our main page.
    rootPage = MainPage::Current;
// This is the click handler for the 'Copy Strings' button.  Here we will parse the
// strings contained in the ElementsToWrite text block, write them to a stream using
// DataWriter, retrieve them using DataReader, and output the results in the
// ElementsRead text block.
void DataReaderWriter::WriteReadStream::TransferData(
Platform::Object^ sender, Windows::UI::Xaml::RoutedEventArgs^ e)
    // Initialize the in-memory stream where data will be stored.
    InMemoryRandomAccessStream^ stream = ref new InMemoryRandomAccessStream();
    // Create the DataWriter object backed by the in-memory stream.  When
    // dataWriter is deleted, it will also close the underlying stream.
    DataWriter^ dataWriter = ref new DataWriter(stream);
    dataWriter->UnicodeEncoding = UnicodeEncoding::Utf8;
    dataWriter->ByteOrder = ByteOrder::LittleEndian;
    // Create the data reader by using the input stream set at position 0 so that 
    // the stream will be read from the beginning regardless of where the position
    // the original stream ends up in after the store.
    IInputStream^ inputStream = stream->GetInputStreamAt(0);
    DataReader^ dataReader = ref new DataReader(inputStream);
    // The encoding and byte order need to match the settings of the writer 
    // we previously used.
    dataReader->UnicodeEncoding = UnicodeEncoding::Utf8;
    dataReader->ByteOrder = ByteOrder::LittleEndian;
    // Write the input data to the output stream.  Serialize the elements by writing
    // each string separately, preceded by its length.
    for (unsigned int i = 0; i < _inputElements->Length; i++) 
        unsigned int inputElementSize = dataWriter->MeasureString(_inputElements[i]);
        dataWriter->WriteUInt32(inputElementSize);
        dataWriter->WriteString(_inputElements[i]);
    // Send the contents of the writer to the backing stream.
    create_task(dataWriter->StoreAsync()).then([this, dataWriter] (unsigned int bytesStored)
        // For the in-memory stream implementation we are using, the FlushAsync() call 
        // is superfluous, but other types of streams may require it.
        return dataWriter->FlushAsync();
    }).then([this, dataReader, stream] (bool flushOp)
        // Once we have written the contents successfully we load the stream.
        return dataReader->LoadAsync((unsigned int) stream->Size);
    }).then([this, dataReader] (task<unsigned int> bytesLoaded)
            // Check for possible exceptions that could have been thrown 
            // in the async call chain.
            bytesLoaded.get();
            String^ readFromStream = "";
            // 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".
                unsigned int bytesToRead = dataReader->ReadUInt32();
                readFromStream += dataReader->ReadString(bytesToRead) + "\n";
            // Populate the ElementsRead text block with the items we read from the stream
            ElementsRead->Text = readFromStream;
        catch (Exception^ e)
            ElementsRead->Text = "Error: " + e->Message;
	
DataReader 对象的实例不支持并发读取操作。 如果应用程序从要从中读取的 DataReader 实例并发读取或分离流，则对对象的调用将失败并出现错误HRESULT_FROM_WIN32 (ERROR_INVALID_OPERATION) 。