BinaryReader.Read 方法

参考

定义

命名空间:: System.IO

程序集:: System.IO.dll

程序集:: System.Runtime.dll

程序集:: System.Runtime.Extensions.dll

程序集:: mscorlib.dll

程序集:: netstandard.dll

重要

一些信息与预发行产品相关，相应产品在发行之前可能会进行重大修改。对于此处提供的信息，Microsoft 不作任何明示或暗示的担保。

从基础流中读取字节，并将流的当前位置前移。

重载

Read()	从基础流中读取字符，并根据所使用的 `Encoding` 和从流中读取的特定字符，提升流的当前位置。
Read(Span<Byte>)	从当前流读取字节序列，并将流中的位置向前移动读取的字节数。
Read(Span<Char>)	从当前流中读取与提供的缓冲区长度相同的字符数，将其写入提供的缓冲区，然后根据所使用的 `Encoding` 和从流中读取的特定字符，将当前位置前移。
Read(Byte[], Int32, Int32)	从字节数组中的指定点开始，从流中读取指定的字节数。
Read(Char[], Int32, Int32)	从字符数组中的指定点开始，从流中读取指定的字符数。

Read()

从基础流中读取字符，并根据所使用的 Encoding 和从流中读取的特定字符，提升流的当前位置。

public:
 virtual int Read();

public virtual int Read ();

abstract member Read : unit -> int
override this.Read : unit -> int

Public Overridable Function Read () As Integer

Int32

输入流中的下一个字符，如果当前无可用字符则为 -1。

例外

IOException

出现 I/O 错误。

ObjectDisposedException

流已关闭。

示例

以下示例演示如何使用内存作为后盾存储来读取和写入数据。此示例显示控制台的文件路径字符无效的列表。尽管代码尝试显示所有无效文件路径字符的列表，但并非所有字符都位于可显示字符集中。由于无效字符列表可能因系统而异，因此此代码的输出也可能有所不同。

using namespace System;
using namespace System::IO;
int main()
{
   int i;
   array<Char>^invalidPathChars = Path::InvalidPathChars;
   MemoryStream^ memStream = gcnew MemoryStream;
   BinaryWriter^ binWriter = gcnew BinaryWriter( memStream );
   
   // Write to memory.
   binWriter->Write( "Invalid file path characters are: " );
   for ( i = 0; i < invalidPathChars->Length; i++ )
   {
      binWriter->Write( invalidPathChars[ i ] );

   }
   
   // Create the reader using the same MemoryStream 
   // as used with the writer.
   BinaryReader^ binReader = gcnew BinaryReader( memStream );
   
   // Set Position to the beginning of the stream.
   binReader->BaseStream->Position = 0;
   
   // Read the data from memory and write it to the console.
   Console::Write( binReader->ReadString() );
   array<Char>^memoryData = gcnew array<Char>(memStream->Length - memStream->Position);
   for ( i = 0; i < memoryData->Length; i++ )
   {
      memoryData[ i ] = Convert::ToChar( binReader->Read() );

   }
   Console::WriteLine( memoryData );
}

using System;
using System.IO;

class BinaryRW
{
    static void Main()
    {
        int i = 0;
        char[] invalidPathChars = Path.InvalidPathChars;
        MemoryStream memStream = new MemoryStream();
        BinaryWriter binWriter = new BinaryWriter(memStream);

        // Write to memory.
        binWriter.Write("Invalid file path characters are: ");
        for(i = 0; i < invalidPathChars.Length; i++)
        {
            binWriter.Write(invalidPathChars[i]);
        }

        // Create the reader using the same MemoryStream
        // as used with the writer.
        BinaryReader binReader = new BinaryReader(memStream);

        // Set Position to the beginning of the stream.
        memStream.Position = 0;

        // Read the data from memory and write it to the console.
        Console.Write(binReader.ReadString());
        char[] memoryData =
            new char[memStream.Length - memStream.Position];
        for(i = 0; i < memoryData.Length; i++)
        {
            memoryData[i] = Convert.ToChar(binReader.Read());
        }
        Console.WriteLine(memoryData);
    }
}

