Console.ReadLine Méthode

Référence

Définition

Espace de noms:: System

Assembly:: System.Console.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Source:: Console.cs

Source:: Console.cs

Source:: Console.cs

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 la ligne de caractères suivante du flux d'entrée standard.

public:
 static System::String ^ ReadLine();

[System.Runtime.Versioning.UnsupportedOSPlatform("browser")]
public static string? ReadLine ();

[System.Runtime.Versioning.UnsupportedOSPlatform("browser")]
[System.Runtime.Versioning.UnsupportedOSPlatform("android")]
public static string? ReadLine ();

public static string ReadLine ();

[<System.Runtime.Versioning.UnsupportedOSPlatform("browser")>]
static member ReadLine : unit -> string

[<System.Runtime.Versioning.UnsupportedOSPlatform("browser")>]
[<System.Runtime.Versioning.UnsupportedOSPlatform("android")>]
static member ReadLine : unit -> string

static member ReadLine : unit -> string

Public Shared Function ReadLine () As String

Retours

String

Ligne de caractères suivante du flux d'entrée, ou null s'il n'y a plus de lignes disponibles.

Attributs: UnsupportedOSPlatformAttribute

Exceptions

IOException

Une erreur d'E/S s'est produite.

OutOfMemoryException

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

ArgumentOutOfRangeException

Le nombre de caractères dans la ligne de caractères suivante est supérieur à Int32.MaxValue.

Exemples

L’exemple suivant nécessite deux arguments de ligne de commande : le nom d’un fichier texte existant et le nom d’un fichier dans lequel écrire la sortie. Il ouvre le fichier texte existant et redirige l’entrée standard du clavier vers ce fichier. Il redirige également la sortie standard de la console vers le fichier de sortie. Il utilise ensuite la Console.ReadLine méthode pour lire chaque ligne du fichier, remplace chaque séquence de quatre espaces par un caractère de tabulation et utilise la Console.WriteLine méthode pour écrire le résultat dans le fichier de sortie.

using namespace System;
using namespace System::IO;

int main()
{
   array<String^>^args = Environment::GetCommandLineArgs();
   const int tabSize = 4;
   String^ usageText = "Usage: INSERTTABS inputfile.txt outputfile.txt";
   StreamWriter^ writer = nullptr;
   if ( args->Length < 3 )
   {
      Console::WriteLine( usageText );
      return 1;
   }

   try
   {
      // Attempt to open output file.
      writer = gcnew StreamWriter( args[ 2 ] );
      // Redirect standard output from the console to the output file.
      Console::SetOut( writer );
      // Redirect standard input from the console to the input file.
      Console::SetIn( gcnew StreamReader( args[ 1 ] ) );
   }
   catch ( IOException^ e ) 
   {
      TextWriter^ errorWriter = Console::Error;
      errorWriter->WriteLine( e->Message );
      errorWriter->WriteLine( usageText );
      return 1;
   }

   String^ line;
   while ( (line = Console::ReadLine()) != nullptr )
   {
      String^ newLine = line->Replace( ((String^)"")->PadRight( tabSize, ' ' ), "\t" );
      Console::WriteLine( newLine );
   }

   writer->Close();
   
   // Recover the standard output stream so that a 
   // completion message can be displayed.
   StreamWriter^ standardOutput = gcnew StreamWriter( Console::OpenStandardOutput() );
   standardOutput->AutoFlush = true;
   Console::SetOut( standardOutput );
   Console::WriteLine( "INSERTTABS has completed the processing of {0}.", args[ 1 ] );
   return 0;
}

using System;
using System.IO;

public class InsertTabs
{
    private const int tabSize = 4;
    private const string usageText = "Usage: INSERTTABS inputfile.txt outputfile.txt";
    public static int Main(string[] args)
    {
        if (args.Length < 2)
        {
            Console.WriteLine(usageText);
            return 1;
        }

        try
        {
            // Attempt to open output file.
            using (var writer = new StreamWriter(args[1]))
            {
                using (var reader = new StreamReader(args[0]))
                {
                    // Redirect standard output from the console to the output file.
                    Console.SetOut(writer);
                    // Redirect standard input from the console to the input file.
                    Console.SetIn(reader);
                    string line;
                    while ((line = Console.ReadLine()) != null)
                    {
                        string newLine = line.Replace(("").PadRight(tabSize, ' '), "\t");
                        Console.WriteLine(newLine);
                    }
                }
            }
        }
        catch(IOException e)
        {
            TextWriter errorWriter = Console.Error;
            errorWriter.WriteLine(e.Message);
            errorWriter.WriteLine(usageText);
            return 1;
        }

        // Recover the standard output stream so that a
        // completion message can be displayed.
        var standardOutput = new StreamWriter(Console.OpenStandardOutput());
        standardOutput.AutoFlush = true;
        Console.SetOut(standardOutput);
        Console.WriteLine($"INSERTTABS has completed the processing of {args[0]}.");
        return 0;
    }
}

