Console.ReadLine Yöntem

Başvuru

Tanım

Ad Alanı:: System

Bütünleştirilmiş Kod:: System.Console.dll

Bütünleştirilmiş Kod:: mscorlib.dll

Bütünleştirilmiş Kod:: netstandard.dll

Kaynak:: Console.cs

Kaynak:: Console.cs

Kaynak:: Console.cs

Önemli

Bazı bilgiler ürünün ön sürümüyle ilgilidir ve sürüm öncesinde önemli değişiklikler yapılmış olabilir. Burada verilen bilgilerle ilgili olarak Microsoft açık veya zımni hiçbir garanti vermez.

Standart giriş akışından sonraki karakter satırını okur.

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

Döndürülenler

String

Giriş akışındaki bir sonraki karakter satırı veya null başka satır yoksa.

Öznitelikler: UnsupportedOSPlatformAttribute

Özel durumlar

IOException

G/ç hatası oluştu.

OutOfMemoryException

Döndürülen dize için arabellek ayırmaya yetecek bellek yok.

ArgumentOutOfRangeException

Sonraki karakter satırındaki karakter sayısı Int32.MaxValue değerinden büyük.

Örnekler

Aşağıdaki örnek iki komut satırı bağımsız değişkeni gerektirir: var olan bir metin dosyasının adı ve çıkışın yazacak dosya adı. Mevcut metin dosyasını açar ve standart girişi klavyeden bu dosyaya yönlendirir. Ayrıca konsoldaki standart çıkışı çıkış dosyasına yönlendirir. Ardından dosyadaki Console.ReadLine her satırı okumak için yöntemini kullanır, dört boşluğun her dizisini bir sekme karakteriyle değiştirir ve sonucu çıkış dosyasına yazmak için yöntemini kullanır Console.WriteLine .

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

Açıklamalar

yöntemi, ReadLine standart giriş akışından bir satır okur. (Satırın tanımı için aşağıdaki listeden sonraki paragrafa bakın.) Bu, şu anlama gelir:

Standart giriş cihazı klavyeyse, ReadLine kullanıcı Enter tuşuna basana kadar yöntem engeller.

Yöntemin en yaygın kullanımlarından ReadLine biri, konsolu temizlemeden ve yeni bilgileri görüntülemeden önce program yürütmeyi duraklatmak veya kullanıcıdan uygulamayı sonlandırmadan önce Enter tuşuna basmasını istemde bulunabilmektir. Aşağıdaki örnek bunu göstermektedir.

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

Standart giriş bir dosyaya yeniden yönlendiriliyorsa, ReadLine yöntem bir dosyadan metin satırını okur. Örneğin, aşağıda ReadLine1.txt adlı bir metin dosyası verilmiştir:


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

Aşağıdaki örnek, bir dosyadan yeniden yönlendirilen girişi okumak için yöntemini kullanır ReadLine . Yöntemi döndürdüğünde nullokuma işlemi sonlandırıldığında, okunacak satır kalmadığını gösterir.

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

Örneği ReadLine1.exe adlı bir yürütülebilir dosyaya derledikten sonra, dosyanın içeriğini okumak ve konsolda görüntülemek için komut satırından çalıştırabilirsiniz. Söz dizimi aşağıdaki gibidir:

ReadLine1 < ReadLine1.txt

Satır, bir satır başı (onaltılık 0x000d), satır beslemesi (onaltılık 0x000a) veya özelliğin Environment.NewLine değeri tarafından izlenen karakter dizisi olarak tanımlanır. Döndürülen dize sonlandırıcı karakterleri içermiyor. Varsayılan olarak, yöntemi 256 karakterlik giriş arabelleğinden girişi okur. Bu karakterleri içerdiğinden Environment.NewLine , yöntem en fazla 254 karakter içeren satırları okuyabilir. Daha uzun satırları okumak için yöntemini çağırın OpenStandardInput(Int32) .

ReadLine yöntemi zaman uyumlu olarak yürütülür. Başka bir ifadeyle, bir satır okunana veya Ctrl+Z klavye bileşimine (Ardından Windows'da Enter tuşuna) basılana kadar engeller. özelliği, In standart giriş akışını temsil eden ve hem zaman uyumlu TextReader.ReadLine yöntemi hem de zaman uyumsuz TextReader.ReadLineAsync yöntemi olan bir nesnesi döndürürTextReader. Ancak, konsolun standart giriş akışı olarak kullanıldığında, TextReader.ReadLineAsync zaman uyumsuz olarak değil zaman uyumlu olarak yürütülür ve yalnızca okuma işlemi tamamlandıktan sonra bir Task<String> döndürür.

Bu yöntem bir OutOfMemoryException özel durum oluşturursa, okuyucunun temel nesnedeki Stream konumu yöntemin okuyabildiği karakter sayısıyla gelişmiştir, ancak iç ReadLine arabelleğe zaten okunan karakterler atılır. Okuyucunun akıştaki konumu değiştirilemediğinden, zaten okunan karakterler kurtarılamaz ve yalnızca yeniden TextReaderbaşlatılarak erişilebilir. Akış içindeki ilk konum bilinmiyorsa veya akış aramayı desteklemiyorsa, temel alınan Stream konumun da yeniden başlatılması gerekir. Böyle bir durumdan kaçınmak ve sağlam kod oluşturmak için özelliğini ve yöntemini kullanmanız KeyAvailable ve ReadKey okuma karakterlerini önceden ayrılmış bir arabellekte depolamanız gerekir.

Yöntem konsolundan girişi okurken Ctrl+Z tuş bileşimine (ardından Windows'da Enter tuşuna) basılırsa, yöntem döndürür null. Bu, yöntem bir döngüde çağrıldığında ReadLine kullanıcının daha fazla klavye girişini engellemesini sağlar. Aşağıdaki örnekte bu senaryo gösterilmektedir.

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

Şunlara uygulanır

Aracılığıyla paylaş