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

Définition

Lit tous les caractères entre la position actuelle et la fin du flux.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

Retours

Le reste du flux comme une chaîne, de la position actuelle jusqu'à la fin.The rest of the stream as a string, from the current position to the end. Si la position actuelle est à la fin du flux, retourne une chaîne vide ("").If the current position is at the end of the stream, returns an empty string ("").

Exceptions

La mémoire est insuffisante pour allouer une mémoire tampon à la chaîne retournée.There is insufficient memory to allocate a buffer for the returned string.

Une erreur d’E/S se produit.An I/O error occurs.

Exemples

L’exemple de code suivant lit tout jusqu’à la fin d’un fichier en une seule opération.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.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

Remarques

Cette méthode se substitue à TextReader.ReadToEnd.This method overrides TextReader.ReadToEnd.

ReadToEndfonctionne mieux lorsque vous devez lire toutes les entrées à partir de la position actuelle jusqu’à la fin du flux.ReadToEnd works best when you need to read all the input from the current position to the end of the stream. Si vous avez besoin de davantage de contrôle sur le nombre de caractères lus à partir du Read(Char[], Int32, Int32) flux, utilisez la surcharge de méthode, qui produit généralement de meilleures performances.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.

ReadToEndsuppose que le flux sache quand il a atteint une fin.ReadToEnd assumes that the stream knows when it has reached an end. Pour les protocoles interactifs dans lesquels le serveur envoie des données uniquement lorsque vous le demandez et ne ferme pas ReadToEnd la connexion, peut se bloquer indéfiniment, car il n’atteint pas une fin et doit être évité.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.

Notez que lors de l' Read utilisation de la méthode, il est plus efficace d’utiliser une mémoire tampon de la même taille que la mémoire tampon interne du flux.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. Si la taille de la mémoire tampon n’a pas été spécifiée lors de la construction du flux, sa taille par défaut est de 4 kilo-octets (4096 octets).If the size of the buffer was unspecified when the stream was constructed, its default size is 4 kilobytes (4096 bytes).

Si la méthode actuelle lève une OutOfMemoryException, la position du lecteur dans l’objet sous-jacent Stream est avancée du nombre de caractères que la méthode a pu lire, mais les caractères déjà lus dans la mémoire ReadLine tampon interne sont ignorés .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. Si vous manipulez la position du flux sous-jacent après avoir lu les données dans la mémoire tampon, la position du flux sous-jacent peut ne pas correspondre à la position de la mémoire tampon interne.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. Pour réinitialiser la mémoire tampon interne, appelez DiscardBufferedData la méthode. Toutefois, cette méthode ralentit les performances et doit être appelée uniquement lorsque cela est absolument nécessaire.To reset the internal buffer, call the DiscardBufferedData method; however, this method slows performance and should be called only when absolutely necessary.

Pour obtenir la liste des tâches d’e/s courantes, consultez tâches d’e/s courantes.For a list of common I/O tasks, see Common I/O Tasks.

S’applique à

Voir aussi