StreamReader.ReadToEnd Método

Definición

Espacio de nombres:

System.IO

Ensamblado:

System.Runtime.dll

Source:

StreamReader.cs

Lee todos los caracteres desde la posición actual hasta el final de la secuencia.

public:
 override System::String ^ ReadToEnd();

public override string ReadToEnd ();

override this.ReadToEnd : unit -> string

Public Overrides Function ReadToEnd () As String

Devoluciones

String

Resto de la secuencia, como una cadena, desde la posición actual hasta el final. Si la posición actual se encuentra al final de la secuencia, devuelve una cadena vacía ("").

Excepciones

OutOfMemoryException

No hay memoria suficiente para asignar un búfer para la cadena devuelta.

IOException

Error de E/S.

Ejemplos

En el ejemplo de código siguiente se lee todo el camino hasta el final de un archivo en una operación.

using namespace System;
using namespace System::IO;
int main()
{
   String^ path = "c:\\temp\\MyTest.txt";
   try
   {
      if ( File::Exists( path ) )
      {
         File::Delete( path );
      }
      StreamWriter^ sw = gcnew StreamWriter( path );
      try
      {
         sw->WriteLine( "This" );
         sw->WriteLine( "is some text" );
         sw->WriteLine( "to test" );
         sw->WriteLine( "Reading" );
      }
      finally
      {
         delete sw;
      }

      StreamReader^ sr = gcnew StreamReader( path );
      try
      {
         //This allows you to do one Read operation.
         Console::WriteLine( sr->ReadToEnd() );
      }
      finally
      {
         delete sr;
      }
   }
   catch ( Exception^ e ) 
   {
      Console::WriteLine( "The process failed: {0}", e );
   }
}

using System;
using System.IO;

class Test
{
    
    public static void Main()
    {
        string path = @"c:\temp\MyTest.txt";

        try
        {
            if (File.Exists(path))
            {
                File.Delete(path);
            }

            using (StreamWriter sw = new StreamWriter(path))
            {
                sw.WriteLine("This");
                sw.WriteLine("is some text");
                sw.WriteLine("to test");
                sw.WriteLine("Reading");
            }

            using (StreamReader sr = new StreamReader(path))
            {
                //This allows you to do one Read operation.
                Console.WriteLine(sr.ReadToEnd());
            }
        }
        catch (Exception e)
        {
            Console.WriteLine("The process failed: {0}", e.ToString());
        }
    }
}

Imports System.IO
Imports System.Text

Public Class Test

    Public Shared Sub Main()
        Dim path As String = "c:\temp\MyTest.txt"

        Try
            If File.Exists(path) Then
                File.Delete(path)
            End If

            Dim sw As StreamWriter = New StreamWriter(path)
            sw.WriteLine("This")
            sw.WriteLine("is some text")
            sw.WriteLine("to test")
            sw.WriteLine("Reading")
            sw.Close()

            Dim sr As StreamReader = New StreamReader(path)

            'This allows you to do one Read operation.
            Console.WriteLine(sr.ReadToEnd())
            sr.Close()
        Catch e As Exception
            Console.WriteLine("The process failed: {0}", e.ToString())
        End Try
    End Sub
End Class

Comentarios

Este método invalida TextReader.ReadToEnd.

ReadToEnd funciona mejor cuando necesite leer toda la entrada de la posición actual al final de la secuencia. Si se necesita más control sobre cuántos caracteres se leen desde la secuencia, use la sobrecarga del Read(Char[], Int32, Int32) método, lo que suele dar lugar a un mejor rendimiento.

ReadToEnd supone que la secuencia sabe cuándo ha llegado a un final. En el caso de los protocolos interactivos en los que el servidor envía datos solo cuando se solicita y no cierra la conexión, puede bloquearse indefinidamente porque ReadToEnd no llega a un final y debe evitarse.

Tenga en cuenta que al usar el Read método , es más eficaz usar un búfer que tenga el mismo tamaño que el búfer interno de la secuencia. Si el tamaño del búfer no se especificó cuando se construyó la secuencia, su tamaño predeterminado es de 4 kilobytes (4096 bytes).

Si el método actual inicia una OutOfMemoryException, la posición del lector en el objeto subyacente Stream está avanzada por el número de caracteres que el método pudo leer, pero los caracteres que ya se leen en el búfer interno ReadLine se descartan. Si manipula la posición de la secuencia subyacente después de leer los datos en el búfer, es posible que la posición de la secuencia subyacente no coincida con la posición del búfer interno. Para restablecer el búfer interno, llame al método ; sin embargo, este método ralentiza el DiscardBufferedData rendimiento y solo se debe llamar cuando sea absolutamente necesario.

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

Consulte también

• E/S de archivos y secuencias
• Cómo: Leer texto de un archivo
• Cómo: Escribir texto en un archivo