open System
open System.IO

let invalidPathChars = Path.GetInvalidPathChars()
let memStream = new MemoryStream()
let binWriter = new BinaryWriter(memStream)

// Write to memory.
printf "Invalid file path characters are: "
for i = 0 to invalidPathChars.Length - 1 do
    binWriter.Write invalidPathChars[i]

// Create the reader using the same MemoryStream
// as used with the writer.
let binReader = new BinaryReader(memStream)

// Set Position to the beginning of the stream.
memStream.Position <- 0

// Read the data from memory and write it to the console.
printf $"{binReader.ReadString()}"
let memoryData =
    [| for _ = 0L to memStream.Length - memStream.Position - 1L do
        Convert.ToChar(binReader.Read()) |]
printfn $"{memoryData}"

Imports System.IO

Public Class BinaryRW

    Shared Sub Main()
    
        Dim i As Integer = 0
        Dim invalidPathChars() As Char = Path.InvalidPathChars
        Dim memStream As new MemoryStream()
        Dim binWriter As New BinaryWriter(memStream)

        ' Write to memory.
        binWriter.Write("Invalid file path characters are: ")
        For i = 0 To invalidPathChars.Length - 1
            binWriter.Write(invalidPathChars(i))
        Next i

        ' Create the reader using the same MemoryStream 
        ' as used with the writer.
        Dim binReader As New BinaryReader(memStream)

        ' Set Position to the beginning of the stream.
        memStream.Position = 0

        ' Read the data from memory and write it to the console.
        Console.Write(binReader.ReadString())
        Dim memoryData( _
            CInt(memStream.Length - memStream.Position) - 1) As Char
        For i = 0 To memoryData.Length - 1
            memoryData(i) = Convert.ToChar(binReader.Read())
        Next i
        Console.WriteLine(memoryData)
    
    End Sub
End Class

注解

BinaryReader 在读取失败后，不会还原文件位置。

有关常见 I/O 任务的列表，请参阅常见 I/O 任务。

另请参阅

适用于

Read(Span<Byte>)

从当前流读取字节序列，并将流中的位置向前移动读取的字节数。

public:
 virtual int Read(Span<System::Byte> buffer);

public virtual int Read (Span<byte> buffer);

abstract member Read : Span<byte> -> int
override this.Read : Span<byte> -> int

Public Overridable Function Read (buffer As Span(Of Byte)) As Integer

参数

buffer: Span<Byte>

内存的区域。当此方法返回时，此区域的内容将替换为从当前源读取的字节。

Int32

读入缓冲区中的总字节数。如果很多字节当前不可用，则这可小于在缓冲区中分配的字节数；如果已到达流结尾，则为零 (0)。

例外

ObjectDisposedException

流已关闭。

IOException

出现 I/O 错误。

适用于

Read(Span<Char>)

从当前流中读取与提供的缓冲区长度相同的字符数，将其写入提供的缓冲区，然后根据所使用的 Encoding 和从流中读取的特定字符，将当前位置前移。

public:
 virtual int Read(Span<char> buffer);

public virtual int Read (Span<char> buffer);

abstract member Read : Span<char> -> int
override this.Read : Span<char> -> int

Public Overridable Function Read (buffer As Span(Of Char)) As Integer

参数

buffer: Span<Char>

字符范围。当此方法返回时，此区域的内容将替换为从当前源读取的字符。

Int32

读入缓冲区的总字符数。如果当前可用的字节没有请求的那么多，此数可能小于所请求的字符数；如果到达了流的末尾，此数可能为零。

例外

ObjectDisposedException

流已关闭。

IOException

出现 I/O 错误。

适用于

Read(Byte[], Int32, Int32)