open System
open System.IO

let tabSize = 4
let usageText = "Usage: INSERTTABS inputfile.txt outputfile.txt"

[<EntryPoint>]
let main args =
    if args.Length < 2 then
        Console.WriteLine usageText
        1
    else
        try
            // Attempt to open output file.
            use reader = new StreamReader(args[0])
            use writer = new StreamWriter(args[1])
            
            // Redirect standard output from the console to the output file.
            Console.SetOut writer
            
            // Redirect standard input from the console to the input file.
            Console.SetIn reader
            
            let mutable line = Console.ReadLine()
            while line <> null do
                let newLine = line.Replace(("").PadRight(tabSize, ' '), "\t")
                Console.WriteLine newLine
                line <- Console.ReadLine()

            // Recover the standard output stream so that a
            // completion message can be displayed.
            let standardOutput = new StreamWriter(Console.OpenStandardOutput())
            standardOutput.AutoFlush <- true
            Console.SetOut standardOutput
            Console.WriteLine $"INSERTTABS has completed the processing of {args[0]}."
            0

        with :? IOException as e -> 
            let errorWriter = Console.Error
            errorWriter.WriteLine e.Message
            errorWriter.WriteLine usageText
            1

Imports System.IO

Public Module InsertTabs
    Private Const tabSize As Integer = 4
    Private Const usageText As String = "Usage: INSERTTABS inputfile.txt outputfile.txt"
   
    Public Function Main(args As String()) As Integer
        If args.Length < 2 Then
            Console.WriteLine(usageText)
            Return 1
        End If
      
        Try
            ' Attempt to open output file.
            Using writer As New StreamWriter(args(1))
                Using reader As New StreamReader(args(0))
                    ' Redirect standard output from the console to the output file.
                    Console.SetOut(writer)
                    ' Redirect standard input from the console to the input file.
                    Console.SetIn(reader)
                    Dim line As String = Console.ReadLine()
                    While line IsNot Nothing
                        Dim newLine As String = line.Replace("".PadRight(tabSize, " "c), ControlChars.Tab)
                        Console.WriteLine(newLine)
                        line = Console.ReadLine()
                    End While
                End Using
            End Using
        Catch e As IOException
            Dim errorWriter As TextWriter = Console.Error
            errorWriter.WriteLine(e.Message)
            errorWriter.WriteLine(usageText)
            Return 1
        End Try

        ' Recover the standard output stream so that a 
        ' completion message can be displayed.
        Dim standardOutput As New StreamWriter(Console.OpenStandardOutput())
        standardOutput.AutoFlush = True
        Console.SetOut(standardOutput)
        Console.WriteLine($"INSERTTABS has completed the processing of {args(0)}.")
        Return 0
    End Function 
End Module

Remarques

La ReadLine méthode lit une ligne du flux d’entrée standard. (Pour la définition d’une ligne, consultez le paragraphe après la liste suivante.) Cela signifie que :

Si le périphérique d’entrée standard est le clavier, la ReadLine méthode se bloque jusqu’à ce que l’utilisateur appuie sur la touche Entrée .

L’une des utilisations les plus courantes de la méthode consiste à suspendre l’exécution ReadLine du programme avant d’effacer la console et de lui afficher de nouvelles informations, ou à inviter l’utilisateur à appuyer sur la touche Entrée avant de mettre fin à l’application. L'exemple suivant illustre ce comportement.

using namespace System;

void main()
{
    Console::Clear();

    DateTime dat = DateTime::Now;

    Console::WriteLine("\nToday is {0:d} at {0:T}.", dat);
    Console::Write("\nPress any key to continue... ");
    Console::ReadLine();
}
// The example displays output like the following:
//     Today is 10/26/2015 at 12:22:22 PM.
//     
//     Press any key to continue...

