Console.Error Console.Error Console.Error Console.Error Property

정의

표준 오류 출력 스트림을 가져옵니다.Gets the standard error output stream.

public:
 static property System::IO::TextWriter ^ Error { System::IO::TextWriter ^ get(); };
public static System.IO.TextWriter Error { get; }
member this.Error : System.IO.TextWriter
Public Shared ReadOnly Property Error As TextWriter

속성 값

표준 오류 출력 스트림을 나타내는 TextWriter입니다.A TextWriter that represents the standard error output stream.

예제

다음 예제는 네 개의 공백을 의해 정의 된 값을 사용 하 여 텍스트 파일에서 탭 문자를 대체 하는 ExpandTabs 라는 명령줄 유틸리티는 tabSize 변수입니다.The following example is a command line utility named ExpandTabs that replaces tab characters in a text file with four spaces, the value defined by the tabSize variable. 리디렉션합니다 표준 입력 및 출력 파일, 스트림 하지만 사용 하 여는 Error 콘솔에 표준 오류 스트림에 쓸 속성입니다.It redirects the standard input and output streams to files, but uses the Error property to write the standard error stream to the console. 탭 문자를 포함 하는 파일의 이름 및 출력 파일의 이름을 제공 하 여 명령줄에서 시작할 수 있습니다.It can be launched from the command line by supplying the name of the file that contains tab characters and the name of the output file.

using namespace System;
using namespace System::IO;

void main()
{
   const int tabSize = 4;
   array<String^>^args = Environment::GetCommandLineArgs();
   String^ usageText = "Usage: EXPANDTABSEX inputfile.txt outputfile.txt";
   StreamWriter^ writer = nullptr;
   
   if ( args->Length < 3 )
   {
      Console::WriteLine( usageText );
      return;
   }

   try
   {
      writer = gcnew StreamWriter( args[ 2 ] );
      Console::SetOut( writer );
      Console::SetIn( gcnew StreamReader( args[ 1 ] ) );
   }
   catch ( IOException^ e ) 
   {
      TextWriter^ errorWriter = Console::Error;
      errorWriter->WriteLine( e->Message );
      errorWriter->WriteLine( usageText );
      return;
   }

   int i;
   while ( (i = Console::Read()) != -1 )
   {
      Char c = (Char)i;
      if ( c == '\t' )
            Console::Write( ((String^)"")->PadRight( tabSize, ' ' ) );
      else
            Console::Write( c );
   }

   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( "EXPANDTABSEX has completed the processing of {0}.", args[ 0 ] );
   return;
}
using System;
using System.IO;

public class ExpandTabs
{
    private const int tabSize = 4;
    private const string usageText = "Usage: EXPANDTABSEX inputfile.txt outputfile.txt";

    public static void Main(string[] args)
    {
        StreamWriter writer = null;

        if (args.Length < 2) {
            Console.WriteLine(usageText);
            return;
        }

        try {
            writer = new StreamWriter(args[1]);
            Console.SetOut(writer);
            Console.SetIn(new StreamReader(args[0]));
        }
        catch(IOException e) {
            TextWriter errorWriter = Console.Error;
            errorWriter.WriteLine(e.Message);
            errorWriter.WriteLine(usageText);
            return;
        }
        int i;
        while ((i = Console.Read()) != -1) {
            char c = (char)i;
            if (c == '\t')
                Console.Write(("").PadRight(tabSize, ' '));
            else
                Console.Write(c);
        }
        writer.Close();
        // Recover the standard output stream so that a 
        // completion message can be displayed.
        StreamWriter standardOutput = new StreamWriter(Console.OpenStandardOutput());
        standardOutput.AutoFlush = true;
        Console.SetOut(standardOutput);
        Console.WriteLine("EXPANDTABSEX has completed the processing of {0}.", args[0]);
        return;
    }
}
Imports System.IO

Public Class ExpandTabs
   Private Const tabSize As Integer = 4
   Private Const usageText As String = "Usage: EXPANDTABSEX inputfile.txt outputfile.txt"
   
   Public Shared Sub Main(args() As String)
      Dim writer As StreamWriter = Nothing

      If args.Length < 2 Then
         Console.WriteLine(usageText)
         Exit Sub
      End If
      
      Try
         writer = New StreamWriter(args(1))
         Console.SetOut(writer)
         Console.SetIn(New StreamReader(args(0)))
      Catch e As IOException
         Console.Error.WriteLine(e.Message)
         Console.Error.WriteLine(usageText)
         Exit Sub
      End Try
      
      Dim i As Integer = Console.Read()
      While i <> -1 
         Dim c As Char = Convert.ToChar(i)
         If c = ControlChars.Tab Then
            Console.Write("".PadRight(tabSize, " "c))
         Else
            Console.Write(c)
         End If
         i = Console.Read()
      End While
      writer.Close()
      
      ' Reacquire 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("EXPANDTABSEX has completed the processing of {0}.", args(0))
   End Sub