从字节数组中的指定点开始，从流中读取指定的字节数。

public:
 virtual int Read(cli::array <System::Byte> ^ buffer, int index, int count);

public virtual int Read (byte[] buffer, int index, int count);

abstract member Read : byte[] * int * int -> int
override this.Read : byte[] * int * int -> int

Public Overridable Function Read (buffer As Byte(), index As Integer, count As Integer) As Integer

参数

buffer: Byte[]

将数据读入的缓冲区。

index: Int32

缓冲区中的起始点，在该处开始读入缓冲区。

count: Int32

要读取的字节数。

Int32

读入 buffer 的字节数。如果可用的字节没有请求的那么多，此数可能小于所请求的字节数；如果到达了流的末尾，此数可能为零。

例外

ArgumentException

缓冲区长度减去 index 小于 count。

或 - 要读取的解码字符数大于 count。如果 Unicode 解码器返回回退字符或代理项对，则可能发生此情况。

ArgumentNullException

buffer 为 null。

ArgumentOutOfRangeException

index 或 count 为负数。

ObjectDisposedException

流已关闭。

IOException

出现 I/O 错误。

示例

以下示例演示如何使用内存作为后盾存储来写入二进制数据。它向控制台显示一条消息，指示数据是否已正确写入。

using System;
using System.IO;

namespace BinaryRW
{
    class Program
    {
        static void Main(string[] args)
        {
            const int arrayLength = 1000;
            byte[] dataArray = new byte[arrayLength];
            byte[] verifyArray = new byte[arrayLength];

            new Random().NextBytes(dataArray);

            using (BinaryWriter binWriter = new BinaryWriter(new MemoryStream()))
            {
                Console.WriteLine("Writing the data.");
                binWriter.Write(dataArray, 0, arrayLength);

                using (BinaryReader binReader = new BinaryReader(binWriter.BaseStream))
                {
                    binReader.BaseStream.Position = 0;

                    if (binReader.Read(verifyArray, 0, arrayLength) != arrayLength)
                    {
                        Console.WriteLine("Error writing the data.");
                        return;
                    }
                }
            }

            for (int i = 0; i < arrayLength; i++)
            {
                if (verifyArray[i] != dataArray[i])
                {
                    Console.WriteLine("Error writing the data.");
                    return;
                }
            }

            Console.WriteLine("The data was written and verified.");
        }
    }
}

open System
open System.IO

let arrayLength = 1000
let dataArray = Array.zeroCreate<byte> arrayLength
let verifyArray = Array.zeroCreate<byte> arrayLength

Random().NextBytes dataArray

do
    use binWriter = new BinaryWriter(new MemoryStream())
    printfn "Writing the data."
    binWriter.Write(dataArray, 0, arrayLength)

    use binReader = new BinaryReader(binWriter.BaseStream)
    binReader.BaseStream.Position <- 0

    if binReader.Read(verifyArray, 0, arrayLength) <> arrayLength then
        printfn "Error writing the data."
    else
        for i = 0 to arrayLength - 1 do
            if verifyArray[i] <> dataArray[i] then
                printfn "Error writing the data."
            else
                printfn "The data was written and verified."

Imports System.IO

Module Module1

    Sub Main()
        Const upperBound As Integer = 1000
        Dim dataArray(upperBound) As Byte
        Dim verifyArray(upperBound) As Byte

        Dim randomGenerator As New Random
        randomGenerator.NextBytes(dataArray)

        Using binWriter As New BinaryWriter(New MemoryStream())
            Console.WriteLine("Writing the data.")
            binWriter.Write(dataArray, 0, dataArray.Length)

            Using binReader As New BinaryReader(binWriter.BaseStream)
                binReader.BaseStream.Position = 0

                If binReader.Read(verifyArray, 0, dataArray.Length) <> dataArray.Length Then
                    Console.WriteLine("Error writing the data.")
                    Return
                End If
            End Using
        End Using

        For i As Integer = 0 To upperBound
            If verifyArray(i) <> dataArray(i) Then
                Console.WriteLine("Error writing the data.")
                Return
            End If
        Next i

        Console.WriteLine("The data was written and verified.")
    End Sub

