共用方式為


DataReader 類別

定義

從輸入資料流程讀取資料。

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
繼承
Object Platform::Object IInspectable DataReader
屬性
實作

Windows 需求

裝置系列
Windows 10 (已於 10.0.10240.0 引進)
API contract
Windows.Foundation.UniversalApiContract (已於 v1.0 引進)

範例

下列程式碼範例示範如何將字串寫入和讀取記憶體內部資料流程。 如需 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())
    {
        try
        {
            // 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)
    {
        try
        {
            // 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) 。

建構函式

DataReader(IInputStream)

建立並初始化資料讀取器的新實例。

屬性

ByteOrder

取得或設定輸入資料流程中資料的位元組順序。

InputStreamOptions

取得或設定輸入資料流程的讀取選項。

UnconsumedBufferLength

取得尚未讀取之緩衝區的大小。

UnicodeEncoding

取得或設定輸入資料流程的 Unicode 字元編碼。

方法

Close()

關閉目前的資料流程,並釋放系統資源。

DetachBuffer()

中斷連結與資料讀取器相關聯的緩衝區。 如果您想要在處置資料讀取器之後保留緩衝區,這會很有用。

DetachStream()

中斷連結與資料讀取器相關聯的資料流程。

Dispose()

執行與釋放 (Free)、釋放 (Release) 或重設 Unmanaged 資源相關聯之應用程式定義的工作。

FromBuffer(IBuffer)

使用來自指定緩衝區的資料,建立資料讀取器的新實例。

LoadAsync(UInt32)

從輸入資料流程載入資料。

ReadBoolean()

從輸入資料流程讀取布林值。

ReadBuffer(UInt32)

從輸入資料流程讀取緩衝區。

ReadByte()

從輸入資料流程讀取位元組值。

ReadBytes(Byte[])

從輸入資料流程讀取位元組值的陣列。

ReadDateTime()

從輸入資料流程讀取日期和時間值。

ReadDouble()

從輸入資料流程讀取浮點值。

ReadGuid()

從輸入資料流程讀取 GUID 值。

ReadInt16()

從輸入資料流程讀取 16 位整數值。

ReadInt32()

從輸入資料流程讀取 32 位整數值。

ReadInt64()

從輸入資料流程讀取 64 位整數值。

ReadSingle()

從輸入資料流程讀取浮點值。

ReadString(UInt32)

從輸入資料流程讀取字串值。

ReadTimeSpan()

從輸入資料流程讀取時間間隔值。

ReadUInt16()

從輸入資料流程讀取 16 位不帶正負號的整數。

ReadUInt32()

從輸入資料流程讀取 32 位不帶正負號的整數。

ReadUInt64()

從輸入資料流程讀取 64 位不帶正負號的整數。

適用於

另請參閱