25、DataReaderWriter

 

 

1、Read and write simple structured data：

      这个示例演示了创建一个内存支持的流，然后通过使用 DataWrite 对象把下面的字符串存储到流中。一旦这个

操作完成了，再使用一个 DataReader 对象把这些字符串从这个流中提取出来。

   

操作截图：

 

点击按钮后 ，显示结果：

 

页面的 xaml：

//将要操作的文本

 <TextBlock x:Name="ElementsToWrite" >

            Hello;World;1 2 3 4 5;Très bien!;Goodbye

 </TextBlock>



  <Button x:Name="SendButton" Content="Copy Strings" Click="TransferData"/>

//输出结果

<TextBlock x:Name="ElementsRead"  />

 

按钮的操作事件：

 

//读取文本框中的文本，并使用 DataReader 和 DataWriter 进行读写操作

 private async void TransferData(object sender, RoutedEventArgs e)

        {

            // 初始化 in-memory stream ，并把数据存储到这个流中

            using (var stream = new Windows.Storage.Streams.InMemoryRandomAccessStream())

            {

             // 创建数据写入器对象支持的内存流

                using (var dataWriter = new Windows.Storage.Streams.DataWriter(stream))

                {

                  // 获取或设置用于输出流的 Unicode 字符编码。 编码为 UTF-8。

                    dataWriter.UnicodeEncoding = Windows.Storage.Streams.UnicodeEncoding.Utf8;



                 // 在输出流中获取或设置数据的字节顺序。首先存储最低有效字节（最低的地址）。

                    dataWriter.ByteOrder = Windows.Storage.Streams.ByteOrder.LittleEndian;



                 // 转换输入流，并且把它们分割

                    string[] inputElements = ElementsToWrite.Text.Split(';');

                    foreach (string inputElement in inputElements)

                    {

                     // 获取字符串的大小。

                        uint inputElementSize = dataWriter.MeasureString(inputElement);



                    //将 32 位无符号整数值写入输出流。

                        dataWriter.WriteUInt32(inputElementSize);



                    //将字符串值写入输出流。

                        dataWriter.WriteString(inputElement);

                    }



                    // 发送 writer 的内容到支持的流。

                       await dataWriter.StoreAsync();



                //对于内存流的实现中,我们调用 flushAsync() 方法是多余的，但是其它类型的流中可能需要这么做



                   // 为了延长 stream 的生命周期，把这个流从 dataWriter 中分离，所以在 dataWriter 对象调用 Dispose() 方法时，
                   //这个流不会被关闭掉。如果我们分离这个流失败，在调用dataWriter.Dispose() 方法时会优先关闭这个流，阻止了下面DataReader 的调用

                    dataWriter.DetachStream();

                }



             // 创建这个 input stream 在位置 0，以便这个流可以从开始读

                using (var inputStream = stream.GetInputStreamAt(0))

                {

                    using (var dataReader = new Windows.Storage.Streams.DataReader(inputStream))

                    {

                     // 编码和字节顺序需要匹配我们之前的设置使用的 writer

                     // 获取或设置用于输入流的 Unicode 字符编码。

                        dataReader.UnicodeEncoding = Windows.Storage.Streams.UnicodeEncoding.Utf8;



                    // 在输入流中获取或设置数据的字节顺序。

                        dataReader.ByteOrder = Windows.Storage.Streams.ByteOrder.LittleEndian;



                    // 一旦我们把这些内容写成功，然后我们就加载这个流. 从输入流加载数据。

                        await dataReader.LoadAsync((uint)stream.Size);



                        var receivedStrings = "";



                        // 继续阅读,直到我们消费掉完整的流。

                       while (dataReader.UnconsumedBufferLength > 0)

                        {

                        // 注意到当调用 ReadString 方法前需要设置 “code units”的长度。

                           //这是为什么在写入流时，把每个 string 的长度进行设置

                            uint bytesToRead = dataReader.ReadUInt32();

                            receivedStrings += dataReader.ReadString(bytesToRead) + "\n";

                        }



                        // 把从流中读取的元素输出到 TextBlock 对象中

                        ElementsRead.Text = receivedStrings;

                    }

                }

            }

 

 2、Dump file contents using ReadBytes() ：

      本示例打开下面图片的顺序访问流，并且使用 ReadBytes() 方法，把它的内容显示为 16 进制数据，

并且存储为 二进制数据。

 

操作截图：

 

显示的 16 进制输出：

 

页面的 xaml ：

//用来操作的应用程序包中的图片

<Image x:Name="StrawberryImage" Source="/assets/110Strawberry.png"  />



<Button x:Name="HexDumpButton" Content="Hex Dump"  Click="HexDump"/>



//显示图片的 16 进制结果

 <TextBlock x:Name="ReadBytesOutput"  />

 

相应按钮的单击事件：

//声明三个变量

private const int bytesPerRow = 16;

private const int bytesPerSegment = 2;

private const uint chunkSize = 4096;





//首先打开将要操作的图片，然后把文件放入一个连续访问的流中，然后使用 ReadBytes() 方法从中提取二进制数据。最后，把每个字节转换为 16 进制的数据，
//并且格式化后，把这些数据输出到 textblock 中

private async void HexDump(object sender, RoutedEventArgs e)

        {

            try

            {

                //检索并获取图形文件

                  Uri uri = new Uri("ms-appx:///assets/110Strawberry.png");

                var file = await Windows.Storage.StorageFile.GetFileFromApplicationUriAsync(uri);



                // 打开一个图像文件的顺序访问流。

                using (var inputStream = await file.OpenSequentialReadAsync())

                {

                    // 把这个输入流（input stream）传输到 DataReader 对象

                    using (var dataReader = new Windows.Storage.Streams.DataReader(inputStream))

                    {

                        uint currChunk = 0;

                        uint numBytes;

                        ReadBytesOutput.Text = "";



                     // 创建一个字节数组,可以持有足够的字节来填充一排十六进制转储。

                        var bytes = new byte[bytesPerRow];



                        do

                        {

                        // 加载下一个块 到 DataReader 的缓冲区

                            numBytes = await dataReader.LoadAsync(chunkSize);//从输入流加载数据。


                         // 读出并打印一行

                             var numBytesRemaining = numBytes;

                         while (numBytesRemaining >= bytesPerRow)

                            {

                                // 使用 DataReader 对象和 ReadBytes() 方法来填补这个字节数组与足够一行的字节

                                    dataReader.ReadBytes(bytes);//从输入流中读取字节值数组。


                                PrintRow(bytes, (numBytes - numBytesRemaining) + (currChunk * chunkSize));



                                numBytesRemaining -= bytesPerRow;

                            }



                          // 如果有任何剩余的字节可读,分配一个新的数组,用来装载 DataReader对象中剩余的字节，并且打印到最后一行
                              // 注意: ReadBytes()填充整个数组,所以如果数组被传入到比在 DataReader 中剩下的缓冲区大
 //,将会抛出一个异常。
                               if (numBytesRemaining > 0)

                            {

                                bytes = new byte[numBytesRemaining];



                                //  从输入流中读取字节值数组。
                                dataReader.ReadBytes(bytes);



                                PrintRow(bytes, (numBytes - numBytesRemaining) + (currChunk * chunkSize));

                            }



                            currChunk++;


                        // If the number of bytes read is anything but the chunk size, then we've just retrieved the last

                        // chunk of data from the stream.  Otherwise, keep loading data into the DataReader buffer.
                        //如果读取的字节数决不是块的大小,然后我们检索下一个
 //大块的数据流。否则,继续加载数据到 DataReader 缓冲区。

                        } while (numBytes == chunkSize);

                    }

                }

            }

            catch (Exception ex)

            {

                ReadBytesOutput.Text = ex.Message;

            }

        }

 

        /// <summary>

        /// 把从 ReadBytes() 方法中得到的数据，格式化并且输出为一行十六进制数据

         /// </summary>

        /// <param name="bytes">我们将要操作的数组</param>

        /// <param name="currByte">值将被格式化为一个地址</param>

        private void PrintRow(byte[] bytes, uint currByte)

        {

            var rowStr = "";



            // Format the address of byte i to have 8 hexadecimal digits and add the address

            // of the current byte to the output string.

            rowStr += currByte.ToString("x8");



            // 格式化输出

              for (int i = 0; i < bytes.Length; i++)

            {

                //如果完成了一段,添加一个 空格。

                  if (i % bytesPerSegment == 0)

                {

                    rowStr += " ";

                }



              // 把当前字节值转换成十六进制,并将它添加到输出字符串。

                rowStr += bytes[i].ToString("x2");

            }



             // 把当前行追加到 TextBlock 中

               ReadBytesOutput.Text += rowStr + "\n";

        }