End Module

此示例读取文件的内容，并以 16 列格式显示每个字节的数值。当方法返回零字节时 Read ，检测到正在读取的文件的末尾。

using System;
using System.IO;
using System.Text;

public class DumpFileSample
{
    private static readonly int CHUNK_SIZE = 1024;
    public static void Main(String[] args)
    {
        if ((args.Length == 0) || !File.Exists(args[0]))
        {
            Console.WriteLine("Please provide an existing file name.");
        }
        else
        {
            using (FileStream fs = new FileStream(args[0], FileMode.Open, FileAccess.Read))
            {
                using (BinaryReader br = new BinaryReader(fs, new ASCIIEncoding()))
                {
                    byte[] chunk;

                    chunk = br.ReadBytes(CHUNK_SIZE);
                    while(chunk.Length > 0)
                    {
                        DumpBytes(chunk, chunk.Length);
                        chunk = br.ReadBytes(CHUNK_SIZE);
                    }
                }
            }
        }
    }

    public static void DumpBytes(byte[] bdata, int len)
    {
        int i;
        int j = 0;
        char dchar;
        // 3 * 16 chars for hex display, 16 chars for text and 8 chars
        // for the 'gutter' int the middle.
        StringBuilder dumptext = new StringBuilder("        ", 16 * 4 + 8);
        for (i = 0; i < len; i++)
        {
            dumptext.Insert(j * 3, String.Format("{0:X2} ", (int)bdata[i]));
            dchar = (char)bdata[i];
            //' replace 'non-printable' chars with a '.'.
            if (Char.IsWhiteSpace(dchar) || Char.IsControl(dchar))
            {
                dchar = '.';
            }
            dumptext.Append(dchar);
            j++;
            if (j == 16)
            {
                Console.WriteLine(dumptext);
                dumptext.Length = 0;
                dumptext.Append("        ");
                j = 0;
            }
        }
        // display the remaining line
        if (j > 0)
        {
            for (i = j; i < 16; i++)
            {
                dumptext.Insert(j * 3, "   ");
            }
            Console.WriteLine(dumptext);
        }
    }
}

open System
open System.IO
open System.Text

let CHUNK_SIZE = 1024

let dumpBytes (bdata: byte[]) len =
    let mutable j = 0
    // 3 * 16 chars for hex display, 16 chars for text and 8 chars
    // for the 'gutter' int the middle.
    let dumptext = StringBuilder("        ", 16 * 4 + 8)
    for i = 0 to len - 1 do
        dumptext.Insert(j * 3, $"{int bdata[i]:X2} ") |> ignore
        let dchar = char bdata[i]
        //' replace 'non-printable' chars with a '.'.
        let dchar = 
            if Char.IsWhiteSpace dchar || Char.IsControl dchar then
                '.'
            else 
                dchar
        dumptext.Append dchar |> ignore
        j <- j + 1
        if j = 16 then
            printfn $"{dumptext}"
            dumptext.Length <- 0
            dumptext.Append "        " |> ignore
            j <- 0
    // display the remaining line
    if j > 0 then
        for i = j to 15 do
            dumptext.Insert(j * 3, "   ") |> ignore
        printfn $"{dumptext}"

[<EntryPoint>]
let main args =
    if args.Length = 0 || File.Exists args[0] |> not then
        printfn "Please provide an existing file name."
    else
        use fs = new FileStream(args[0], FileMode.Open, FileAccess.Read)
        use br = new BinaryReader(fs, ASCIIEncoding())
        
        let mutable chunk = br.ReadBytes CHUNK_SIZE
        while chunk.Length > 0 do
            dumpBytes chunk chunk.Length
            chunk <- br.ReadBytes CHUNK_SIZE
    0