using System;

public class Example
{
   public static void Main()
   {
      Console.Clear();

      DateTime dat = DateTime.Now;

      Console.WriteLine("\nToday is {0:d} at {0:T}.", dat);
      Console.Write("\nPress any key to continue... ");
      Console.ReadLine();
   }
}
// The example displays output like the following:
//     Today is 10/26/2015 at 12:22:22 PM.
//
//     Press any key to continue...

open System

Console.Clear()

let dat = DateTime.Now

printfn $"\nToday is {dat:d} at {dat:T}." 
printf "\nPress any key to continue... "
Console.ReadLine() |> ignore

// The example displays output like the following:
//     Today is 12/28/2021 at 8:23:50 PM.
//
//     Press any key to continue...

Module Example
   Public Sub Main()
      Console.Clear()

      Dim dat As Date = Date.Now

      Console.WriteLine()
      Console.WriteLine("Today is {0:d} at {0:T}.", dat)
      Console.WriteLine()
      Console.Write("Press any key to continue... ")
      Console.ReadLine()
   End Sub
End Module
' The example displays output like the following:
'     Today is 10/26/2015 at 12:22:22 PM.
'     
'     Press any key to continue...

Si l’entrée standard est redirigée vers un fichier, la ReadLine méthode lit une ligne de texte à partir d’un fichier. Par exemple, voici un fichier texte nommé ReadLine1.txt :


This is the first line.
This is the second line.
This is the third line.
This is the fourth line.

L’exemple suivant utilise la méthode pour lire l’entrée ReadLine redirigée à partir d’un fichier. L’opération de lecture se termine lorsque la méthode retourne null, ce qui indique qu’aucune ligne ne reste à lire.

using System;

public class Example
{
   public static void Main()
   {
      if (! Console.IsInputRedirected) {
         Console.WriteLine("This example requires that input be redirected from a file.");
         return;
      }

      Console.WriteLine("About to call Console.ReadLine in a loop.");
      Console.WriteLine("----");
      String s;
      int ctr = 0;
      do {
         ctr++;
         s = Console.ReadLine();
         Console.WriteLine("Line {0}: {1}", ctr, s);
      } while (s != null);
      Console.WriteLine("---");
   }
}
// The example displays the following output:
//       About to call Console.ReadLine in a loop.
//       ----
//       Line 1: This is the first line.
//       Line 2: This is the second line.
//       Line 3: This is the third line.
//       Line 4: This is the fourth line.
//       Line 5:
//       ---

open System

if not Console.IsInputRedirected then
    printfn "This example requires that input be redirected from a file."

printfn "About to call Console.ReadLine in a loop."
printfn "----"

let mutable s = ""
let mutable i = 0

while s <> null do
    i <- i + 1
    s <- Console.ReadLine()
    printfn $"Line {i}: {s}"
printfn "---"


// The example displays the following output:
//       About to call Console.ReadLine in a loop.
//       ----
//       Line 1: This is the first line.
//       Line 2: This is the second line.
//       Line 3: This is the third line.
//       Line 4: This is the fourth line.
//       Line 5:
//       ---

Module Example
   Public Sub Main()
      If Not Console.IsInputRedirected Then
         Console.WriteLine("This example requires that input be redirected from a file.")
         Exit Sub 
      End If

      Console.WriteLine("About to call Console.ReadLine in a loop.")
      Console.WriteLine("----")
      Dim s As String
      Dim ctr As Integer
      Do
         ctr += 1
         s = Console.ReadLine()
         Console.WriteLine("Line {0}: {1}", ctr, s)
      Loop While s IsNot Nothing
      Console.WriteLine("---")
   End Sub
End Module
' The example displays the following output:
'       About to call Console.ReadLine in a loop.
'       ----
'       Line 1: This is the first line.
'       Line 2: This is the second line.
'       Line 3: This is the third line.
'       Line 4: This is the fourth line.
'       Line 5:
'       ---

Après avoir compilé l’exemple dans un exécutable nommé ReadLine1.exe, vous pouvez l’exécuter à partir de la ligne de commande pour lire le contenu du fichier et l’afficher dans la console. La syntaxe est :

ReadLine1 < ReadLine1.txt

