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()

來源:: BinaryReader.cs

來源:: BinaryReader.cs

來源:: BinaryReader.cs

按照所使用的 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>)

來源:: BinaryReader.cs

來源:: BinaryReader.cs

來源:: BinaryReader.cs

從目前的資料流讀取位元組序列，並依讀取的位元組數將資料流中的位置往前移。

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>)

來源:: BinaryReader.cs

來源:: BinaryReader.cs

來源:: BinaryReader.cs

從目前資料流讀取與所提供緩衝區長度相同的字元數目、將它們寫入所提供緩衝區，並根據所使用 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)

來源:: BinaryReader.cs

來源:: BinaryReader.cs

來源:: BinaryReader.cs

由位元組陣列中指定點開始，讀取資料流中的指定位元組數。

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 解碼器傳回後援字元或 Surrogate 組，就會發生這個情況。

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)

來源:: BinaryReader.cs

來源:: BinaryReader.cs

來源:: BinaryReader.cs

由字元陣列中的指定點開始，從資料流讀取指定字元數。

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 解碼器傳回後援字元或 Surrogate 組，就會發生這個情況。

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)

參數

傳回

例外狀況

範例

備註

另請參閱

適用於

其他資源