StreamReader.ReadToEnd Metodo

  • Riferimento

Definizione

Spazio dei nomi:
System.IO
Assembly:
System.IO.dll
Assembly:
System.Runtime.dll
Assembly:
System.Runtime.Extensions.dll
Assembly:
mscorlib.dll
Assembly:
netstandard.dll
Origine:
StreamReader.cs
Origine:
StreamReader.cs
Origine:
StreamReader.cs

Legge tutti i caratteri dalla posizione corrente fino alla fine del flusso.

public:
 override System::String ^ ReadToEnd();
public override string ReadToEnd ();
override this.ReadToEnd : unit -> string
Public Overrides Function ReadToEnd () As String

Restituisce

String

Parte restante del flusso come stringa, dalla posizione corrente alla fine del flusso. Se la posizione corrente è alla fine del flusso, restituisce una stringa vuota ("").

Eccezioni

OutOfMemoryException

La memoria disponibile non è sufficiente per l’allocazione di un buffer per la stringa restituita.

IOException

Si è verificato un errore di I/O.

Esempio

Nell'esempio di codice seguente viene letto fino alla fine di un file in un'unica operazione.

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

Commenti

Questo metodo esegue l'override di TextReader.ReadToEnd.

ReadToEnd funziona meglio quando è necessario leggere tutto l'input dalla posizione corrente alla fine del flusso. Se è necessario un maggiore controllo sul numero di caratteri letti dal flusso, usare l'overload del Read(Char[], Int32, Int32) metodo, che in genere comporta prestazioni migliori.

ReadToEnd presuppone che il flusso sappia quando ha raggiunto una fine. Per i protocolli interattivi in cui il server invia i dati solo quando viene richiesto e non chiude la connessione, ReadToEnd potrebbe bloccarsi a tempo indefinito perché non raggiunge una fine ed è consigliabile evitare.

Si noti che quando si usa il Read metodo , è più efficiente usare un buffer con le stesse dimensioni del buffer interno del flusso. Se le dimensioni del buffer non sono state specificate al momento della costruzione del flusso, le dimensioni predefinite sono 4 kilobyte (4096 byte).

Se il metodo corrente genera un'eccezione OutOfMemoryException, la posizione del lettore nell'oggetto sottostante Stream viene avanzata dal numero di caratteri che il metodo è stato in grado di leggere, ma i caratteri già letti nel buffer interno ReadLine vengono eliminati. Se si modifica la posizione del flusso sottostante dopo la lettura dei dati nel buffer, la posizione del flusso sottostante potrebbe non corrispondere alla posizione del buffer interno. Per reimpostare il buffer interno, chiamare il DiscardBufferedData metodo , ma questo metodo rallenta le prestazioni e deve essere chiamato solo quando è assolutamente necessario.

Per un elenco delle attività di I/O comuni, vedere Attività di I/O comuni.

Si applica a

Vedi anche