StreamReader.Read 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

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Lit le caractère ou l'ensemble de caractères suivant dans le flux d'entrée.

Surcharges

Read()	Lit le caractère suivant dans le flux d'entrée et avance la position d'un caractère.
Read(Span<Char>)	Lit les caractères du flux actuel dans une étendue.
Read(Char[], Int32, Int32)	Lit un nombre maximal de caractères spécifié du flux actuel dans une mémoire tampon, en commençant à l'index spécifié.

Read()

Source:: StreamReader.cs

Source:: StreamReader.cs

Source:: StreamReader.cs

Lit le caractère suivant dans le flux d'entrée et avance la position d'un caractère.

public:
 override int Read();

public override int Read ();

override this.Read : unit -> int

Public Overrides Function Read () As Integer

Retours

Int32

Caractère suivant du flux d'entrée, représenté sous la forme d'un objet Int32, ou -1 s'il n'y a plus de caractère disponible.

Exceptions

IOException

Une erreur d’E/S se produit.

Exemples

L’exemple de code suivant illustre une utilisation simple de la Read méthode.

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
      {
         while ( sr->Peek() >= 0 )
         {
            Console::Write( (Char)sr->Read() );
         }
      }
      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))
            {
                while (sr.Peek() >= 0)
                {
                    Console.Write((char)sr.Read());
                }
            }
        }
        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)

            Do While sr.Peek() >= 0
                Console.Write(Convert.ToChar(sr.Read()))
            Loop
            sr.Close()
        Catch e As Exception
            Console.WriteLine("The process failed: {0}", e.ToString())
        End Try
    End Sub
End Class

L’exemple de code suivant illustre la lecture d’un caractère unique à l’aide de la Read() surcharge de méthode, en mettant en forme la sortie d’entier ASCII comme décimal et hexadécimal.

using namespace System;
using namespace System::IO;
int main()
{
   
   //Create a FileInfo instance representing an existing text file.
   FileInfo^ MyFile = gcnew FileInfo( "c:\\csc.txt" );
   
   //Instantiate a StreamReader to read from the text file.
   StreamReader^ sr = MyFile->OpenText();
   
   //Read a single character.
   int FirstChar = sr->Read();
   
   //Display the ASCII number of the character read in both decimal and hexadecimal format.
   Console::WriteLine( "The ASCII number of the first character read is {0:D} in decimal and {1:X} in hexadecimal.", FirstChar, FirstChar );
   
   //
   sr->Close();
}

using System;
using System.IO;

class StrmRdrRead
{
public static void Main()
    {
    //Create a FileInfo instance representing an existing text file.
    FileInfo MyFile=new FileInfo(@"c:\csc.txt");
    //Instantiate a StreamReader to read from the text file.
    StreamReader sr=MyFile.OpenText();
    //Read a single character.
    int FirstChar=sr.Read();
    //Display the ASCII number of the character read in both decimal and hexadecimal format.
    Console.WriteLine("The ASCII number of the first character read is {0:D} in decimal and {1:X} in hexadecimal.",
        FirstChar, FirstChar);
    //
    sr.Close();
    }
}

Imports System.IO

Class StrmRdrRead
   
   Public Shared Sub Main()
      'Create a FileInfo instance representing an existing text file.
      Dim MyFile As New FileInfo("c:\csc.txt")
      'Instantiate a StreamReader to read from the text file.
      Dim sr As StreamReader = MyFile.OpenText()
      'Read a single character.
      Dim FirstChar As Integer = sr.Read()
      'Display the ASCII number of the character read in both decimal and hexadecimal format.
      Console.WriteLine("The ASCII number of the first character read is {0:D} in decimal and {1:X} in hexadecimal.", FirstChar, FirstChar)
      sr.Close()
   End Sub
End Class

Remarques

Cette méthode se substitue à TextReader.Read.

Cette méthode retourne un entier afin qu’il puisse retourner -1 si la fin du flux a été atteinte. 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.

Voir aussi

S’applique à

Read(Span<Char>)

Source:: StreamReader.cs

Source:: StreamReader.cs

Source:: StreamReader.cs

Lit les caractères du flux actuel dans une étendue.

public:
 override int Read(Span<char> buffer);