Imports System.IO
Imports System.Text

Module Module1
    Private ReadOnly CHUNK_SIZE As Integer = 1024
    Public Sub Main(args() As String)
        If ((args.Length = 0) OrElse Not File.Exists(args(0))) Then
            Console.WriteLine("Please provide an existing file name.")
        Else
            Using fs As FileStream = New FileStream(args(0), FileMode.Open, FileAccess.Read)
                Using br As New BinaryReader(fs, New ASCIIEncoding())
                    Dim chunk(CHUNK_SIZE) As Byte
                    chunk = br.ReadBytes(CHUNK_SIZE)

                    While chunk.Length > 0
                        DumpBytes(chunk, chunk.Length)
                        chunk = br.ReadBytes(CHUNK_SIZE)
                    End While
                End Using
            End Using
        End If
    End Sub

    Public Sub DumpBytes(bdata() As Byte, len As Integer)
        Dim i As Integer
        Dim j As Integer = 0
        Dim dchar As Char
        ' 3 * 16 chars for hex display, 16 chars for text and 8 chars
        ' for the 'gutter' int the middle.
        Dim dumptext As New StringBuilder("        ", 16 * 4 + 8)
        For i = 0 To len - 1
            dumptext.Insert(j * 3, String.Format("{0:X2} ", CType(bdata(i), Integer)))
            dchar = Convert.ToChar(bdata(i))
            ' replace 'non-printable' chars with a '.'.
            If Char.IsWhiteSpace(dchar) Or Char.IsControl(dchar) Then
                dchar = "."
            End If
            dumptext.Append(dchar)
            j += 1
            If j = 16 Then
                Console.WriteLine(dumptext)
                dumptext.Length = 0
                dumptext.Append("        ")
                j = 0
            End If
        Next i
        ' display the remaining line
        If j > 0 Then
            ' add blank hex spots to align the 'gutter'.
            For i = j To 15
                dumptext.Insert(j * 3, "   ")
            Next i
            Console.WriteLine(dumptext)
        End If
    End Sub

End Module

注解

BinaryReader 在读取操作失败后，不会还原文件位置。

有关常见 I/O 任务的列表，请参阅常见 I/O 任务。

另请参阅

适用于

Read(Char[], Int32, Int32)

从字符数组中的指定点开始，从流中读取指定的字符数。

public:
 virtual int Read(cli::array <char> ^ buffer, int index, int count);

public virtual int Read (char[] buffer, int index, int count);

abstract member Read : char[] * int * int -> int
override this.Read : char[] * int * int -> int

Public Overridable Function Read (buffer As Char(), index As Integer, count As Integer) As Integer

参数

buffer: Char[]

将数据读入的缓冲区。

index: Int32

缓冲区中的起始点，在该处开始读入缓冲区。

count: Int32

要读取的字符数。

Int32

读入缓冲区的总字符数。如果当前可用的字节没有请求的那么多，此数可能小于所请求的字符数；如果到达了流的末尾，此数可能为零。

例外

ArgumentException

缓冲区长度减去 index 小于 count。

或 - 要读取的解码字符数大于 count。如果 Unicode 解码器返回回退字符或代理项对，则可能发生此情况。

ArgumentNullException

buffer 为 null。

ArgumentOutOfRangeException

index 或 count 为负数。

ObjectDisposedException

流已关闭。

IOException

出现 I/O 错误。

示例