Une ligne est définie comme une séquence de caractères suivie d’un retour chariot (0x000d hexadécimal), d’un flux de ligne (0x000a hexadécimal) ou de la valeur de la Environment.NewLine propriété . La chaîne retournée ne contient pas le ou les caractères de fin. Par défaut, la méthode lit l’entrée d’une mémoire tampon d’entrée de 256 caractères. Étant donné que cela inclut le ou les Environment.NewLine caractères, la méthode peut lire des lignes qui contiennent jusqu’à 254 caractères. Pour lire des lignes plus longues, appelez la OpenStandardInput(Int32) méthode .

La ReadLine méthode s’exécute de manière synchrone. Autrement dit, il se bloque jusqu’à ce qu’une ligne soit lue ou que la combinaison de claviers Ctrl+Z (suivie d’Entrée sur Windows) soit enfoncée. La In propriété retourne un TextReader objet qui représente le flux d’entrée standard et qui a à la fois une méthode synchrone TextReader.ReadLine et une méthode asynchrone TextReader.ReadLineAsync . Toutefois, lorsqu’il est utilisé comme flux d’entrée standard de la console, le TextReader.ReadLineAsync s’exécute de manière synchrone plutôt que asynchrone et ne retourne un Task<String> qu’une fois l’opération de lecture terminée.

Si cette méthode lève une OutOfMemoryException exception, 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. Étant donné que la position du lecteur dans le flux ne peut pas être modifiée, les caractères déjà lus ne sont pas récupérables et sont accessibles uniquement en réinitialisant le TextReader. Si la position initiale dans le flux est inconnue ou si le flux ne prend pas en charge la recherche, le sous-jacent Stream doit également être réinitialisé. Pour éviter une telle situation et produire du code robuste, vous devez utiliser la propriété et ReadKey la KeyAvailable méthode et stocker les caractères de lecture dans une mémoire tampon pré-allouée.

Si la combinaison de touches Ctrl+Z (suivie de La touche Entrée sur Windows) est enfoncée lorsque la méthode lit l’entrée à partir de la console, la méthode retourne null. Cela permet à l’utilisateur d’empêcher d’autres entrées au clavier lorsque la ReadLine méthode est appelée dans une boucle. L’exemple suivant illustre ce scénario.

using namespace System;

void main()
{
   String^ line;
   Console::WriteLine("Enter one or more lines of text (press CTRL+Z to exit):");
   Console::WriteLine();
   do { 
      Console::Write("   ");
      line = Console::ReadLine();
      if (line != nullptr) 
         Console::WriteLine("      " + line);
   } while (line != nullptr);   
}
// The following displays possible output from this example:
//       Enter one or more lines of text (press CTRL+Z to exit):
//       
//          This is line #1.
//             This is line #1.
//          This is line #2
//             This is line #2
//          ^Z
//       
//       >}

using System;

public class Example
{
   public static void Main()
   {
      string line;
      Console.WriteLine("Enter one or more lines of text (press CTRL+Z to exit):");
      Console.WriteLine();
      do {
         Console.Write("   ");
         line = Console.ReadLine();
         if (line != null)
            Console.WriteLine("      " + line);
      } while (line != null);
   }
}
// The following displays possible output from this example:
//       Enter one or more lines of text (press CTRL+Z to exit):
//
//          This is line #1.
//             This is line #1.
//          This is line #2
//             This is line #2
//          ^Z
//
//       >

open System

printfn "Enter one or more lines of text (press CTRL+Z to exit):\n"

let mutable line = ""

while line <> null do
    printf "   "
    line <- Console.ReadLine()
    if line <> null then
        printfn $"      {line}"


// The following displays possible output from this example:
//       Enter one or more lines of text (press CTRL+Z to exit):
//
//          This is line #1.
//             This is line #1.
//          This is line #2
//             This is line #2
//          ^Z
//
//       >

Module Example
   Public Sub Main()
      Dim line As String
      Console.WriteLine("Enter one or more lines of text (press CTRL+Z to exit):")
      Console.WriteLine()
      Do 
         Console.Write("   ")
         line = Console.ReadLine()
         If line IsNot Nothing Then Console.WriteLine("      " + line)
      Loop While line IsNot Nothing   
   End Sub
End Module
' The following displays possible output from this example:
'       Enter one or more lines of text (press CTRL+Z to exit):
'       
'          This is line #1.
'             This is line #1.
'          This is line #2
'             This is line #2
'          ^Z
'       
'       >

S’applique à

Partager via