StreamReader.ReadToEnd StreamReader.ReadToEnd StreamReader.ReadToEnd StreamReader.ReadToEnd Method

Definizione

Legge tutti i caratteri dalla posizione corrente fino alla fine del flusso.Reads all characters from the current position to the end of the stream.

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

Restituisce

Parte restante del flusso come stringa, dalla posizione corrente alla fine del flusso.The rest of the stream as a string, from the current position to the end. Se la posizione corrente è alla fine del flusso, restituisce una stringa vuota ("").If the current position is at the end of the stream, returns an empty string ("").

Eccezioni

La memoria disponibile non è sufficiente per l’allocazione di un buffer per la stringa restituita.There is insufficient memory to allocate a buffer for the returned string.

Si è verificato un errore di I/O.An I/O error occurs.

Esempi

Esempio di codice seguente legge tutti gli altri fino alla fine di un file in un'unica operazione.The following code example reads all the way to the end of a file in one operation.

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
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.This method overrides TextReader.ReadToEnd.

ReadToEnd funziona in modo ottimale quando è necessario leggere tutti gli input dalla posizione corrente alla fine del flusso.ReadToEnd works best when you need to read all the input from the current position to the end of the stream. Se è necessario un maggiore controllo sul numero di caratteri letti dal flusso, utilizzare il Read(Char[], Int32, Int32) overload del metodo, che comporta in genere prestazioni migliori.If more control is needed over how many characters are read from the stream, use the Read(Char[], Int32, Int32) method overload, which generally results in better performance.

ReadToEnd si presuppone che il flusso sa quando ha raggiunto la fine.ReadToEnd assumes that the stream knows when it has reached an end. Per protocolli interattivi in cui il server invia i dati solo quando viene richiesto e non chiude la connessione, ReadToEnd potrebbe bloccarsi in modo indefinito poiché non raggiungerà una fine e deve essere evitata.For interactive protocols in which the server sends data only when you ask for it and does not close the connection, ReadToEnd might block indefinitely because it does not reach an end, and should be avoided.

Si noti che quando si usa il Read metodo, è più efficiente per usare un buffer che è la stessa dimensione del buffer interno del flusso.Note that when using the Read method, it is more efficient to use a buffer that is the same size as the internal buffer of the stream. Se le dimensioni del buffer non è stata specificata quando il flusso è stato costruito, le dimensioni predefinite pari a 4 KB (4096 byte).If the size of the buffer was unspecified when the stream was constructed, its default size is 4 kilobytes (4096 bytes).

Se il metodo genera un' OutOfMemoryException, la posizione del lettore nell'oggetto sottostante Stream oggetto aumenta il numero di caratteri, il metodo è stato in grado di leggere, ma i caratteri già letti in interno ReadLine buffer vengono ignorati .If the current method throws an OutOfMemoryException, the reader's position in the underlying Stream object is advanced by the number of characters the method was able to read, but the characters already read into the internal ReadLine buffer are discarded. Se si modifica la posizione del flusso sottostante dopo la lettura dei dati nel buffer, la posizione del flusso sottostante potrebbe non corrispondere la posizione del buffer interno.If you manipulate the position of the underlying stream after reading data into the buffer, the position of the underlying stream might not match the position of the internal buffer. Per reimpostare il buffer interno, chiamare il DiscardBufferedData metodo; tuttavia, questo metodo determina un rallentamento delle prestazioni e deve essere chiamato solo se assolutamente necessario.To reset the internal buffer, call the DiscardBufferedData method; however, this method slows performance and should be called only when absolutely necessary.

Per un elenco delle attività dei / o comuni, vedere attività dei / o comuni.For a list of common I/O tasks, see Common I/O Tasks.

Si applica a

Vedi anche