Compartir a través de


BinaryReader.Read Método

Definición

Lee los bytes de la secuencia subyacente y hace avanzar la posición actual de la secuencia.

Sobrecargas

Read()

Lee los caracteres de la secuencia subyacente y hace avanzar la posición actual de la secuencia de acuerdo con la Encoding usada y el carácter concreto que se lea de la secuencia.

Read(Span<Byte>)

Lee una secuencia de bytes en el flujo actual y avanza la posición en el flujo según el número de bytes leídos.

Read(Span<Char>)

Lee, en la secuencia actual, el mismo número de caracteres que la longitud del búfer proporcionado, los escribe en el búfer proporcionado y hace avanzar la posición actual de acuerdo con el elemento Encoding usado y el carácter concreto que se lee en la secuencia.

Read(Byte[], Int32, Int32)

Lee el número especificado de bytes de la secuencia, a partir del punto especificado en la matriz de bytes.

Read(Char[], Int32, Int32)

Lee el número especificado de caracteres de la secuencia, a partir del punto especificado en la matriz de caracteres.

Read()

Source:
BinaryReader.cs
Source:
BinaryReader.cs
Source:
BinaryReader.cs

Lee los caracteres de la secuencia subyacente y hace avanzar la posición actual de la secuencia de acuerdo con la Encoding usada y el carácter concreto que se lea de la secuencia.

public:
 virtual int Read();
public virtual int Read ();
abstract member Read : unit -> int
override this.Read : unit -> int
Public Overridable Function Read () As Integer

Devoluciones

Siguiente carácter de la secuencia de entrada o -1 si no hay más caracteres disponibles en este momento.

Excepciones

Error de E/S.

La secuencia está cerrada.

Ejemplos

En el ejemplo siguiente se muestra cómo leer y escribir datos con memoria como almacén de respaldo. En este ejemplo se muestra una lista de caracteres de ruta de acceso de archivo no válidos a la consola. Aunque el código intenta mostrar una lista de todos los caracteres de ruta de acceso de archivo no válidos, no todos los caracteres están dentro del conjunto de caracteres que se puede mostrar. Dado que la lista de caracteres no válidos puede variar en función del sistema, la salida de este código también puede variar.

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

Comentarios

BinaryReader no restaura la posición del archivo después de una lectura incorrecta.

Para obtener una lista de tareas de E/S comunes, consulte Tareas de E/S comunes.

Consulte también

Se aplica a

Read(Span<Byte>)

Source:
BinaryReader.cs
Source:
BinaryReader.cs
Source:
BinaryReader.cs

Lee una secuencia de bytes en el flujo actual y avanza la posición en el flujo según el número de bytes leídos.

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

Parámetros

buffer
Span<Byte>

Región de memoria. Cuando este método finaliza, el contenido de esta región se reemplaza por los bytes leídos del origen actual.

Devoluciones

Número total de bytes leídos en el búfer. Puede ser menor que el número de bytes asignado en el búfer si esos bytes no están disponibles en ese momento o cero (0) si se ha alcanzado el final de la secuencia.

Excepciones

La secuencia está cerrada.

Error de E/S.

Se aplica a

Read(Span<Char>)

Source:
BinaryReader.cs
Source:
BinaryReader.cs
Source:
BinaryReader.cs

Lee, en la secuencia actual, el mismo número de caracteres que la longitud del búfer proporcionado, los escribe en el búfer proporcionado y hace avanzar la posición actual de acuerdo con el elemento Encoding usado y el carácter concreto que se lee en la secuencia.

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

Parámetros

buffer
Span<Char>

Intervalo de caracteres. Cuando este método finaliza, el contenido de esta región se reemplaza por los bytes leídos en el origen actual.

Devoluciones

Número total de caracteres leídos en el búfer. Este podría ser inferior al número de caracteres solicitado si dicho número de caracteres no se encuentra disponible o podría ser cero si se alcanza el final de la secuencia.

Excepciones

La secuencia está cerrada.

Error de E/S.

Se aplica a

Read(Byte[], Int32, Int32)

Source:
BinaryReader.cs
Source:
BinaryReader.cs
Source:
BinaryReader.cs

Lee el número especificado de bytes de la secuencia, a partir del punto especificado en la matriz de bytes.

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

Parámetros

buffer
Byte[]

Búfer en el que se leen los datos.

index
Int32

Punto inicial del búfer en el que comienza la lectura.

count
Int32

Número de bytes que se va a leer.

Devoluciones

Número de bytes leídos en buffer. Podría ser inferior al número de bytes solicitado si ese número de bytes no está disponible, o podría ser cero si se alcanza el final de la secuencia.

Excepciones

La longitud del búfer menos index es menor que count.

O bien

El número de caracteres descodificados para leer es mayor que count. Esto puede pasar si un descodificador de Unicode devuelve caracteres de reserva o un par suplente.

buffer es null.

index o count es negativo.

La secuencia está cerrada.

Error de E/S.

Ejemplos

En el ejemplo siguiente se muestra cómo escribir datos binarios mediante el uso de memoria como almacén de respaldo. Muestra un mensaje en la consola que indica si los datos se escribieron correctamente.

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

En este ejemplo se lee el contenido de un archivo y se muestra el valor numérico de cada byte en formato de 16 columnas. El final del archivo que se lee se detecta cuando el Read método devuelve cero bytes.

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

Comentarios

BinaryReader no restaura la posición del archivo después de una operación de lectura incorrecta.

Para obtener una lista de tareas de E/S comunes, consulte Tareas de E/S comunes.

Consulte también

Se aplica a

Read(Char[], Int32, Int32)

Source:
BinaryReader.cs
Source:
BinaryReader.cs
Source:
BinaryReader.cs

Lee el número especificado de caracteres de la secuencia, a partir del punto especificado en la matriz de caracteres.

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

Parámetros

buffer
Char[]

Búfer en el que se leen los datos.

index
Int32

Punto inicial del búfer en el que comienza la lectura.

count
Int32

Número de caracteres que se va a leer.

Devoluciones

Número total de caracteres leídos en el búfer. Este podría ser inferior al número de caracteres solicitado si dicho número de caracteres no se encuentra disponible o podría ser cero si se alcanza el final de la secuencia.

Excepciones

La longitud del búfer menos index es menor que count.

O bien

El número de caracteres descodificados para leer es mayor que count. Esto puede pasar si un descodificador de Unicode devuelve caracteres de reserva o un par suplente.

buffer es null.

index o count es negativo.

La secuencia está cerrada.

Error de E/S.

Ejemplos

En el ejemplo siguiente se muestra cómo leer y escribir datos con memoria como almacén de respaldo. En este ejemplo se muestra una lista de caracteres de ruta de acceso de archivo no válidos a la consola. Aunque el código intenta mostrar una lista de todos los caracteres de ruta de acceso de archivo no válidos, no todos los caracteres están dentro del conjunto de caracteres que se puede mostrar. Dado que la lista de caracteres no válidos puede variar en función del sistema, la salida de este código también puede variar.

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

Comentarios

BinaryReader no restaura la posición del archivo después de una operación de lectura incorrecta.

Para obtener una lista de tareas de E/S comunes, consulte Tareas de E/S comunes.

Consulte también

Se aplica a