Console.ReadLine Metódus

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

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

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

public static string ReadLine();

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

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

static member ReadLine : unit -> string

Public Shared Function ReadLine () As String

Válaszok

A bemeneti adatfolyam következő karaktersora, vagy null ha nincs több sor.

Attribútumok

UnsupportedOSPlatformAttribute

Kivételek

Példák

A következő példához két parancssori argumentum szükséges: egy meglévő szövegfájl neve és egy fájl neve a kimenet írásához. Megnyitja a meglévő szövegfájlt, és átirányítja a standard bemenetet a billentyűzetről az adott fájlba. Emellett átirányítja a standard kimenetet a konzolról a kimeneti fájlba. Ezután a metódussal Console.ReadLine beolvassa a fájl minden sorát, lecseréli a négy szóköz minden sorozatát egy tabulátor karakterre, és a Console.WriteLine metódussal írja az eredményt a kimeneti fájlba.

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

Megjegyzések

A ReadLine metódus egy sort olvas be a standard bemeneti adatfolyamból. (Egy sor definícióját a következő lista utáni bekezdésben találja.) Ez azt jelenti, hogy:

• Ha a standard beviteli eszköz a billentyűzet, a ReadLine metódus addig blokkol, amíg a felhasználó nem nyomja le az Enter billentyűt.

  A módszer egyik leggyakoribb felhasználási módja a ReadLine program végrehajtásának szüneteltetése a konzol törlése és új információk megjelenítése előtt, vagy az alkalmazás bezárása előtt az Enter billentyű lenyomása. A következő példa ezt szemlélteti.

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

• Ha a standard bemenetet egy fájlba irányítja át, a ReadLine metódus egy szövegsort olvas be egy fájlból. A következő például egy ReadLine1.txtnevű szövegfájl:

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

  Az alábbi példa a fájlból átirányított bemenet olvasására használja a ReadLine metódust. Az olvasási művelet akkor fejeződik be, amikor a metódus visszatér null, ami azt jelzi, hogy egyetlen sor sem marad olvasható.

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

  Miután lefordította a példát egy ReadLine1.exenevű végrehajtható fájlra, futtathatja a parancssorból a fájl tartalmának olvasásához és a konzolon való megjelenítéséhez. A szintaxis a következő:

  ReadLine1 < ReadLine1.txt
  

A vonal karaktersorozatként van definiálva, amelyet kocsivissza (hexadecimális 0x000d), vonalcsatorna (hexadecimális 0x000a) vagy a Environment.NewLine tulajdonság értéke követ. A visszaadott sztring nem tartalmazza a végződő karakter(ek)et. A metódus alapértelmezés szerint egy 256 karakteres bemeneti pufferből olvassa be a bemenetet. Mivel ez magában foglalja a Environment.NewLine karakter(ek)et, a metódus legfeljebb 254 karakterből álló sorokat tud olvasni. Hosszabb sorok olvasásához hívja meg a metódust OpenStandardInput(Int32) .

A ReadLine metódus szinkron módon fut. Vagyis addig blokkolja a vonalat, amíg a Ctrl+Z billentyűkombinációt (Enter Windows) lenyomja. A In tulajdonság egy TextReader olyan objektumot ad vissza, amely a standard bemeneti adatfolyamot képviseli, és szinkron és aszinkron TextReader.ReadLine metódussal is TextReader.ReadLineAsync rendelkezik. Ha azonban a konzol szabványos bemeneti adatfolyamaként használják, a TextReader.ReadLineAsync rendszer aszinkron helyett szinkron módon hajtja végre a műveletet, és csak az olvasási művelet befejezése után ad vissza Task<String> .

Ha ez a metódus kivételt OutOfMemoryException jelez, az olvasó pozícióját az alapul szolgáló Stream objektumban a metódus által olvasható karakterek száma emeli ki, de a belső ReadLine pufferbe már beolvasott karakterek elvesznek. Mivel az olvasó pozíciója a streamben nem módosítható, a már beolvasott karakterek helyreállíthatatlanok, és csak az TextReaderújraincializálással érhetők el. Ha a stream kezdeti pozíciója ismeretlen, vagy a stream nem támogatja a keresést, az alapul szolgálót Stream is újra kell inicializálni. Az ilyen helyzet elkerülése és a robusztus kód létrehozása érdekében használja a tulajdonságot és KeyAvailable a ReadKey metódust, és tárolja az olvasási karaktereket egy előre lefoglalt pufferben.

Ha a Ctrl+Z billentyűkombinációt (majd Enter Windows) lenyomja, amikor a metódus beolvassa a bemenetet a konzolról, a metódus null ad vissza. Ez lehetővé teszi a felhasználó számára, hogy megakadályozza a további billentyűzetbemenetet, amikor a ReadLine metódust ciklusban hívják meg. Az alábbi példa ezt a forgatókönyvet szemlélteti.

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

Lásd még

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