public override int Read (Span<char> buffer);

override this.Read : Span<char> -> int

Public Overrides Function Read (buffer As Span(Of Char)) As Integer

Paramètres

buffer: Span<Char>

Quand cette méthode retourne un résultat, contient l’étendue spécifiée de caractères remplacés par les caractères lus dans la source actuelle.

Retours

Int32

Le nombre de caractères qui ont été lus, ou 0 si c'est la fin du flux et qu'aucune donnée n'a été lue. Le nombre sera inférieur ou égal à la longueur buffer, selon que les données sont, ou non, disponibles dans le flux.

Exceptions

IOException

Le nombre de caractères lus à partir du flux est supérieur à la longueur buffer.

ArgumentNullException

buffer a la valeur null.

S’applique à

Read(Char[], Int32, Int32)

Source:: StreamReader.cs

Source:: StreamReader.cs

Source:: StreamReader.cs

Lit un nombre maximal de caractères spécifié du flux actuel dans une mémoire tampon, en commençant à l'index spécifié.

public:
 override int Read(cli::array <char> ^ buffer, int index, int count);

public override int Read (char[] buffer, int index, int count);

override this.Read : char[] * int * int -> int

Public Overrides Function Read (buffer As Char(), index As Integer, count As Integer) As Integer

Paramètres

buffer: Char[]

Quand cette méthode retourne un résultat, contient le tableau de caractères spécifié dont les valeurs comprises entre index et (index + count - 1) sont remplacées par les caractères lus dans la source actuelle.

index: Int32

Index de buffer auquel commencer l'écriture.

count: Int32

Nombre maximal de caractères à lire.

Retours

Int32

Le nombre de caractères qui ont été lus, ou 0 si c'est la fin du flux et qu'aucune donnée n'a été lue. Le nombre sera inférieur ou égal à la valeur du paramètre count, selon que les données sont, ou non, disponibles dans le flux.

Exceptions

ArgumentException

La longueur de la mémoire tampon moins index est inférieure à count.

ArgumentNullException

buffer a la valeur null.

ArgumentOutOfRangeException

index ou count est un nombre négatif.

IOException

Une erreur d’E/S, telle que la fermeture du flux, se produit.

Exemples

L’exemple de code suivant lit cinq caractères à la fois jusqu’à ce que la fin du fichier soit atteinte.

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 is an arbitrary size for this example.
         array<Char>^c = nullptr;
         while ( sr->Peek() >= 0 )
         {
            c = gcnew array<Char>(5);
            sr->Read( c, 0, c->Length );
            
            //The output will look odd, because
            //only five characters are read at a time.
            Console::WriteLine( c );
         }
      }
      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 is an arbitrary size for this example.
                char[] c = null;

                while (sr.Peek() >= 0)
                {
                    c = new char[5];
                    sr.Read(c, 0, c.Length);
                    //The output will look odd, because
                    //only five characters are read at a time.
                    Console.WriteLine(c);
                }
            }
        }
        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)

            Do While sr.Peek() >= 0
                'This is an arbitrary size for this example.
                Dim c(5) As Char
                sr.Read(c, 0, c.Length)
                'The output will look odd, because
                'only five characters are read at a time.
                Console.WriteLine(c)
            Loop
            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.Read.

Cette méthode retourne un entier afin qu’il puisse renvoyer 0 si la fin du flux a été atteinte.

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, où la mémoire tampon interne est définie sur la taille de bloc souhaitée, et de toujours lire moins que la taille de bloc. Si la taille de la mémoire tampon interne 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 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.

Cette méthode retourne une fois que le nombre de caractères spécifié par le count paramètre a été lu ou que la fin du fichier est atteinte. ReadBlock est une version bloquante de Read.

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

Voir aussi

S’applique à

Partager via

StreamReader.Read Méthode

Définition

Surcharges

Read()

Retours

Exceptions

Exemples

Remarques

Voir aussi

S’applique à

Read(Span<Char>)

Paramètres

Retours

Exceptions

S’applique à

Read(Char[], Int32, Int32)

Paramètres

Retours

Exceptions

Exemples

Remarques

Voir aussi

S’applique à

Ressources supplémentaires