using namespace System;
using namespace System::IO;
int main()
{
   array<Char>^invalidPathChars = Path::InvalidPathChars;
   MemoryStream^ memStream = gcnew MemoryStream;
   BinaryWriter^ binWriter = gcnew BinaryWriter( memStream );
   
   // Write to memory.
   binWriter->Write( "Invalid file path characters are: " );
   binWriter->Write( Path::InvalidPathChars, 0, Path::InvalidPathChars->Length );
   
   // Create the reader using the same MemoryStream 
   // as used with the writer.
   BinaryReader^ binReader = gcnew BinaryReader( memStream );
   
   // Set Position to the beginning of the stream.
   binReader->BaseStream->Position = 0;
   
   // Read the data from memory and write it to the console.
   Console::Write( binReader->ReadString() );
   int arraySize = (int)(memStream->Length - memStream->Position);
   array<Char>^memoryData = gcnew array<Char>(arraySize);
   binReader->Read( memoryData, 0, arraySize );
   Console::WriteLine( memoryData );
}

using System;
using System.IO;

class BinaryRW
{
    static void Main()
    {
        char[] invalidPathChars = Path.InvalidPathChars;
        MemoryStream memStream = new MemoryStream();
        BinaryWriter binWriter = new BinaryWriter(memStream);

        // Write to memory.
        binWriter.Write("Invalid file path characters are: ");
        binWriter.Write(
            Path.InvalidPathChars, 0, Path.InvalidPathChars.Length);

        // Create the reader using the same MemoryStream
        // as used with the writer.
        BinaryReader binReader = new BinaryReader(memStream);

        // Set Position to the beginning of the stream.
        memStream.Position = 0;

        // Read the data from memory and write it to the console.
        Console.Write(binReader.ReadString());
        int arraySize = (int)(memStream.Length - memStream.Position);
        char[] memoryData = new char[arraySize];
        binReader.Read(memoryData, 0, arraySize);
        Console.WriteLine(memoryData);
    }
}

open System.IO

let invalidPathChars = Path.GetInvalidPathChars()
let memStream = new MemoryStream()
let binWriter = new BinaryWriter(memStream)

// Write to memory.
binWriter.Write "Invalid file path characters are: "
binWriter.Write(invalidPathChars, 0, invalidPathChars.Length)

// Create the reader using the same MemoryStream
// as used with the writer.
let binReader = new BinaryReader(memStream)

// Set Position to the beginning of the stream.
memStream.Position <- 0

// Read the data from memory and write it to the console.
printf $"{binReader.ReadString()}"
let arraySize = memStream.Length - memStream.Position |> int
let memoryData = Array.zeroCreate<char> arraySize
binReader.Read(memoryData, 0, arraySize) |> ignore
printfn $"{memoryData}"

Imports System.IO

Public Class BinaryRW

    Shared Sub Main()
    
        Dim invalidPathChars() As Char = Path.InvalidPathChars
        Dim memStream As new MemoryStream()
        Dim binWriter As New BinaryWriter(memStream)

        ' Write to memory.
        binWriter.Write("Invalid file path characters are: ")
        binWriter.Write(Path.InvalidPathChars, 0, _
            Path.InvalidPathChars.Length)

        ' Create the reader using the same MemoryStream 
        ' as used with the writer.
        Dim binReader As New BinaryReader(memStream)

        ' Set Position to the beginning of the stream.
        memStream.Position = 0

        ' Read the data from memory and write it to the console.
        Console.Write(binReader.ReadString())
        Dim upperBound As Integer = _
            CInt(memStream.Length - memStream.Position) - 1
        Dim memoryData(upperBound) As Char
        binReader.Read(memoryData, 0, upperBound)
        Console.WriteLine(memoryData)
    
    End Sub
End Class

注解

BinaryReader 在读取操作失败后，不会还原文件位置。

有关常见 I/O 任务的列表，请参阅常见 I/O 任务。

另请参阅

适用于

BinaryReader.Read 方法

定义

重载

Read()

返回

例外

示例

注解

另请参阅

适用于

Read(Span<Byte>)

参数

返回

例外

适用于

Read(Span<Char>)

参数

返回

例外

适用于

Read(Byte[], Int32, Int32)

参数

返回

例外

示例

注解

另请参阅

适用于

Read(Char[], Int32, Int32)

参数

返回

例外

示例

注解

另请参阅

适用于

其他资源