End Class

다음 예제에는 하나 이상의 텍스트 파일의 내용을 콘솔에 표시 하는 간단한 텍스트 파일 뷰어입니다.The following example is a simple text file viewer that displays the contents of one or more text files to the console. 명령줄 인수가 없습니다 또는 명령줄 인수로 전달 된 모든 파일이 존재 하지 않는 경우이 예제에서는 호출 하는 경우는 SetError 오류 정보를 파일로 리디렉션하는 메서드를 호출 합니다 OpenStandardError 표준 오류를 썼는지 중 메서드 스트림, 및 오류 정보를 파일에 작성 된 임을 나타냅니다.If there are no command line arguments, or if any files passed as command line arguments do not exist, the example calls the SetError method to redirect error information to a file, calls the OpenStandardError method in the process of reacquiring the standard error stream, and indicates that error information was written to a file.

using System;
using System.IO;

public class ViewTextFile
{
   public static void Main()
   {
      String[] args = Environment.GetCommandLineArgs();
      String errorOutput = "";
      // Make sure that there is at least one command line argument.
      if (args.Length <= 1)
         errorOutput += "You must include a filename on the command line.\n";

      for (int ctr = 1; ctr <= args.GetUpperBound(0); ctr++)  {
         // Check whether the file exists.
         if (! File.Exists(args[ctr])) {
            errorOutput += String.Format("'{0}' does not exist.\n", args[ctr]);
         }
         else {
            // Display the contents of the file.
            StreamReader sr = new StreamReader(args[ctr]);
            String contents = sr.ReadToEnd();
            sr.Close();
            Console.WriteLine("*****Contents of file '{0}':\n\n",
                              args[ctr]);
            Console.WriteLine(contents);
            Console.WriteLine("*****\n");
         }
      }

      // Check for error conditions.
      if (! String.IsNullOrEmpty(errorOutput)) {
         // Write error information to a file.
         Console.SetError(new StreamWriter(@".\ViewTextFile.Err.txt"));
         Console.Error.WriteLine(errorOutput);
         Console.Error.Close();
         // Reacquire the standard error stream.
         var standardError = new StreamWriter(Console.OpenStandardError());
         standardError.AutoFlush = true;
         Console.SetError(standardError);
         Console.Error.WriteLine("\nError information written to ViewTextFile.Err.txt");
      }
   }
}
// If the example is compiled and run with the following command line:
//     ViewTextFile file1.txt file2.txt
// and neither file1.txt nor file2.txt exist, it displays the
// following output:
//     Error information written to ViewTextFile.Err.txt
// and writes the following text to ViewTextFile.Err.txt:
//     'file1.txt' does not exist.
//     'file2.txt' does not exist.
Imports System.IO

Module ViewTextFile
   Public Sub Main()
      Dim args() As String = Environment.GetCommandLineArgs()
      Dim errorOutput As String = ""
      ' Make sure that there is at least one command line argument.
      If args.Length <= 1 Then
         errorOutput += "You must include a filename on the command line." +
                        vbCrLf
      End If
      
      For ctr As Integer = 1 To args.GetUpperBound(0)
         ' Check whether the file exists.
         If Not File.Exists(args(ctr)) Then
            errorOutput += String.Format("'{0}' does not exist.{1}",
                                         args(ctr), vbCrLf)
         Else
            ' Display the contents of the file.
            Dim sr As New StreamReader(args(ctr))
            Dim contents As String = sr.ReadToEnd()
            sr.Close()
            Console.WriteLine("***** Contents of file '{0}':{1}{1}",
                              args(ctr), vbCrLf)
            Console.WriteLine(contents)
            Console.WriteLine("*****{0}", vbCrLf)
         End If
      Next

      ' Check for error conditions.
      If Not String.IsNullOrEmpty(errorOutput) Then
         ' Write error information to a file.
         Console.SetError(New StreamWriter(".\ViewTextFile.Err.txt"))
         Console.Error.WriteLine(errorOutput)
         Console.Error.Close()
         ' Reacquire the standard error stream.
         Dim standardError As New StreamWriter(Console.OpenStandardError())
         standardError.AutoFlush = True
         Console.SetError(standardError)
         Console.Error.WriteLine("{0}Error information written to ViewTextFile.Err.txt",
                                 vbCrLf)
      End If
   End Sub
