Console.ReadLine Methode

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

Gibt zurück

Die nächste Zeile von Zeichen aus dem Eingabestream oder null, wenn keine weiteren Zeilen verfügbar sind.

Attribute

UnsupportedOSPlatformAttribute

Ausnahmen

Beispiele

Im folgenden Beispiel sind zwei Befehlszeilenargumente erforderlich: der Name einer vorhandenen Textdatei und der Name einer Datei, in die die Ausgabe geschrieben werden soll. Es öffnet die vorhandene Textdatei und leitet die Standardeingabe von der Tastatur an diese Datei um. Außerdem wird die Standardausgabe von der Konsole in die Ausgabedatei umgeleitet. Anschließend wird die Console.ReadLine -Methode verwendet, um jede Zeile in der Datei zu lesen, jede Sequenz von vier Leerzeichen durch ein Tabstoppzeichen ersetzt und die Console.WriteLine -Methode verwendet, um das Ergebnis in die Ausgabedatei zu schreiben.

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

Hinweise

Die ReadLine -Methode liest eine Zeile aus dem Standardeingabedatenstrom. (Die Definition einer Zeile finden Sie im Absatz nach der folgenden Liste.) Dies bedeutet, dass:

• Wenn das Standardeingabegerät die Tastatur ist, wird die ReadLine -Methode blockiert, bis der Benutzer die EINGABETASTE drückt.

  Eine der häufigsten Verwendungsmöglichkeiten der -Methode besteht darin, die ReadLine Programmausführung vor dem Löschen der Konsole anzuhalten und neue Informationen anzuzeigen, oder den Benutzer aufzufordern, die EINGABETASTE zu drücken, bevor die Anwendung beendet wird. Dies wird anhand des folgenden Beispiels veranschaulicht.

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

• Wenn die Standardeingabe an eine Datei umgeleitet wird, liest die ReadLine Methode eine Textzeile aus einer Datei. Im Folgenden finden Sie beispielsweise eine Textdatei mit dem Namen ReadLine1.txt:

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

  Im folgenden Beispiel wird die -Methode zum Lesen von ReadLine Eingaben verwendet, die aus einer Datei umgeleitet werden. Der Lesevorgang wird beendet, wenn die -Methode zurückgibt null, was angibt, dass keine Zeilen mehr gelesen werden müssen.

  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:
  '       ---
  

  Nachdem Sie das Beispiel in eine ausführbare Datei namens ReadLine1.exe kompiliert haben, können Sie es über die Befehlszeile ausführen, um den Inhalt der Datei zu lesen und in der Konsole anzuzeigen. Die Syntax ist:

  ReadLine1 < ReadLine1.txt
  

Eine Zeile wird als Folge von Zeichen definiert, gefolgt von einem Wagenrücklauf (hexadezimal 0x000d), einem Zeilenvorschub (hexadezimal 0x000a) oder dem Wert der Environment.NewLine -Eigenschaft. Die zurückgegebene Zeichenfolge enthält keine abschlussenden Zeichen. Standardmäßig liest die -Methode Eingaben aus einem 256-stelligen Eingabepuffer. Da dies die Environment.NewLine Zeichen enthält, kann die -Methode Zeilen lesen, die bis zu 254 Zeichen enthalten. Um längere Zeilen zu lesen, rufen Sie die OpenStandardInput(Int32) -Methode auf.

Die ReadLine -Methode wird synchron ausgeführt. Das heißt, es wird blockiert, bis eine Zeile gelesen wird oder die Tastenkombination STRG+Z (gefolgt von der EINGABETASTE unter Windows) gedrückt wird. Die In -Eigenschaft gibt ein TextReader -Objekt zurück, das den Standardeingabedatenstrom darstellt und sowohl über eine synchrone TextReader.ReadLine als auch über eine asynchrone TextReader.ReadLineAsync Methode verfügt. Wenn sie jedoch als Standardeingabestream der Konsole verwendet wird, wird der TextReader.ReadLineAsync synchron und nicht asynchron ausgeführt und gibt erst zurück, Task<String> nachdem der Lesevorgang abgeschlossen ist.

Wenn diese Methode eine OutOfMemoryException Ausnahme auslöst, wird die Position des Lesers im zugrunde liegenden Stream Objekt um die Anzahl der Zeichen erweitert, die die Methode lesen konnte, aber die bereits in den internen ReadLine Puffer gelesenen Zeichen werden verworfen. Da die Position des Readers im Stream nicht geändert werden kann, sind die bereits gelesenen Zeichen nicht wiederherstellbar und können nur durch erneute Initialisierung des TextReaderzugegriffen werden. Wenn die anfängliche Position im Stream unbekannt ist oder der Stream die Suche nicht unterstützt, muss auch die zugrunde liegende Stream neu initialisiert werden. Um eine solche Situation zu vermeiden und robusten Code zu erzeugen, sollten Sie die -Eigenschaft und ReadKey -KeyAvailableMethode verwenden und die Lesezeichen in einem vorab zugewiesenen Puffer speichern.

Wenn die Tastenkombination STRG+Z (gefolgt von der EINGABETASTE unter Windows) gedrückt wird, wenn die -Methode Eingaben aus der Konsole liest, gibt die -Methode zurück null. Dadurch kann der Benutzer weitere Tastatureingaben verhindern, wenn die ReadLine Methode in einer Schleife aufgerufen wird. Dies wird im folgenden Beispiel veranschaulicht.

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
'       
'       >

Gilt für:

Weitere Informationen

• Read()
• Write(String, Object)
• WriteLine()