Console.ReadLine Console.ReadLine Console.ReadLine Console.ReadLine Method

Definizione

Legge la riga successiva di caratteri dal flusso di input standard.Reads the next line of characters from the standard input stream.

public:
 static System::String ^ ReadLine();
public static string ReadLine ();
static member ReadLine : unit -> string
Public Shared Function ReadLine () As String

Restituisce

Riga successiva di caratteri dal flusso di input oppure null se non ci sono altre righe disponibili.The next line of characters from the input stream, or null if no more lines are available.

Eccezioni

Si è verificato un errore di I/O.An I/O error occurred.

La memoria disponibile non è sufficiente per l’allocazione di un buffer per la stringa restituita.There is insufficient memory to allocate a buffer for the returned string.

Il numero di caratteri nella riga successiva è maggiore di MaxValue.The number of characters in the next line of characters is greater than MaxValue.

Esempi

Nell'esempio seguente sono necessari due argomenti della riga di comando: il nome di un file di testo esistente e il nome di un file in cui scrivere l'output.The following example requires two command line arguments: the name of an existing text file, and the name of a file to write the output to. Apre il file di testo esistente e reindirizza l'input standard dalla tastiera a tale file.It opens the existing text file and redirects the standard input from the keyboard to that file. Reindirizza inoltre l'output standard dalla console di al file di output.It also redirects the standard output from the console to the output file. USA quindi il Console.ReadLine metodo per leggere ogni riga nel file, sostituisce ogni sequenza di quattro spazi con un carattere di tabulazione e usa il Console.WriteLine metodo per scrivere il risultato nel file di output.It then uses the Console.ReadLine method to read each line in the file, replaces every sequence of four spaces with a tab character, and uses the Console.WriteLine method to write the result to the output file.

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;
    }
}
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

Commenti

Il ReadLine metodo legge una riga dal flusso di input standard.The ReadLine method reads a line from the standard input stream. Per la definizione di una riga, vedere il paragrafo dopo l'elenco seguente. Vale a dire che:(For the definition of a line, see the paragraph after the following list.) This means that:

  • Se il dispositivo di input standard è la tastiera, ReadLine il metodo si blocca fino a quando l'utente preme il tasto invio .If the standard input device is the keyboard, the ReadLine method blocks until the user presses the Enter key.

    Uno degli usi più comuni del ReadLine metodo consiste nel sospendere l'esecuzione del programma prima di cancellare la console e visualizzarvi nuove informazioni oppure per chiedere all'utente di premere il tasto invio prima di terminare l'applicazione.One of the most common uses of the ReadLine method is to pause program execution before clearing the console and displaying new information to it, or to prompt the user to press the Enter key before terminating the application. Questa condizione è illustrata nell'esempio seguente.The following example illustrates this.

    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...
    
    
    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...
    
  • Se l'input standard viene reindirizzato a un ReadLine file, il metodo legge una riga di testo da un file.If standard input is redirected to a file, the ReadLine method reads a line of text from a file. Ad esempio, di seguito è riportato un file di testo denominato ReadLine1. txt:For example, the following is a text file named ReadLine1.txt:

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

    Nell'esempio seguente viene usato ReadLine il metodo per leggere l'input che viene reindirizzato da un file.The following example uses the ReadLine method to read input that is redirected from a file. L'operazione di lettura termina quando il metodo restituisce null, che indica che non è ancora possibile leggere alcuna riga.The read operation terminates when the method returns null, which indicates that no lines remain to be read.

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

    Dopo aver compilato l'esempio in un eseguibile denominato ReadLine1. exe, è possibile eseguirlo dalla riga di comando con la sintassiAfter compiling the example to an executable named ReadLine1.exe, you can run it from the command line with the syntax

    ReadLine1 < ReadLine1.txt  
    

    per leggere il contenuto del file e visualizzarli nella console.to read the contents of the file and display them to the console.

Una linea è definita come sequenza di caratteri seguita da un ritorno a capo (0x000d esadecimale), da un avanzamento riga (0x000a esadecimale) o dal valore Environment.NewLine della proprietà.A line is defined as a sequence of characters followed by a carriage return (hexadecimal 0x000d), a line feed (hexadecimal 0x000a), or the value of the Environment.NewLine property. La stringa restituita non contiene i caratteri di terminazione.The returned string does not contain the terminating character(s). Per impostazione predefinita, il metodo legge l'input da un buffer di input di 256 caratteri.By default, the method reads input from a 256-character input buffer. Poiché include i Environment.NewLine caratteri, il metodo è in grado di leggere righe contenenti un massimo di 254 caratteri.Because this includes the Environment.NewLine character(s), the method can read lines that contain up to 254 characters. Per leggere le righe più lunghe, OpenStandardInput(Int32) chiamare il metodo.To read longer lines, call the OpenStandardInput(Int32) method.

Il ReadLine metodo viene eseguito in modo sincrono.The ReadLine method executes synchronously. Ovvero si blocca fino a quando non viene letta una riga o si preme la combinazione di tasti CTRL + Z.That is, it blocks until a line is read or the Ctrl+Z keyboard combination is pressed. La In proprietà restituisce un TextReader oggetto che rappresenta il flusso di input standard e che include sia un TextReader.ReadLine metodo sincrono che TextReader.ReadLineAsync un metodo asincrono.The In property returns a TextReader object that represents the standard input stream and that has both a synchronous TextReader.ReadLine method and an asynchronous TextReader.ReadLineAsync method. Tuttavia, se usato come flusso di input standard della console, TextReader.ReadLineAsync viene eseguito in modo sincrono anziché asincrono e restituisce un Task<String> solo dopo il completamento dell'operazione di lettura.However, when used as the console's standard input stream, the TextReader.ReadLineAsync executes synchronously rather than asynchronously and returns a Task<String> only after the read operation has completed.

Se questo metodo genera un' OutOfMemoryException eccezione, la posizione del Reader nell'oggetto sottostante Stream viene avanzata in base al numero di caratteri che il metodo è stato in grado di leggere, ma i caratteri già letti ReadLine nel buffer interno sono scartato.If this method throws an OutOfMemoryException exception, the reader's position in the underlying Stream object is advanced by the number of characters the method was able to read, but the characters already read into the internal ReadLine buffer are discarded. Poiché non è possibile modificare la posizione del Reader nel flusso, i caratteri già letti sono irreversibili ed è possibile accedervi solo reinizializzando TextReader.Since the position of the reader in the stream cannot be changed, the characters already read are unrecoverable, and can be accessed only by reinitializing the TextReader. Se la posizione iniziale all'interno del flusso è sconosciuta o se il flusso non supporta la ricerca, Stream è necessario reinizializzare anche l'oggetto sottostante.If the initial position within the stream is unknown or the stream does not support seeking, the underlying Stream also needs to be reinitialized. Per evitare una situazione di questo tipo e produrre codice affidabile, è consigliabile utilizzare KeyAvailable la proprietà ReadKey e il metodo e archiviare i caratteri letti in un buffer preallocato.To avoid such a situation and to produce robust code, you should use the KeyAvailable property and ReadKey method and store the read characters in a pre-allocated buffer.

Se il carattere CTRL + Z viene premuto quando il metodo sta leggendo input dalla console, il metodo restituisce null.If the Ctrl+Z character is pressed when the method is reading input from the console, the method returns null. Ciò consente all'utente di impedire un ulteriore input da tastiera ReadLine quando il metodo viene chiamato in un ciclo.This enables the user to prevent further keyboard input when the ReadLine method is called in a loop. Nell'esempio seguente viene illustrato questo scenario.The following example illustrates this scenario.

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

Si applica a

Vedi anche