End Module
' If the example is compiled and run with the following command line:
'     ViewTextFile file1.txt file2.txt
' and neither file1.txt nor file2.txt exist, it displays the
' following output:
'     Error information written to ViewTextFile.Err.txt
' and writes the following text to ViewTextFile.Err.txt:
'     'file1.txt' does not exist.
'     'file2.txt' does not exist.

합니다 StreamWriter.AutoFlush 속성이 true 오류 스트림에 썼는지 하기 전에 합니다.Note that the StreamWriter.AutoFlush property is set to true before reacquiring the error stream. 이렇게 하면는 출력은 콘솔에 즉시 전송 되지 않고 버퍼링 합니다.This ensures that output will be sent to the console immediately rather than buffered.

설명

이 표준 오류 스트림에 기본적으로 콘솔에 설정 됩니다.This standard error stream is set to the console by default. 사용 하 여 다른 스트림에 설정할 수는 SetError 메서드.It can be set to another stream with the SetError method. 다시 호출 하 여 수 후 표준 오류 스트림에 리디렉션되는 OpenStandardError 메서드.After the standard error stream is redirected, it can be reacquired by calling the OpenStandardError method.

정보 제공 용 이므로 해당 출력을 파일로 리디렉션되 종종는 콘솔 애플리케이션 표준 오류 스트림의 통해 사용할 수는 Error 출력을 리디렉션할 경우에 콘솔에 정보를 표시 하려면 속성을 사용할 수 있습니다.In console applications whose informational output is often redirected to a file, the standard error stream available through the Error property can be used to display information to the console even if output is redirected. 다음 예제에서는 1부터 시작 하는 한 번에 10 개의 번호에 대 한 제품 테이블을 표시 합니다.The following example displays product tables for 10 numbers at a time starting with 1. 모든 집합 10 개의 숫자가 포함 한 후의 Error 속성을 다음 집합을 표시할지 여부를 사용자에 게 요청 하는 데 사용 됩니다.After every set of 10 numbers, the Error property is used to ask the user whether to display the next set. 표준 출력을 파일로 리디렉션되는 경우 사용자가 루틴 제품의 다음 집합을 생성할지 여부를 묻습니다.If the standard output is redirected to a file, the user is still asked whether the routine should generate the next set of products.

using System;

public class Example
{
   public static void Main()
   {
      int increment = 0;
      bool exitFlag = false;

      while (! exitFlag) {
         if (Console.IsOutputRedirected)
            Console.Error.WriteLine("Generating multiples of numbers from {0} to {1}",
                                    increment + 1, increment + 10);

         Console.WriteLine("Generating multiples of numbers from {0} to {1}",
                           increment + 1, increment + 10);
         for (int ctr = increment + 1; ctr <= increment + 10; ctr++) {
            Console.Write("Multiples of {0}: ", ctr);
            for (int ctr2 = 1; ctr2 <= 10; ctr2++)
               Console.Write("{0}{1}", ctr * ctr2, ctr2 == 10 ? "" : ", ");

            Console.WriteLine();
         }
         Console.WriteLine();

         increment += 10;
         Console.Error.Write("Display multiples of {0} through {1} (y/n)? ",
                             increment + 1, increment + 10);
         Char response = Console.ReadKey(true).KeyChar;
         Console.Error.WriteLine(response);
         if (! Console.IsOutputRedirected)
            Console.CursorTop--;

         if (Char.ToUpperInvariant(response) == 'N')
            exitFlag = true;
      }
   }
}
Module Example
   Public Sub Main()
      Dim increment As Integer = 0
      Dim exitFlag As Boolean = False
      
      Do While Not exitFlag
         If Console.IsOutputRedirected Then
            Console.Error.WriteLine("Generating multiples of numbers from {0} to {1}",
                                    increment + 1, increment + 10)
         End If
         Console.WriteLine("Generating multiples of numbers from {0} to {1}",
                           increment + 1, increment + 10)
         For ctr As Integer = increment + 1 To increment + 10
            Console.Write("Multiples of {0}: ", ctr)
            For ctr2 As Integer = 1 To 10
               Console.Write("{0}{1}", ctr * ctr2, If(ctr2 = 10, "", ", "))
            Next
            Console.WriteLine()
         Next
         Console.WriteLine()
         
         increment += 10
         Console.Error.Write("Display multiples of {0} through {1} (y/n)? ",
                             increment + 1, increment + 10)
         Dim response As Char = Console.ReadKey(True).KeyChar
         Console.Error.WriteLine(response)
         If Not Console.IsOutputRedirected Then
            Console.CursorTop = Console.CursorTop - 1
         End If
         If Char.ToUpperInvariant(response) = "N" Then exitFlag = True
      Loop
   End Sub
End Module

적용 대상

추가 정보