Console.ReadLine Methode
Definition
Wichtig
Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.
Liest die nächste Zeile von Zeichen aus dem Standardeingabestream.
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 -> stringstatic member ReadLine : unit -> stringPublic Shared Function ReadLine () As StringGibt zurück
Die nächste Zeile von Zeichen aus dem Eingabestream oder null, wenn keine weiteren Zeilen verfügbar sind.
- Attribute
Ausnahmen
E/A-Fehler
Es ist nicht genügend Speicher vorhanden, um einen Puffer für die zurückgegebene Zeichenfolge zuzuordnen.
Die Anzahl der Zeichen in der nächsten Zeichenzeile ist größer als Int32.MaxValue.
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
'
' >
