StreamReader.ReadToEnd Méthode

  • Référence

Définition

Espace de noms:
System.IO
Assembly:
System.IO.dll
Assembly:
System.Runtime.dll
Assembly:
System.Runtime.Extensions.dll
Assembly:
mscorlib.dll
Assembly:
netstandard.dll
Source:
StreamReader.cs
Source:
StreamReader.cs
Source:
StreamReader.cs

Lit tous les caractères entre la position actuelle et la fin du flux.

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

Retours

String

Le reste du flux sous forme de chaîne, de la position actuelle jusqu'à la fin. Si la position actuelle est à la fin du flux, retourne une chaîne vide ("").

Exceptions

OutOfMemoryException

La mémoire est insuffisante pour allouer une mémoire tampon à la chaîne retournée.

IOException

Une erreur d’E/S se produit.

Exemples

L’exemple de code suivant lit jusqu’à la fin d’un fichier en une seule opération.

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.

ReadToEnd fonctionne mieux lorsque vous devez lire toutes les entrées de la position actuelle à la fin du flux. Si davantage de contrôle est nécessaire sur le nombre de caractères lus à partir du flux, utilisez la surcharge de méthode Read(Char[], Int32, Int32) , ce qui se traduit généralement par de meilleures performances.

ReadToEnd suppose que le flux sait quand il a atteint une fin. Pour les protocoles interactifs dans lesquels le serveur envoie des données uniquement lorsque vous les demandez et ne ferme pas la connexion, ReadToEnd peut se bloquer indéfiniment, car il n’atteint pas de fin et doit être évité.

Notez que lors de l’utilisation de la Read 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. Si la taille de la mémoire tampon n’était pas spécifiée lors de la construction du flux, sa taille par défaut est de 4 kilo-octets (4 096 octets).

Si la méthode actuelle lève un OutOfMemoryException, la position du lecteur dans l’objet sous-jacent Stream est avancée par le nombre de caractères que la méthode a pu lire, mais les caractères déjà lus dans la mémoire tampon interne ReadLine sont ignorés. Si vous manipulez la position du flux sous-jacent après avoir lu des 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. Pour réinitialiser la mémoire tampon interne, appelez la DiscardBufferedData méthode ; toutefois, cette méthode ralentit les performances et ne doit être appelée que lorsque cela est absolument nécessaire.

Pour obtenir la liste des tâches d’E/S courantes, consultez Tâches courantes d’E/S.

S’applique à

Voir aussi