Permalink
Fetching contributors…
Cannot retrieve contributors at this time
2305 lines (1982 sloc) 99 KB
// ==++==
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
// ==--==
/*=============================================================================
**
** Class: Console
**
**
** Purpose: This class provides access to the standard input, standard output
** and standard error streams.
**
**
=============================================================================*/
namespace System {
using System;
using System.IO;
using System.Text;
using System.Globalization;
using System.Security;
using System.Security.Permissions;
using Microsoft.Win32;
using System.Runtime.CompilerServices;
using System.Threading;
using System.Runtime.InteropServices;
using Microsoft.Win32.SafeHandles;
using System.Runtime.ConstrainedExecution;
using System.Runtime.Versioning;
using System.Diagnostics.Contracts;
using System.Diagnostics.CodeAnalysis;
using System.Collections.Generic;
// Provides static fields for console input & output. Use
// Console.In for input from the standard input stream (stdin),
// Console.Out for output to stdout, and Console.Error
// for output to stderr. If any of those console streams are
// redirected from the command line, these streams will be redirected.
// A program can also redirect its own output or input with the
// SetIn, SetOut, and SetError methods.
//
// The distinction between Console.Out & Console.Error is useful
// for programs that redirect output to a file or a pipe. Note that
// stdout & stderr can be output to different files at the same
// time from the DOS command line:
//
// someProgram 1> out 2> err
//
//Contains only static data. Serializable attribute not required.
public static class Console
{
private const int DefaultConsoleBufferSize = 256;
private const short AltVKCode = 0x12;
#if !FEATURE_PAL
private const int NumberLockVKCode = 0x90; // virtual key code
private const int CapsLockVKCode = 0x14;
// Beep range - see MSDN.
private const int MinBeepFrequency = 37;
private const int MaxBeepFrequency = 32767;
// MSDN says console titles can be up to 64 KB in length.
// But I get an exception if I use buffer lengths longer than
// ~24500 Unicode characters. Oh well.
private const int MaxConsoleTitleLength = 24500;
#endif // !FEATURE_PAL
#if !FEATURE_CORECLR
private static readonly UnicodeEncoding StdConUnicodeEncoding = new UnicodeEncoding(false, false);
#endif // !FEATURE_CORECLR
private static volatile TextReader _in;
private static volatile TextWriter _out;
private static volatile TextWriter _error;
private static volatile ConsoleCancelEventHandler _cancelCallbacks;
private static volatile ControlCHooker _hooker;
#if !FEATURE_PAL
// ReadLine & Read can't use this because they need to use ReadFile
// to be able to handle redirected input. We have to accept that
// we will lose repeated keystrokes when someone switches from
// calling ReadKey to calling Read or ReadLine. Those methods should
// ideally flush this cache as well.
[System.Security.SecurityCritical] // auto-generated
private static Win32Native.InputRecord _cachedInputRecord;
// For ResetColor
private static volatile bool _haveReadDefaultColors;
private static volatile byte _defaultColors;
#endif // !FEATURE_PAL
#if FEATURE_CODEPAGES_FILE // if no codepages file then locked into default
private static volatile bool _isOutTextWriterRedirected = false;
private static volatile bool _isErrorTextWriterRedirected = false;
#endif
private static volatile Encoding _inputEncoding = null;
private static volatile Encoding _outputEncoding = null;
#if !FEATURE_CORECLR
private static volatile bool _stdInRedirectQueried = false;
private static volatile bool _stdOutRedirectQueried = false;
private static volatile bool _stdErrRedirectQueried = false;
private static bool _isStdInRedirected;
private static bool _isStdOutRedirected;
private static bool _isStdErrRedirected;
#endif // !FEATURE_CORECLR
// Private object for locking instead of locking on a public type for SQL reliability work.
// Use this for internal synchronization during initialization, wiring up events, or for short, non-blocking OS calls.
private static volatile Object s_InternalSyncObject;
private static Object InternalSyncObject {
get {
Contract.Ensures(Contract.Result<Object>() != null);
if (s_InternalSyncObject == null) {
Object o = new Object();
#pragma warning disable 0420
Interlocked.CompareExchange<Object>(ref s_InternalSyncObject, o, null);
#pragma warning restore 0420
}
return s_InternalSyncObject;
}
}
// Use this for blocking in Console.ReadKey, which needs to protect itself in case multiple threads call it simultaneously.
// Use a ReadKey-specific lock though, to allow other fields to be initialized on this type.
private static volatile Object s_ReadKeySyncObject;
private static Object ReadKeySyncObject
{
get
{
Contract.Ensures(Contract.Result<Object>() != null);
if (s_ReadKeySyncObject == null)
{
Object o = new Object();
#pragma warning disable 0420
Interlocked.CompareExchange<Object>(ref s_ReadKeySyncObject, o, null);
#pragma warning restore 0420
}
return s_ReadKeySyncObject;
}
}
// About reliability: I'm not using SafeHandle here. We don't
// need to close these handles, and we don't allow the user to close
// them so we don't have many of the security problems inherent in
// something like file handles. Additionally, in a host like SQL
// Server, we won't have a console.
private static volatile IntPtr _consoleInputHandle;
private static volatile IntPtr _consoleOutputHandle;
private static IntPtr ConsoleInputHandle {
[System.Security.SecurityCritical] // auto-generated
[ResourceExposure(ResourceScope.Process)]
[ResourceConsumption(ResourceScope.Process)]
get {
if (_consoleInputHandle == IntPtr.Zero) {
_consoleInputHandle = Win32Native.GetStdHandle(Win32Native.STD_INPUT_HANDLE);
}
return _consoleInputHandle;
}
}
private static IntPtr ConsoleOutputHandle {
[System.Security.SecurityCritical] // auto-generated
[ResourceExposure(ResourceScope.Process)]
[ResourceConsumption(ResourceScope.Process)]
get {
if (_consoleOutputHandle == IntPtr.Zero) {
_consoleOutputHandle = Win32Native.GetStdHandle(Win32Native.STD_OUTPUT_HANDLE);
}
return _consoleOutputHandle;
}
}
#if !FEATURE_CORECLR
[System.Security.SecuritySafeCritical]
[ResourceExposure(ResourceScope.Process)]
[ResourceConsumption(ResourceScope.Process)]
private static bool IsHandleRedirected(IntPtr ioHandle) {
// Need this to use GetFileType:
SafeFileHandle safeIOHandle = new SafeFileHandle(ioHandle, false);
// If handle is not to a character device, we must be redirected:
int fileType = Win32Native.GetFileType(safeIOHandle);
if ((fileType & Win32Native.FILE_TYPE_CHAR) != Win32Native.FILE_TYPE_CHAR)
return true;
// We are on a char device.
// If GetConsoleMode succeeds, we are NOT redirected.
int mode;
bool success = Win32Native.GetConsoleMode(ioHandle, out mode);
return !success;
}
public static bool IsInputRedirected {
[System.Security.SecuritySafeCritical]
get {
if (_stdInRedirectQueried)
return _isStdInRedirected;
lock (InternalSyncObject) {
if (_stdInRedirectQueried)
return _isStdInRedirected;
_isStdInRedirected = IsHandleRedirected(ConsoleInputHandle);
_stdInRedirectQueried = true;
return _isStdInRedirected;
}
}
} // public static bool IsInputRedirected
public static bool IsOutputRedirected {
[System.Security.SecuritySafeCritical]
get {
if (_stdOutRedirectQueried)
return _isStdOutRedirected;
lock (InternalSyncObject) {
if (_stdOutRedirectQueried)
return _isStdOutRedirected;
_isStdOutRedirected = IsHandleRedirected(ConsoleOutputHandle);
_stdOutRedirectQueried = true;
return _isStdOutRedirected;
}
}
} // public static bool IsOutputRedirected
public static bool IsErrorRedirected {
[System.Security.SecuritySafeCritical]
[ResourceExposure(ResourceScope.Process)]
[ResourceConsumption(ResourceScope.Process)]
get {
if (_stdErrRedirectQueried)
return _isStdErrRedirected;
lock (InternalSyncObject) {
if (_stdErrRedirectQueried)
return _isStdErrRedirected;
IntPtr errHndle = Win32Native.GetStdHandle(Win32Native.STD_ERROR_HANDLE);
_isStdErrRedirected = IsHandleRedirected(errHndle);
_stdErrRedirectQueried = true;
return _isStdErrRedirected;
}
}
} // public static bool IsErrorRedirected
#endif // !FEATURE_CORECLR
public static TextReader In {
[System.Security.SecuritySafeCritical] // auto-generated
[HostProtection(UI=true)]
[ResourceExposure(ResourceScope.None)]
[ResourceConsumption(ResourceScope.Process, ResourceScope.Process)]
get {
Contract.Ensures(Contract.Result<TextReader>() != null);
// Because most applications don't use stdin, we can delay
// initialize it slightly better startup performance.
if (_in == null) {
lock(InternalSyncObject) {
if (_in == null) {
// Set up Console.In
Stream s = OpenStandardInput(DefaultConsoleBufferSize);
TextReader tr;
if (s == Stream.Null)
tr = StreamReader.Null;
else {
// Hopefully Encoding.GetEncoding doesn't load as many classes now.
#if FEATURE_CORECLR
Encoding enc = Encoding.UTF8;
#else // FEATURE_CORECLR
Encoding enc = InputEncoding;
#endif // FEATURE_CORECLR
tr = TextReader.Synchronized(new StreamReader(s, enc, false, DefaultConsoleBufferSize, true));
}
System.Threading.Thread.MemoryBarrier();
_in = tr;
}
}
}
return _in;
}
}
public static TextWriter Out {
[HostProtection(UI=true)]
[ResourceExposure(ResourceScope.None)]
[ResourceConsumption(ResourceScope.Process, ResourceScope.Process)]
get {
Contract.Ensures(Contract.Result<TextWriter>() != null);
// Hopefully this is inlineable.
if (_out == null)
InitializeStdOutError(true);
return _out;
}
}
public static TextWriter Error {
[HostProtection(UI=true)]
get {
Contract.Ensures(Contract.Result<TextWriter>() != null);
// Hopefully this is inlineable.
if (_error == null)
InitializeStdOutError(false);
return _error;
}
}
// For console apps, the console handles are set to values like 3, 7,
// and 11 OR if you've been created via CreateProcess, possibly -1
// or 0. -1 is definitely invalid, while 0 is probably invalid.
// Also note each handle can independently be invalid or good.
// For Windows apps, the console handles are set to values like 3, 7,
// and 11 but are invalid handles - you may not write to them. However,
// you can still spawn a Windows app via CreateProcess and read stdout
// and stderr.
// So, we always need to check each handle independently for validity
// by trying to write or read to it, unless it is -1.
// We do not do a security check here, under the assumption that this
// cannot create a security hole, but only waste a user's time or
// cause a possible denial of service attack.
[System.Security.SecuritySafeCritical] // auto-generated
[ResourceExposure(ResourceScope.None)]
[ResourceConsumption(ResourceScope.Process, ResourceScope.Process)]
private static void InitializeStdOutError(bool stdout)
{
// Set up Console.Out or Console.Error.
lock(InternalSyncObject) {
if (stdout && _out != null)
return;
else if (!stdout && _error != null)
return;
TextWriter writer = null;
Stream s;
if (stdout)
s = OpenStandardOutput(DefaultConsoleBufferSize);
else
s = OpenStandardError(DefaultConsoleBufferSize);
if (s == Stream.Null) {
#if _DEBUG
if (CheckOutputDebug())
writer = MakeDebugOutputTextWriter((stdout) ? "Console.Out: " : "Console.Error: ");
else
#endif // _DEBUG
writer = TextWriter.Synchronized(StreamWriter.Null);
}
else {
#if FEATURE_CORECLR
Encoding encoding = Encoding.UTF8;
#else // FEATURE_CORECLR
Encoding encoding = OutputEncoding;
#endif // FEATURE_CORECLR
StreamWriter stdxxx = new StreamWriter(s, encoding, DefaultConsoleBufferSize, true);
stdxxx.HaveWrittenPreamble = true;
stdxxx.AutoFlush = true;
writer = TextWriter.Synchronized(stdxxx);
}
if (stdout)
_out = writer;
else
_error = writer;
Contract.Assert((stdout && _out != null) || (!stdout && _error != null), "Didn't set Console::_out or _error appropriately!");
}
}
// This is ONLY used in debug builds. If you have a registry key set,
// it will redirect Console.Out & Error on console-less applications to
// your debugger's output window.
#if _DEBUG
[System.Security.SecuritySafeCritical] // auto-generated
[ResourceExposure(ResourceScope.None)]
[ResourceConsumption(ResourceScope.Machine, ResourceScope.Machine)]
private static bool CheckOutputDebug()
{
#if FEATURE_WIN32_REGISTRY
new System.Security.Permissions.RegistryPermission(RegistryPermissionAccess.Read | RegistryPermissionAccess.Write, "HKEY_LOCAL_MACHINE").Assert();
RegistryKey rk = Registry.LocalMachine;
using (rk = rk.OpenSubKey("Software\\Microsoft\\.NETFramework", false)) {
if (rk != null) {
Object obj = rk.GetValue("ConsoleSpewToDebugger", 0);
if (obj != null && ((int)obj) != 0) {
return true;
}
}
}
return false;
#else // FEATURE_WIN32_REGISTRY
#if FEATURE_PAL && !FEATURE_CORECLR
const int parameterValueLength = 255;
StringBuilder parameterValue = new StringBuilder(parameterValueLength);
bool rc = Win32Native.FetchConfigurationString(true, "ConsoleSpewToDebugger", parameterValue, parameterValueLength);
if (rc) {
if (0 != parameterValue.Length) {
int value = Convert.ToInt32(parameterValue.ToString());
if (0 != value)
return true;
}
}
#endif // FEATURE_PAL && !FEATURE_CORECLR
return false;
#endif // FEATURE_WIN32_REGISTRY
}
#endif // _DEBUG
#if _DEBUG
private static TextWriter MakeDebugOutputTextWriter(String streamLabel)
{
TextWriter output = new __DebugOutputTextWriter(streamLabel);
output.WriteLine("Output redirected to debugger from a bit bucket.");
return TextWriter.Synchronized(output);
}
#endif // _DEBUG
#if !FEATURE_CORECLR
// We cannot simply compare the encoding to Encoding.Unicode bacasue it incorporates BOM
// and we do not care about BOM. Instead, we compare by class, codepage and little-endianess only:
private static bool IsStandardConsoleUnicodeEncoding(Encoding encoding) {
UnicodeEncoding enc = encoding as UnicodeEncoding;
if (null == enc)
return false;
return (StdConUnicodeEncoding.CodePage == enc.CodePage)
&& (StdConUnicodeEncoding.bigEndian == enc.bigEndian);
}
private static bool GetUseFileAPIs(int handleType) {
switch(handleType) {
case Win32Native.STD_INPUT_HANDLE:
return !IsStandardConsoleUnicodeEncoding(InputEncoding) || IsInputRedirected;
case Win32Native.STD_OUTPUT_HANDLE:
return !IsStandardConsoleUnicodeEncoding(OutputEncoding) || IsOutputRedirected;
case Win32Native.STD_ERROR_HANDLE:
return !IsStandardConsoleUnicodeEncoding(OutputEncoding) || IsErrorRedirected;
default:
// This can never happen.
Contract.Assert(false, "Unexpected handleType value (" + handleType + ")");
return true;
}
}
#endif // !FEATURE_CORECLR
// This method is only exposed via methods to get at the console.
// We won't use any security checks here.
#if FEATURE_CORECLR
[System.Security.SecurityCritical] // auto-generated
#else
[System.Security.SecuritySafeCritical]
#endif
[ResourceExposure(ResourceScope.Process)]
[ResourceConsumption(ResourceScope.Process)]
private static Stream GetStandardFile(int stdHandleName, FileAccess access, int bufferSize) {
// We shouldn't close the handle for stdout, etc, or we'll break
// unmanaged code in the process that will print to console.
// We should have a better way of marking this on SafeHandle.
IntPtr handle = Win32Native.GetStdHandle(stdHandleName);
SafeFileHandle sh = new SafeFileHandle(handle, false);
// If someone launches a managed process via CreateProcess, stdout
// stderr, & stdin could independently be set to INVALID_HANDLE_VALUE.
// Additionally they might use 0 as an invalid handle.
if (sh.IsInvalid) {
// Minor perf optimization - get it out of the finalizer queue.
sh.SetHandleAsInvalid();
return Stream.Null;
}
// Check whether we can read or write to this handle.
if (stdHandleName != Win32Native.STD_INPUT_HANDLE && !ConsoleHandleIsWritable(sh)) {
//BCLDebug.ConsoleError("Console::ConsoleHandleIsValid for std handle "+stdHandleName+" failed, setting it to a null stream");
return Stream.Null;
}
#if !FEATURE_CORECLR
bool useFileAPIs = GetUseFileAPIs(stdHandleName);
#else
const bool useFileAPIs = true;
#endif // !FEATURE_CORECLR
//BCLDebug.ConsoleError("Console::GetStandardFile for std handle "+stdHandleName+" succeeded, returning handle number "+handle.ToString());
Stream console = new __ConsoleStream(sh, access, useFileAPIs);
// Do not buffer console streams, or we can get into situations where
// we end up blocking waiting for you to hit enter twice. It was
// redundant.
return console;
}
// Checks whether stdout or stderr are writable. Do NOT pass
// stdin here.
#if FEATURE_CORECLR
[System.Security.SecurityCritical] // auto-generated
#else
[System.Security.SecuritySafeCritical]
#endif
[ResourceExposure(ResourceScope.Process)]
[ResourceConsumption(ResourceScope.Process)]
private static unsafe bool ConsoleHandleIsWritable(SafeFileHandle outErrHandle) {
// Do NOT call this method on stdin!
// Windows apps may have non-null valid looking handle values for
// stdin, stdout and stderr, but they may not be readable or
// writable. Verify this by calling WriteFile in the
// appropriate modes.
// This must handle console-less Windows apps.
int bytesWritten;
byte junkByte = 0x41;
int r = Win32Native.WriteFile(outErrHandle, &junkByte, 0, out bytesWritten, IntPtr.Zero);
// In Win32 apps w/ no console, bResult should be 0 for failure.
return r != 0;
}
public static Encoding InputEncoding {
[System.Security.SecuritySafeCritical] // auto-generated
get {
Contract.Ensures(Contract.Result<Encoding>() != null);
if (null != _inputEncoding)
return _inputEncoding;
lock(InternalSyncObject) {
if (null != _inputEncoding)
return _inputEncoding;
uint cp = Win32Native.GetConsoleCP();
_inputEncoding = Encoding.GetEncoding((int) cp);
return _inputEncoding;
}
}
#if FEATURE_CODEPAGES_FILE // if no codepages file then locked into default
[System.Security.SecuritySafeCritical] // auto-generated
[ResourceExposure(ResourceScope.Process)]
[ResourceConsumption(ResourceScope.Process)]
set {
if (value == null)
throw new ArgumentNullException("value");
Contract.EndContractBlock();
new UIPermission(UIPermissionWindow.SafeTopLevelWindows).Demand();
lock(InternalSyncObject) {
if (!IsStandardConsoleUnicodeEncoding(value)) {
uint cp = (uint) value.CodePage;
bool r = Win32Native.SetConsoleCP(cp);
if (!r)
__Error.WinIOError();
}
_inputEncoding = (Encoding) value.Clone();
// We need to reinitialize Console.In in the next call to _in
// This will discard the current StreamReader, potentially
// losing buffered data
_in = null;
}
} // set
#endif // FEATURE_CODEPAGES_FILE
} // public static Encoding InputEncoding
public static Encoding OutputEncoding {
[System.Security.SecuritySafeCritical] // auto-generated
get {
Contract.Ensures(Contract.Result<Encoding>() != null);
if (null != _outputEncoding)
return _outputEncoding;
lock(InternalSyncObject) {
if (null != _outputEncoding)
return _outputEncoding;
uint cp = Win32Native.GetConsoleOutputCP();
_outputEncoding = Encoding.GetEncoding((int) cp);
return _outputEncoding;
}
}
#if FEATURE_CODEPAGES_FILE // if no codepages file then locked into default
[System.Security.SecuritySafeCritical] // auto-generated
[ResourceExposure(ResourceScope.Process)]
[ResourceConsumption(ResourceScope.Process)]
set {
if (value == null)
throw new ArgumentNullException("value");
Contract.EndContractBlock();
new UIPermission(UIPermissionWindow.SafeTopLevelWindows).Demand();
lock(InternalSyncObject) {
// Before changing the code page we need to flush the data
// if Out hasn't been redirected. Also, have the next call to
// _out reinitialize the console code page.
if (_out != null && !_isOutTextWriterRedirected) {
_out.Flush();
_out = null;
}
if (_error != null && !_isErrorTextWriterRedirected) {
_error.Flush();
_error = null;
}
if (!IsStandardConsoleUnicodeEncoding(value)) {
uint cp = (uint) value.CodePage;
bool r = Win32Native.SetConsoleOutputCP(cp);
if (!r)
__Error.WinIOError();
}
_outputEncoding = (Encoding) value.Clone();
}
} // set
#endif // FEATURE_CODEPAGES_FILE
} // public static Encoding OutputEncoding
#if !FEATURE_PAL
[HostProtection(UI=true)]
public static void Beep()
{
Beep(800, 200);
}
[System.Security.SecuritySafeCritical] // auto-generated
[HostProtection(UI=true)]
public static void Beep(int frequency, int duration)
{
if (frequency < MinBeepFrequency || frequency > MaxBeepFrequency)
throw new ArgumentOutOfRangeException("frequency", frequency, Environment.GetResourceString("ArgumentOutOfRange_BeepFrequency", MinBeepFrequency, MaxBeepFrequency));
if (duration <= 0)
throw new ArgumentOutOfRangeException("duration", duration, Environment.GetResourceString("ArgumentOutOfRange_NeedPosNum"));
// Note that Beep over Remote Desktop connections does not currently
Contract.EndContractBlock();
// work. Ignore any failures here.
Win32Native.Beep(frequency, duration);
}
[System.Security.SecuritySafeCritical] // auto-generated
[ResourceExposure(ResourceScope.Process)]
[ResourceConsumption(ResourceScope.Process)]
public static void Clear()
{
Win32Native.COORD coordScreen = new Win32Native.COORD();
Win32Native.CONSOLE_SCREEN_BUFFER_INFO csbi;
bool success;
int conSize;
IntPtr hConsole = ConsoleOutputHandle;
if (hConsole == Win32Native.INVALID_HANDLE_VALUE)
throw new IOException(Environment.GetResourceString("IO.IO_NoConsole"));
// get the number of character cells in the current buffer
// Go through my helper method for fetching a screen buffer info
// to correctly handle default console colors.
csbi = GetBufferInfo();
conSize = csbi.dwSize.X * csbi.dwSize.Y;
// fill the entire screen with blanks
int numCellsWritten = 0;
success = Win32Native.FillConsoleOutputCharacter(hConsole, ' ',
conSize, coordScreen, out numCellsWritten);
if (!success)
__Error.WinIOError();
// now set the buffer's attributes accordingly
numCellsWritten = 0;
success = Win32Native.FillConsoleOutputAttribute(hConsole, csbi.wAttributes,
conSize, coordScreen, out numCellsWritten);
if (!success)
__Error.WinIOError();
// put the cursor at (0, 0)
success = Win32Native.SetConsoleCursorPosition(hConsole, coordScreen);
if (!success)
__Error.WinIOError();
}
[System.Security.SecurityCritical] // auto-generated
private static Win32Native.Color ConsoleColorToColorAttribute(ConsoleColor color, bool isBackground)
{
if ((((int)color) & ~0xf) != 0)
throw new ArgumentException(Environment.GetResourceString("Arg_InvalidConsoleColor"));
Contract.EndContractBlock();
Win32Native.Color c = (Win32Native.Color) color;
// Make these background colors instead of foreground
if (isBackground)
c = (Win32Native.Color) ((int)c << 4);
return c;
}
[System.Security.SecurityCritical] // auto-generated
private static ConsoleColor ColorAttributeToConsoleColor(Win32Native.Color c)
{
// Turn background colors into foreground colors.
if ((c & Win32Native.Color.BackgroundMask) != 0)
c = (Win32Native.Color) (((int)c) >> 4);
return (ConsoleColor) c;
}
public static ConsoleColor BackgroundColor {
[System.Security.SecuritySafeCritical] // auto-generated
[ResourceExposure(ResourceScope.None)]
[ResourceConsumption(ResourceScope.Process, ResourceScope.Process)]
get {
bool succeeded;
Win32Native.CONSOLE_SCREEN_BUFFER_INFO csbi = GetBufferInfo(false, out succeeded);
// For code that may be used from Windows app w/ no console
if (!succeeded)
return ConsoleColor.Black;
Win32Native.Color c = (Win32Native.Color) csbi.wAttributes & Win32Native.Color.BackgroundMask;
return ColorAttributeToConsoleColor(c);
}
[System.Security.SecuritySafeCritical] // auto-generated
[ResourceExposure(ResourceScope.Process)]
[ResourceConsumption(ResourceScope.Process)]
set {
new UIPermission(UIPermissionWindow.SafeTopLevelWindows).Demand();
Win32Native.Color c = ConsoleColorToColorAttribute(value, true);
bool succeeded;
Win32Native.CONSOLE_SCREEN_BUFFER_INFO csbi = GetBufferInfo(false, out succeeded);
// For code that may be used from Windows app w/ no console
if (!succeeded)
return;
Contract.Assert(_haveReadDefaultColors, "Setting the foreground color before we've read the default foreground color!");
short attrs = csbi.wAttributes;
attrs &= ~((short)Win32Native.Color.BackgroundMask);
// C#'s bitwise-or sign-extends to 32 bits.
attrs = (short) (((uint) (ushort) attrs) | ((uint) (ushort) c));
// Ignore errors here - there are some scenarios for running code that wants
// to print in colors to the console in a Windows application.
Win32Native.SetConsoleTextAttribute(ConsoleOutputHandle, attrs);
}
} // public static ConsoleColor BackgroundColor
public static ConsoleColor ForegroundColor {
[System.Security.SecuritySafeCritical] // auto-generated
[ResourceExposure(ResourceScope.None)]
[ResourceConsumption(ResourceScope.Process, ResourceScope.Process)]
get {
bool succeeded;
Win32Native.CONSOLE_SCREEN_BUFFER_INFO csbi = GetBufferInfo(false, out succeeded);
// For code that may be used from Windows app w/ no console
if (!succeeded)
return ConsoleColor.Gray;
Win32Native.Color c = (Win32Native.Color) csbi.wAttributes & Win32Native.Color.ForegroundMask;
return ColorAttributeToConsoleColor(c);
}
[System.Security.SecuritySafeCritical] // auto-generated
[ResourceExposure(ResourceScope.Process)]
[ResourceConsumption(ResourceScope.Process)]
set {
new UIPermission(UIPermissionWindow.SafeTopLevelWindows).Demand();
Win32Native.Color c = ConsoleColorToColorAttribute(value, false);
bool succeeded;
Win32Native.CONSOLE_SCREEN_BUFFER_INFO csbi = GetBufferInfo(false, out succeeded);
// For code that may be used from Windows app w/ no console
if (!succeeded)
return;
Contract.Assert(_haveReadDefaultColors, "Setting the foreground color before we've read the default foreground color!");
short attrs = csbi.wAttributes;
attrs &= ~((short)Win32Native.Color.ForegroundMask);
// C#'s bitwise-or sign-extends to 32 bits.
attrs = (short) (((uint) (ushort) attrs) | ((uint) (ushort) c));
// Ignore errors here - there are some scenarios for running code that wants
// to print in colors to the console in a Windows application.
Win32Native.SetConsoleTextAttribute(ConsoleOutputHandle, attrs);
}
} // public static ConsoleColor ForegroundColor
[System.Security.SecuritySafeCritical] // auto-generated
[ResourceExposure(ResourceScope.Process)]
[ResourceConsumption(ResourceScope.Process)]
public static void ResetColor()
{
new UIPermission(UIPermissionWindow.SafeTopLevelWindows).Demand();
bool succeeded;
Win32Native.CONSOLE_SCREEN_BUFFER_INFO csbi = GetBufferInfo(false, out succeeded);
// For code that may be used from Windows app w/ no console
if (!succeeded)
return;
Contract.Assert(_haveReadDefaultColors, "Setting the foreground color before we've read the default foreground color!");
short defaultAttrs = (short) (ushort) _defaultColors;
// Ignore errors here - there are some scenarios for running code that wants
// to print in colors to the console in a Windows application.
Win32Native.SetConsoleTextAttribute(ConsoleOutputHandle, defaultAttrs);
}
[ResourceExposure(ResourceScope.Process)]
[ResourceConsumption(ResourceScope.Process)]
public static void MoveBufferArea(int sourceLeft, int sourceTop,
int sourceWidth, int sourceHeight, int targetLeft, int targetTop)
{
MoveBufferArea(sourceLeft, sourceTop, sourceWidth, sourceHeight, targetLeft, targetTop, ' ', ConsoleColor.Black, BackgroundColor);
}
[System.Security.SecuritySafeCritical] // auto-generated
[ResourceExposure(ResourceScope.Process)]
[ResourceConsumption(ResourceScope.Process)]
public unsafe static void MoveBufferArea(int sourceLeft, int sourceTop,
int sourceWidth, int sourceHeight, int targetLeft, int targetTop,
char sourceChar, ConsoleColor sourceForeColor,
ConsoleColor sourceBackColor)
{
if (sourceForeColor < ConsoleColor.Black || sourceForeColor > ConsoleColor.White)
throw new ArgumentException(Environment.GetResourceString("Arg_InvalidConsoleColor"), "sourceForeColor");
if (sourceBackColor < ConsoleColor.Black || sourceBackColor > ConsoleColor.White)
throw new ArgumentException(Environment.GetResourceString("Arg_InvalidConsoleColor"), "sourceBackColor");
Contract.EndContractBlock();
Win32Native.CONSOLE_SCREEN_BUFFER_INFO csbi = GetBufferInfo();
Win32Native.COORD bufferSize = csbi.dwSize;
if (sourceLeft < 0 || sourceLeft > bufferSize.X)
throw new ArgumentOutOfRangeException("sourceLeft", sourceLeft, Environment.GetResourceString("ArgumentOutOfRange_ConsoleBufferBoundaries"));
if (sourceTop < 0 || sourceTop > bufferSize.Y)
throw new ArgumentOutOfRangeException("sourceTop", sourceTop, Environment.GetResourceString("ArgumentOutOfRange_ConsoleBufferBoundaries"));
if (sourceWidth < 0 || sourceWidth > bufferSize.X - sourceLeft)
throw new ArgumentOutOfRangeException("sourceWidth", sourceWidth, Environment.GetResourceString("ArgumentOutOfRange_ConsoleBufferBoundaries"));
if (sourceHeight < 0 || sourceTop > bufferSize.Y - sourceHeight)
throw new ArgumentOutOfRangeException("sourceHeight", sourceHeight, Environment.GetResourceString("ArgumentOutOfRange_ConsoleBufferBoundaries"));
// Note: if the target range is partially in and partially out
// of the buffer, then we let the OS clip it for us.
if (targetLeft < 0 || targetLeft > bufferSize.X)
throw new ArgumentOutOfRangeException("targetLeft", targetLeft, Environment.GetResourceString("ArgumentOutOfRange_ConsoleBufferBoundaries"));
if (targetTop < 0 || targetTop > bufferSize.Y)
throw new ArgumentOutOfRangeException("targetTop", targetTop, Environment.GetResourceString("ArgumentOutOfRange_ConsoleBufferBoundaries"));
// If we're not doing any work, bail out now (Windows will return
// an error otherwise)
if (sourceWidth == 0 || sourceHeight == 0)
return;
new UIPermission(UIPermissionWindow.SafeTopLevelWindows).Demand();
// Read data from the original location, blank it out, then write
// it to the new location. This will handle overlapping source and
// destination regions correctly.
// See the "Reading and Writing Blocks of Characters and Attributes"
// sample for help
// Read the old data
Win32Native.CHAR_INFO[] data = new Win32Native.CHAR_INFO[sourceWidth * sourceHeight];
bufferSize.X = (short) sourceWidth;
bufferSize.Y = (short) sourceHeight;
Win32Native.COORD bufferCoord = new Win32Native.COORD();
Win32Native.SMALL_RECT readRegion = new Win32Native.SMALL_RECT();
readRegion.Left = (short) sourceLeft;
readRegion.Right = (short) (sourceLeft + sourceWidth - 1);
readRegion.Top = (short) sourceTop;
readRegion.Bottom = (short) (sourceTop + sourceHeight - 1);
bool r;
fixed(Win32Native.CHAR_INFO* pCharInfo = data)
r = Win32Native.ReadConsoleOutput(ConsoleOutputHandle, pCharInfo, bufferSize, bufferCoord, ref readRegion);
if (!r)
__Error.WinIOError();
// Overwrite old section
// I don't have a good function to blank out a rectangle.
Win32Native.COORD writeCoord = new Win32Native.COORD();
writeCoord.X = (short) sourceLeft;
Win32Native.Color c = ConsoleColorToColorAttribute(sourceBackColor, true);
c |= ConsoleColorToColorAttribute(sourceForeColor, false);
short attr = (short) c;
int numWritten;
for(int i = sourceTop; i<sourceTop + sourceHeight; i++) {
writeCoord.Y = (short) i;
r = Win32Native.FillConsoleOutputCharacter(ConsoleOutputHandle, sourceChar, sourceWidth, writeCoord, out numWritten);
Contract.Assert(numWritten == sourceWidth, "FillConsoleOutputCharacter wrote the wrong number of chars!");
if (!r)
__Error.WinIOError();
r = Win32Native.FillConsoleOutputAttribute(ConsoleOutputHandle, attr, sourceWidth, writeCoord, out numWritten);
if (!r)
__Error.WinIOError();
}
// Write text to new location
Win32Native.SMALL_RECT writeRegion = new Win32Native.SMALL_RECT();
writeRegion.Left = (short) targetLeft;
writeRegion.Right = (short) (targetLeft + sourceWidth);
writeRegion.Top = (short) targetTop;
writeRegion.Bottom = (short) (targetTop + sourceHeight);
fixed(Win32Native.CHAR_INFO* pCharInfo = data)
r = Win32Native.WriteConsoleOutput(ConsoleOutputHandle, pCharInfo, bufferSize, bufferCoord, ref writeRegion);
} // MoveBufferArea
[System.Security.SecurityCritical] // auto-generated
[ResourceExposure(ResourceScope.Process)]
[ResourceConsumption(ResourceScope.Process)]
private static Win32Native.CONSOLE_SCREEN_BUFFER_INFO GetBufferInfo()
{
bool junk;
return GetBufferInfo(true, out junk);
}
// For apps that don't have a console (like Windows apps), they might
// run other code that includes color console output. Allow a mechanism
// where that code won't throw an exception for simple errors.
[System.Security.SecuritySafeCritical] // auto-generated
[ResourceExposure(ResourceScope.Process)]
[ResourceConsumption(ResourceScope.Process)]
private static Win32Native.CONSOLE_SCREEN_BUFFER_INFO GetBufferInfo(bool throwOnNoConsole, out bool succeeded)
{
succeeded = false;
Win32Native.CONSOLE_SCREEN_BUFFER_INFO csbi;
bool success;
IntPtr hConsole = ConsoleOutputHandle;
if (hConsole == Win32Native.INVALID_HANDLE_VALUE) {
if (!throwOnNoConsole)
return new Win32Native.CONSOLE_SCREEN_BUFFER_INFO();
else
throw new IOException(Environment.GetResourceString("IO.IO_NoConsole"));
}
// Note that if stdout is redirected to a file, the console handle
// may be a file. If this fails, try stderr and stdin.
success = Win32Native.GetConsoleScreenBufferInfo(hConsole, out csbi);
if (!success) {
success = Win32Native.GetConsoleScreenBufferInfo(Win32Native.GetStdHandle(Win32Native.STD_ERROR_HANDLE), out csbi);
if (!success)
success = Win32Native.GetConsoleScreenBufferInfo(Win32Native.GetStdHandle(Win32Native.STD_INPUT_HANDLE), out csbi);
if (!success) {
int errorCode = Marshal.GetLastWin32Error();
if (errorCode == Win32Native.ERROR_INVALID_HANDLE && !throwOnNoConsole)
return new Win32Native.CONSOLE_SCREEN_BUFFER_INFO();
__Error.WinIOError(errorCode, null);
}
}
if (!_haveReadDefaultColors) {
// Fetch the default foreground and background color for the
// ResetColor method.
Contract.Assert((int)Win32Native.Color.ColorMask == 0xff, "Make sure one byte is large enough to store a Console color value!");
_defaultColors = (byte) (csbi.wAttributes & (short) Win32Native.Color.ColorMask);
_haveReadDefaultColors = true;
}
succeeded = true;
return csbi;
}
public static int BufferHeight {
[System.Security.SecuritySafeCritical] // auto-generated
[ResourceExposure(ResourceScope.Process)]
[ResourceConsumption(ResourceScope.Process)]
get {
Win32Native.CONSOLE_SCREEN_BUFFER_INFO csbi = GetBufferInfo();
return csbi.dwSize.Y;
}
[ResourceExposure(ResourceScope.Process)]
[ResourceConsumption(ResourceScope.Process)]
set {
SetBufferSize(BufferWidth, value);
}
}
public static int BufferWidth {
[System.Security.SecuritySafeCritical] // auto-generated
[ResourceExposure(ResourceScope.Process)]
[ResourceConsumption(ResourceScope.Process)]
get {
Win32Native.CONSOLE_SCREEN_BUFFER_INFO csbi = GetBufferInfo();
return csbi.dwSize.X;
}
[ResourceExposure(ResourceScope.Process)]
[ResourceConsumption(ResourceScope.Process)]
set {
SetBufferSize(value, BufferHeight);
}
}
[System.Security.SecuritySafeCritical] // auto-generated
[ResourceExposure(ResourceScope.Process)]
[ResourceConsumption(ResourceScope.Process)]
public static void SetBufferSize(int width, int height)
{
new UIPermission(UIPermissionWindow.SafeTopLevelWindows).Demand();
// Ensure the new size is not smaller than the console window
Win32Native.CONSOLE_SCREEN_BUFFER_INFO csbi = GetBufferInfo();
Win32Native.SMALL_RECT srWindow = csbi.srWindow;
if (width < srWindow.Right + 1 || width >= Int16.MaxValue)
throw new ArgumentOutOfRangeException("width", width, Environment.GetResourceString("ArgumentOutOfRange_ConsoleBufferLessThanWindowSize"));
if (height < srWindow.Bottom + 1 || height >= Int16.MaxValue)
throw new ArgumentOutOfRangeException("height", height, Environment.GetResourceString("ArgumentOutOfRange_ConsoleBufferLessThanWindowSize"));
Win32Native.COORD size = new Win32Native.COORD();
size.X = (short) width;
size.Y = (short) height;
bool r = Win32Native.SetConsoleScreenBufferSize(ConsoleOutputHandle, size);
if (!r)
__Error.WinIOError();
}
public static int WindowHeight {
[System.Security.SecuritySafeCritical] // auto-generated
[ResourceExposure(ResourceScope.None)]
[ResourceConsumption(ResourceScope.Process, ResourceScope.Process)]
get {
Win32Native.CONSOLE_SCREEN_BUFFER_INFO csbi = GetBufferInfo();
return csbi.srWindow.Bottom - csbi.srWindow.Top + 1;
}
[ResourceExposure(ResourceScope.Process)]
[ResourceConsumption(ResourceScope.Process)]
set {
SetWindowSize(WindowWidth, value);
}
}
public static int WindowWidth {
[System.Security.SecuritySafeCritical] // auto-generated
[ResourceExposure(ResourceScope.None)]
[ResourceConsumption(ResourceScope.Process, ResourceScope.Process)]
get {
Win32Native.CONSOLE_SCREEN_BUFFER_INFO csbi = GetBufferInfo();
return csbi.srWindow.Right - csbi.srWindow.Left + 1;
}
[ResourceExposure(ResourceScope.Process)]
[ResourceConsumption(ResourceScope.Process)]
set {
SetWindowSize(value, WindowHeight);
}
}
[System.Security.SecuritySafeCritical] // auto-generated
[ResourceExposure(ResourceScope.Process)]
[ResourceConsumption(ResourceScope.Process)]
public static unsafe void SetWindowSize(int width, int height)
{
if (width <= 0)
throw new ArgumentOutOfRangeException("width", width, Environment.GetResourceString("ArgumentOutOfRange_NeedPosNum"));
if (height <= 0)
throw new ArgumentOutOfRangeException("height", height, Environment.GetResourceString("ArgumentOutOfRange_NeedPosNum"));
Contract.EndContractBlock();
new UIPermission(UIPermissionWindow.SafeTopLevelWindows).Demand();
// Get the position of the current console window
Win32Native.CONSOLE_SCREEN_BUFFER_INFO csbi = GetBufferInfo();
bool r;
// If the buffer is smaller than this new window size, resize the
// buffer to be large enough. Include window position.
bool resizeBuffer = false;
Win32Native.COORD size = new Win32Native.COORD();
size.X = csbi.dwSize.X;
size.Y = csbi.dwSize.Y;
if (csbi.dwSize.X < csbi.srWindow.Left + width) {
if (csbi.srWindow.Left >= Int16.MaxValue - width)
throw new ArgumentOutOfRangeException("width", Environment.GetResourceString("ArgumentOutOfRange_ConsoleWindowBufferSize"));
size.X = (short) (csbi.srWindow.Left + width);
resizeBuffer = true;
}
if (csbi.dwSize.Y < csbi.srWindow.Top + height) {
if (csbi.srWindow.Top >= Int16.MaxValue - height)
throw new ArgumentOutOfRangeException("height", Environment.GetResourceString("ArgumentOutOfRange_ConsoleWindowBufferSize"));
size.Y = (short) (csbi.srWindow.Top + height);
resizeBuffer = true;
}
if (resizeBuffer) {
r = Win32Native.SetConsoleScreenBufferSize(ConsoleOutputHandle, size);
if (!r)
__Error.WinIOError();
}
Win32Native.SMALL_RECT srWindow = csbi.srWindow;
// Preserve the position, but change the size.
srWindow.Bottom = (short) (srWindow.Top + height - 1);
srWindow.Right = (short) (srWindow.Left + width - 1);
r = Win32Native.SetConsoleWindowInfo(ConsoleOutputHandle, true, &srWindow);
if (!r) {
int errorCode = Marshal.GetLastWin32Error();
// If we resized the buffer, un-resize it.
if (resizeBuffer) {
Win32Native.SetConsoleScreenBufferSize(ConsoleOutputHandle, csbi.dwSize);
}
// Try to give a better error message here
Win32Native.COORD bounds = Win32Native.GetLargestConsoleWindowSize(ConsoleOutputHandle);
if (width > bounds.X)
throw new ArgumentOutOfRangeException("width", width, Environment.GetResourceString("ArgumentOutOfRange_ConsoleWindowSize_Size", bounds.X));
if (height > bounds.Y)
throw new ArgumentOutOfRangeException("height", height, Environment.GetResourceString("ArgumentOutOfRange_ConsoleWindowSize_Size", bounds.Y));
__Error.WinIOError(errorCode, String.Empty);
}
} // public static unsafe void SetWindowSize(int width, int height)
public static int LargestWindowWidth {
[System.Security.SecuritySafeCritical] // auto-generated
[ResourceExposure(ResourceScope.None)]
[ResourceConsumption(ResourceScope.Process, ResourceScope.Process)]
get {
// Note this varies based on current screen resolution and
// current console font. Do not cache this value.
Win32Native.COORD bounds = Win32Native.GetLargestConsoleWindowSize(ConsoleOutputHandle);
return bounds.X;
}
}
public static int LargestWindowHeight {
[System.Security.SecuritySafeCritical] // auto-generated
[ResourceExposure(ResourceScope.None)]
[ResourceConsumption(ResourceScope.Process, ResourceScope.Process)]
get {
// Note this varies based on current screen resolution and
// current console font. Do not cache this value.
Win32Native.COORD bounds = Win32Native.GetLargestConsoleWindowSize(ConsoleOutputHandle);
return bounds.Y;
}
}
public static int WindowLeft {
[System.Security.SecuritySafeCritical] // auto-generated
[ResourceExposure(ResourceScope.None)]
[ResourceConsumption(ResourceScope.Process, ResourceScope.Process)]
get {
Win32Native.CONSOLE_SCREEN_BUFFER_INFO csbi = GetBufferInfo();
return csbi.srWindow.Left;
}
[ResourceExposure(ResourceScope.Process)]
[ResourceConsumption(ResourceScope.Process)]
set {
SetWindowPosition(value, WindowTop);
}
}
public static int WindowTop {
[System.Security.SecuritySafeCritical] // auto-generated
[ResourceExposure(ResourceScope.None)]
[ResourceConsumption(ResourceScope.Process, ResourceScope.Process)]
get {
Win32Native.CONSOLE_SCREEN_BUFFER_INFO csbi = GetBufferInfo();
return csbi.srWindow.Top;
}
[ResourceExposure(ResourceScope.Process)]
[ResourceConsumption(ResourceScope.Process)]
set {
SetWindowPosition(WindowLeft, value);
}
}
[System.Security.SecuritySafeCritical] // auto-generated
[ResourceExposure(ResourceScope.Process)]
[ResourceConsumption(ResourceScope.Process)]
public static unsafe void SetWindowPosition(int left, int top)
{
new UIPermission(UIPermissionWindow.SafeTopLevelWindows).Demand();
// Get the size of the current console window
Win32Native.CONSOLE_SCREEN_BUFFER_INFO csbi = GetBufferInfo();
Win32Native.SMALL_RECT srWindow = csbi.srWindow;
// Check for arithmetic underflows & overflows.
int newRight = left + srWindow.Right - srWindow.Left + 1;
if (left < 0 || newRight > csbi.dwSize.X || newRight < 0)
throw new ArgumentOutOfRangeException("left", left, Environment.GetResourceString("ArgumentOutOfRange_ConsoleWindowPos"));
int newBottom = top + srWindow.Bottom - srWindow.Top + 1;
if (top < 0 || newBottom > csbi.dwSize.Y || newBottom < 0)
throw new ArgumentOutOfRangeException("top", top, Environment.GetResourceString("ArgumentOutOfRange_ConsoleWindowPos"));
// Preserve the size, but move the position.
srWindow.Bottom -= (short) (srWindow.Top - top);
srWindow.Right -= (short) (srWindow.Left - left);
srWindow.Left = (short) left;
srWindow.Top = (short) top;
bool r = Win32Native.SetConsoleWindowInfo(ConsoleOutputHandle, true, &srWindow);
if (!r)
__Error.WinIOError();
}
public static int CursorLeft {
[System.Security.SecuritySafeCritical] // auto-generated
[ResourceExposure(ResourceScope.None)]
[ResourceConsumption(ResourceScope.Process, ResourceScope.Process)]
get {
Win32Native.CONSOLE_SCREEN_BUFFER_INFO csbi = GetBufferInfo();
return csbi.dwCursorPosition.X;
}
[ResourceExposure(ResourceScope.Process)]
[ResourceConsumption(ResourceScope.Process)]
set {
SetCursorPosition(value, CursorTop);
}
}
public static int CursorTop {
[System.Security.SecuritySafeCritical] // auto-generated
[ResourceExposure(ResourceScope.None)]
[ResourceConsumption(ResourceScope.Process, ResourceScope.Process)]
get {
Win32Native.CONSOLE_SCREEN_BUFFER_INFO csbi = GetBufferInfo();
return csbi.dwCursorPosition.Y;
}
[ResourceExposure(ResourceScope.Process)]
[ResourceConsumption(ResourceScope.Process)]
set {
SetCursorPosition(CursorLeft, value);
}
}
[System.Security.SecuritySafeCritical] // auto-generated
[ResourceExposure(ResourceScope.Process)]
[ResourceConsumption(ResourceScope.Process)]
public static void SetCursorPosition(int left, int top)
{
// Note on argument checking - the upper bounds are NOT correct
// here! But it looks slightly expensive to compute them. Let
// Windows calculate them, then we'll give a nice error message.
if (left < 0 || left >= Int16.MaxValue)
throw new ArgumentOutOfRangeException("left", left, Environment.GetResourceString("ArgumentOutOfRange_ConsoleBufferBoundaries"));
if (top < 0 || top >= Int16.MaxValue)
throw new ArgumentOutOfRangeException("top", top, Environment.GetResourceString("ArgumentOutOfRange_ConsoleBufferBoundaries"));
Contract.EndContractBlock();
new UIPermission(UIPermissionWindow.SafeTopLevelWindows).Demand();
IntPtr hConsole = ConsoleOutputHandle;
Win32Native.COORD coords = new Win32Native.COORD();
coords.X = (short) left;
coords.Y = (short) top;
bool r = Win32Native.SetConsoleCursorPosition(hConsole, coords);
if (!r) {
// Give a nice error message for out of range sizes
int errorCode = Marshal.GetLastWin32Error();
Win32Native.CONSOLE_SCREEN_BUFFER_INFO csbi = GetBufferInfo();
if (left < 0 || left >= csbi.dwSize.X)
throw new ArgumentOutOfRangeException("left", left, Environment.GetResourceString("ArgumentOutOfRange_ConsoleBufferBoundaries"));
if (top < 0 || top >= csbi.dwSize.Y)
throw new ArgumentOutOfRangeException("top", top, Environment.GetResourceString("ArgumentOutOfRange_ConsoleBufferBoundaries"));
__Error.WinIOError(errorCode, String.Empty);
}
}
public static int CursorSize {
[System.Security.SecuritySafeCritical] // auto-generated
[ResourceExposure(ResourceScope.None)]
[ResourceConsumption(ResourceScope.Process, ResourceScope.Process)]
get {
Win32Native.CONSOLE_CURSOR_INFO cci;
IntPtr hConsole = ConsoleOutputHandle;
bool r = Win32Native.GetConsoleCursorInfo(hConsole, out cci);
if (!r)
__Error.WinIOError();
return cci.dwSize;
}
[System.Security.SecuritySafeCritical] // auto-generated
[ResourceExposure(ResourceScope.Process)]
[ResourceConsumption(ResourceScope.Process)]
set {
// Value should be a percentage from [1, 100].
if (value < 1 || value > 100)
throw new ArgumentOutOfRangeException("value", value, Environment.GetResourceString("ArgumentOutOfRange_CursorSize"));
Contract.EndContractBlock();
new UIPermission(UIPermissionWindow.SafeTopLevelWindows).Demand();
Win32Native.CONSOLE_CURSOR_INFO cci;
IntPtr hConsole = ConsoleOutputHandle;
bool r = Win32Native.GetConsoleCursorInfo(hConsole, out cci);
if (!r)
__Error.WinIOError();
cci.dwSize = value;
r = Win32Native.SetConsoleCursorInfo(hConsole, ref cci);
if (!r)
__Error.WinIOError();
}
}
public static bool CursorVisible {
[System.Security.SecuritySafeCritical] // auto-generated
[ResourceExposure(ResourceScope.None)]
[ResourceConsumption(ResourceScope.Process, ResourceScope.Process)]
get {
Win32Native.CONSOLE_CURSOR_INFO cci;
IntPtr hConsole = ConsoleOutputHandle;
bool r = Win32Native.GetConsoleCursorInfo(hConsole, out cci);
if (!r)
__Error.WinIOError();
return cci.bVisible;
}
[System.Security.SecuritySafeCritical] // auto-generated
[ResourceExposure(ResourceScope.Process)]
[ResourceConsumption(ResourceScope.Process)]
set {
new UIPermission(UIPermissionWindow.SafeTopLevelWindows).Demand();
Win32Native.CONSOLE_CURSOR_INFO cci;
IntPtr hConsole = ConsoleOutputHandle;
bool r = Win32Native.GetConsoleCursorInfo(hConsole, out cci);
if (!r)
__Error.WinIOError();
cci.bVisible = value;
r = Win32Native.SetConsoleCursorInfo(hConsole, ref cci);
if (!r)
__Error.WinIOError();
}
}
#if !FEATURE_CORECLR
[System.Security.SecurityCritical]
[DllImport(JitHelpers.QCall, CharSet = CharSet.Ansi)]
[ResourceExposure(ResourceScope.None)]
[SuppressUnmanagedCodeSecurity]
private static extern Int32 GetTitleNative(StringHandleOnStack outTitle, out Int32 outTitleLength);
public static String Title {
[System.Security.SecuritySafeCritical] // auto-generated
[ResourceExposure(ResourceScope.None)]
[ResourceConsumption(ResourceScope.Process, ResourceScope.Process)]
get {
string title = null;
int titleLength = -1;
Int32 r = GetTitleNative(JitHelpers.GetStringHandleOnStack(ref title), out titleLength);
if (0 != r) {
__Error.WinIOError(r, String.Empty);
}
if (titleLength > MaxConsoleTitleLength)
throw new InvalidOperationException(Environment.GetResourceString("ArgumentOutOfRange_ConsoleTitleTooLong"));
Contract.Assert(title.Length == titleLength);
return title;
}
[System.Security.SecuritySafeCritical] // auto-generated
[ResourceExposure(ResourceScope.None)]
[ResourceConsumption(ResourceScope.Process, ResourceScope.Process)]
set {
if (value == null)
throw new ArgumentNullException("value");
if (value.Length > MaxConsoleTitleLength)
throw new ArgumentOutOfRangeException("value", Environment.GetResourceString("ArgumentOutOfRange_ConsoleTitleTooLong"));
Contract.EndContractBlock();
new UIPermission(UIPermissionWindow.SafeTopLevelWindows).Demand();
if (!Win32Native.SetConsoleTitle(value))
__Error.WinIOError();
}
}
#endif // !FEATURE_CORECLR
[Flags]
internal enum ControlKeyState
{
RightAltPressed = 0x0001,
LeftAltPressed = 0x0002,
RightCtrlPressed = 0x0004,
LeftCtrlPressed = 0x0008,
ShiftPressed = 0x0010,
NumLockOn = 0x0020,
ScrollLockOn = 0x0040,
CapsLockOn = 0x0080,
EnhancedKey = 0x0100
}
[HostProtection(UI=true)]
[ResourceExposure(ResourceScope.Process)]
[ResourceConsumption(ResourceScope.Process)]
public static ConsoleKeyInfo ReadKey()
{
return ReadKey(false);
}
// For tracking Alt+NumPad unicode key sequence. When you press Alt key down
// and press a numpad unicode decimal sequence and then release Alt key, the
// desired effect is to translate the sequence into one Unicode KeyPress.
// We need to keep track of the Alt+NumPad sequence and surface the final
// unicode char alone when the Alt key is released.
[System.Security.SecurityCritical] // auto-generated
private static bool IsAltKeyDown(Win32Native.InputRecord ir) {
return (((ControlKeyState) ir.keyEvent.controlKeyState)
& (ControlKeyState.LeftAltPressed | ControlKeyState.RightAltPressed)) != 0;
}
// Skip non key events. Generally we want to surface only KeyDown event
// and suppress KeyUp event from the same Key press but there are cases
// where the assumption of KeyDown-KeyUp pairing for a given key press
// is invalid. For example in IME Unicode keyboard input, we often see
// only KeyUp until the key is released.
[System.Security.SecurityCritical] // auto-generated
private static bool IsKeyDownEvent(Win32Native.InputRecord ir) {
return (ir.eventType == Win32Native.KEY_EVENT && ir.keyEvent.keyDown);
}
[System.Security.SecurityCritical] // auto-generated
private static bool IsModKey(Win32Native.InputRecord ir) {
// We should also skip over Shift, Control, and Alt, as well as caps lock.
// Apparently we don't need to check for 0xA0 through 0xA5, which are keys like
// Left Control & Right Control. See the ConsoleKey enum for these values.
short keyCode = ir.keyEvent.virtualKeyCode;
return ((keyCode >= 0x10 && keyCode <= 0x12)
|| keyCode == 0x14 || keyCode == 0x90 || keyCode == 0x91);
}
[System.Security.SecuritySafeCritical] // auto-generated
[HostProtection(UI=true)]
[ResourceExposure(ResourceScope.Process)]
[ResourceConsumption(ResourceScope.Process)]
public static ConsoleKeyInfo ReadKey(bool intercept)
{
Win32Native.InputRecord ir;
int numEventsRead = -1;
bool r;
lock (ReadKeySyncObject) {
if (_cachedInputRecord.eventType == Win32Native.KEY_EVENT) {
// We had a previous keystroke with repeated characters.
ir = _cachedInputRecord;
if (_cachedInputRecord.keyEvent.repeatCount == 0)
_cachedInputRecord.eventType = -1;
else {
_cachedInputRecord.keyEvent.repeatCount--;
}
// We will return one key from this method, so we decrement the
// repeatCount here, leaving the cachedInputRecord in the "queue".
} else { // We did NOT have a previous keystroke with repeated characters:
while (true) {
r = Win32Native.ReadConsoleInput(ConsoleInputHandle, out ir, 1, out numEventsRead);
if (!r || numEventsRead == 0) {
// This will fail when stdin is redirected from a file or pipe.
// We could theoretically call Console.Read here, but I
// think we might do some things incorrectly then.
throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_ConsoleReadKeyOnFile"));
}
short keyCode = ir.keyEvent.virtualKeyCode;
// First check for non-keyboard events & discard them. Generally we tap into only KeyDown events and ignore the KeyUp events
// but it is possible that we are dealing with a Alt+NumPad unicode key sequence, the final unicode char is revealed only when
// the Alt key is released (i.e when the sequence is complete). To avoid noise, when the Alt key is down, we should eat up
// any intermediate key strokes (from NumPad) that collectively forms the Unicode character.
if (!IsKeyDownEvent(ir)) {
//
if (keyCode != AltVKCode)
continue;
}
char ch = (char) ir.keyEvent.uChar;
// In a Alt+NumPad unicode sequence, when the alt key is released uChar will represent the final unicode character, we need to
// surface this. VirtualKeyCode for this event will be Alt from the Alt-Up key event. This is probably not the right code,
// especially when we don't expose ConsoleKey.Alt, so this will end up being the hex value (0x12). VK_PACKET comes very
// close to being useful and something that we could look into using for this purpose...
if (ch == 0) {
// Skip mod keys.
if (IsModKey(ir))
continue;
}
// When Alt is down, it is possible that we are in the middle of a Alt+NumPad unicode sequence.
// Escape any intermediate NumPad keys whether NumLock is on or not (notepad behavior)
ConsoleKey key = (ConsoleKey) keyCode;
if (IsAltKeyDown(ir) && ((key >= ConsoleKey.NumPad0 && key <= ConsoleKey.NumPad9)
|| (key == ConsoleKey.Clear) || (key == ConsoleKey.Insert)
|| (key >= ConsoleKey.PageUp && key <= ConsoleKey.DownArrow))) {
continue;
}
if (ir.keyEvent.repeatCount > 1) {
ir.keyEvent.repeatCount--;
_cachedInputRecord = ir;
}
break;
}
} // we did NOT have a previous keystroke with repeated characters.
} // lock(ReadKeySyncObject)
ControlKeyState state = (ControlKeyState) ir.keyEvent.controlKeyState;
bool shift = (state & ControlKeyState.ShiftPressed) != 0;
bool alt = (state & (ControlKeyState.LeftAltPressed | ControlKeyState.RightAltPressed)) != 0;
bool control = (state & (ControlKeyState.LeftCtrlPressed | ControlKeyState.RightCtrlPressed)) != 0;
ConsoleKeyInfo info = new ConsoleKeyInfo((char)ir.keyEvent.uChar, (ConsoleKey) ir.keyEvent.virtualKeyCode, shift, alt, control);
if (!intercept)
Console.Write(ir.keyEvent.uChar);
return info;
} // public static ConsoleKeyInfo ReadKey(bool intercept)
public static bool KeyAvailable {
[System.Security.SecuritySafeCritical] // auto-generated
[ResourceExposure(ResourceScope.Process)]
[ResourceConsumption(ResourceScope.Process)]
[HostProtection(UI=true)]
get {
if (_cachedInputRecord.eventType == Win32Native.KEY_EVENT)
return true;
Win32Native.InputRecord ir = new Win32Native.InputRecord();
int numEventsRead = 0;
while (true) {
bool r = Win32Native.PeekConsoleInput(ConsoleInputHandle, out ir, 1, out numEventsRead);
if (!r) {
int errorCode = Marshal.GetLastWin32Error();
if (errorCode == Win32Native.ERROR_INVALID_HANDLE)
throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_ConsoleKeyAvailableOnFile"));
__Error.WinIOError(errorCode, "stdin");
}
if (numEventsRead == 0)
return false;
// Skip non key-down && mod key events.
if (!IsKeyDownEvent(ir) || IsModKey(ir)) {
//
// Exempt Alt keyUp for possible Alt+NumPad unicode sequence.
//short keyCode = ir.keyEvent.virtualKeyCode;
//if (!IsKeyDownEvent(ir) && (keyCode == AltVKCode))
// return true;
r = Win32Native.ReadConsoleInput(ConsoleInputHandle, out ir, 1, out numEventsRead);
if (!r)
__Error.WinIOError();
}
else {
return true;
}
}
} // get
} // public static bool KeyAvailable
public static bool NumberLock {
[System.Security.SecuritySafeCritical] // auto-generated
[ResourceExposure(ResourceScope.Process)]
[ResourceConsumption(ResourceScope.Process)]
get {
short s = Win32Native.GetKeyState(NumberLockVKCode);
return (s & 1) == 1;
}
}
public static bool CapsLock {
[System.Security.SecuritySafeCritical] // auto-generated
[ResourceExposure(ResourceScope.Process)]
[ResourceConsumption(ResourceScope.Process)]
get {
short s = Win32Native.GetKeyState(CapsLockVKCode);
return (s & 1) == 1;
}
}
public static bool TreatControlCAsInput {
[System.Security.SecuritySafeCritical] // auto-generated
[ResourceExposure(ResourceScope.None)]
[ResourceConsumption(ResourceScope.Process, ResourceScope.Process)]
get {
IntPtr handle = ConsoleInputHandle;
if (handle == Win32Native.INVALID_HANDLE_VALUE)
throw new IOException(Environment.GetResourceString("IO.IO_NoConsole"));
int mode = 0;
bool r = Win32Native.GetConsoleMode(handle, out mode);
if (!r)
__Error.WinIOError();
return (mode & Win32Native.ENABLE_PROCESSED_INPUT) == 0;
}
[System.Security.SecuritySafeCritical] // auto-generated
[ResourceExposure(ResourceScope.Process)]
[ResourceConsumption(ResourceScope.Process)]
set {
new UIPermission(UIPermissionWindow.SafeTopLevelWindows).Demand();
IntPtr handle = ConsoleInputHandle;
if (handle == Win32Native.INVALID_HANDLE_VALUE)
throw new IOException(Environment.GetResourceString("IO.IO_NoConsole"));
int mode = 0;
bool r = Win32Native.GetConsoleMode(handle, out mode);
if (value)
mode &= ~Win32Native.ENABLE_PROCESSED_INPUT;
else
mode |= Win32Native.ENABLE_PROCESSED_INPUT;
r = Win32Native.SetConsoleMode(handle, mode);
if (!r)
__Error.WinIOError();
}
}
#endif // !FEATURE_PAL
// During an appdomain unload, we must call into the OS and remove
// our delegate from the OS's list of console control handlers. If
// we don't do this, the OS will call back on a delegate that no
// longer exists. So, subclass CriticalFinalizableObject.
// This problem would theoretically exist during process exit for a
// single appdomain too, so using a critical finalizer is probably
// better than the appdomain unload event (I'm not sure we call that
// in the default appdomain during process exit).
internal sealed class ControlCHooker : CriticalFinalizerObject
{
private bool _hooked;
[System.Security.SecurityCritical] // auto-generated
private Win32Native.ConsoleCtrlHandlerRoutine _handler;
[System.Security.SecurityCritical] // auto-generated
internal ControlCHooker()
{
_handler = new Win32Native.ConsoleCtrlHandlerRoutine(BreakEvent);
}
[ResourceExposure(ResourceScope.None)]
[ResourceConsumption(ResourceScope.Machine, ResourceScope.Machine)]
~ControlCHooker()
{
Unhook();
}
[System.Security.SecuritySafeCritical] // auto-generated
[ResourceExposure(ResourceScope.Process)]
[ResourceConsumption(ResourceScope.Process)]
internal void Hook()
{
if (!_hooked) {
bool r = Win32Native.SetConsoleCtrlHandler(_handler, true);
if (!r)
__Error.WinIOError();
_hooked = true;
}
}
[System.Security.SecuritySafeCritical] // auto-generated
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
[ResourceExposure(ResourceScope.Process)]
[ResourceConsumption(ResourceScope.Process)]
internal void Unhook()
{
if (_hooked) {
bool r = Win32Native.SetConsoleCtrlHandler(_handler, false);
if (!r)
__Error.WinIOError();
_hooked = false;
}
}
} // internal sealed class ControlCHooker
// A class with data so ControlC handlers can be called on a Threadpool thread.
private sealed class ControlCDelegateData {
internal ConsoleSpecialKey ControlKey;
internal bool Cancel;
internal bool DelegateStarted;
internal ManualResetEvent CompletionEvent;
internal ConsoleCancelEventHandler CancelCallbacks;
internal ControlCDelegateData(ConsoleSpecialKey controlKey, ConsoleCancelEventHandler cancelCallbacks) {
this.ControlKey = controlKey;
this.CancelCallbacks = cancelCallbacks;
this.CompletionEvent = new ManualResetEvent(false);
// this.Cancel defaults to false
// this.DelegateStarted defaults to false
}
}
// Returns true if we've "handled" the break request, false if
// we want to terminate the process (or at least let the next
// control handler function have a chance).
private static bool BreakEvent(int controlType) {
// The thread that this gets called back on has a very small stack on 64 bit systems. There is
// not enough space to handle a managed exception being caught and thrown. So, queue up a work
// item on another thread for the actual event callback.
if (controlType == Win32Native.CTRL_C_EVENT ||
controlType == Win32Native.CTRL_BREAK_EVENT) {
// To avoid ---- between remove handler and raising the event
ConsoleCancelEventHandler cancelCallbacks = Console._cancelCallbacks;
if (cancelCallbacks == null) {
return false;
}
// Create the delegate
ConsoleSpecialKey controlKey = (controlType == 0) ? ConsoleSpecialKey.ControlC : ConsoleSpecialKey.ControlBreak;
ControlCDelegateData delegateData = new ControlCDelegateData(controlKey, cancelCallbacks);
WaitCallback controlCCallback = new WaitCallback(ControlCDelegate);
// Queue the delegate
if (!ThreadPool.QueueUserWorkItem(controlCCallback, delegateData)) {
Contract.Assert(false, "ThreadPool.QueueUserWorkItem returned false without throwing. Unable to execute ControlC handler");
return false;
}
// Block until the delegate is done. We need to be robust in the face of the work item not executing
// but we also want to get control back immediately after it is done and we don't want to give the
// handler a fixed time limit in case it needs to display UI. Wait on the event twice, once with a
// timout and a second time without if we are sure that the handler actually started.
TimeSpan controlCWaitTime = new TimeSpan(0, 0, 30); // 30 seconds
delegateData.CompletionEvent.WaitOne(controlCWaitTime, false);
if (!delegateData.DelegateStarted) {
Contract.Assert(false, "ThreadPool.QueueUserWorkItem did not execute the handler within 30 seconds.");
return false;
}
delegateData.CompletionEvent.WaitOne();
delegateData.CompletionEvent.Close();
return delegateData.Cancel;
}
return false;
}
// This is the worker delegate that is called on the Threadpool thread to fire the actual events. It must guarantee that it
// signals the caller on the ControlC thread so that it does not block indefinitely.
private static void ControlCDelegate(object data) {
ControlCDelegateData controlCData = (ControlCDelegateData)data;
try {
controlCData.DelegateStarted = true;
ConsoleCancelEventArgs args = new ConsoleCancelEventArgs(controlCData.ControlKey);
controlCData.CancelCallbacks(null, args);
controlCData.Cancel = args.Cancel;
}
finally {
controlCData.CompletionEvent.Set();
}
}
// Note: hooking this event allows you to prevent Control-C from
// killing a console app, which is somewhat surprising for users.
// Some permission seems appropriate. We chose UI permission for lack
// of a better one. However, we also applied host protection
// permission here as well, for self-affecting process management.
// This allows hosts to prevent people from adding a handler for
// this event.
public static event ConsoleCancelEventHandler CancelKeyPress {
[System.Security.SecuritySafeCritical] // auto-generated
[ResourceExposure(ResourceScope.Process)]
[ResourceConsumption(ResourceScope.Process)]
add {
new UIPermission(UIPermissionWindow.SafeTopLevelWindows).Demand();
lock(InternalSyncObject) {
// Add this delegate to the pile.
_cancelCallbacks += value;
// If we haven't registered our control-C handler, do it.
if (_hooker == null) {
_hooker = new ControlCHooker();
_hooker.Hook();
}
}
}
[System.Security.SecuritySafeCritical] // auto-generated
[ResourceExposure(ResourceScope.Process)]
[ResourceConsumption(ResourceScope.Process)]
remove {
new UIPermission(UIPermissionWindow.SafeTopLevelWindows).Demand();
lock(InternalSyncObject) {
// If count was 0, call SetConsoleCtrlEvent to remove cb.
_cancelCallbacks -= value;
Contract.Assert(_cancelCallbacks == null || _cancelCallbacks.GetInvocationList().Length > 0, "Teach Console::CancelKeyPress to handle a non-null but empty list of callbacks");
if (_hooker != null && _cancelCallbacks == null)
_hooker.Unhook();
}
}
}
[HostProtection(UI=true)]
[ResourceExposure(ResourceScope.Process)]
[ResourceConsumption(ResourceScope.Process)]
public static Stream OpenStandardError() {
return OpenStandardError(DefaultConsoleBufferSize);
}
#if FEATURE_CORECLR
[System.Security.SecurityCritical] // auto-generated
#endif
[HostProtection(UI=true)]
[ResourceExposure(ResourceScope.Process)]
[ResourceConsumption(ResourceScope.Process)]
public static Stream OpenStandardError(int bufferSize) {
if (bufferSize < 0)
throw new ArgumentOutOfRangeException("bufferSize", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
Contract.EndContractBlock();
return GetStandardFile(Win32Native.STD_ERROR_HANDLE,
FileAccess.Write, bufferSize);
}
[HostProtection(UI=true)]
[ResourceExposure(ResourceScope.Process)]
[ResourceConsumption(ResourceScope.Process)]
public static Stream OpenStandardInput() {
return OpenStandardInput(DefaultConsoleBufferSize);
}
#if FEATURE_CORECLR
[System.Security.SecurityCritical] // auto-generated
#endif
[HostProtection(UI=true)]
[ResourceExposure(ResourceScope.Process)]
[ResourceConsumption(ResourceScope.Process)]
public static Stream OpenStandardInput(int bufferSize) {
if (bufferSize < 0)
throw new ArgumentOutOfRangeException("bufferSize", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
Contract.EndContractBlock();
return GetStandardFile(Win32Native.STD_INPUT_HANDLE,
FileAccess.Read, bufferSize);
}
[HostProtection(UI=true)]
[ResourceExposure(ResourceScope.Process)]
[ResourceConsumption(ResourceScope.Process)]
public static Stream OpenStandardOutput() {
return OpenStandardOutput(DefaultConsoleBufferSize);
}
#if FEATURE_CORECLR
[System.Security.SecurityCritical] // auto-generated
#endif
[HostProtection(UI=true)]
[ResourceExposure(ResourceScope.Process)]
[ResourceConsumption(ResourceScope.Process)]
public static Stream OpenStandardOutput(int bufferSize) {
if (bufferSize < 0)
throw new ArgumentOutOfRangeException("bufferSize", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
Contract.EndContractBlock();
return GetStandardFile(Win32Native.STD_OUTPUT_HANDLE,
FileAccess.Write, bufferSize);
}
#if FEATURE_CORECLR
[System.Security.SecurityCritical] // auto-generated
#else
[System.Security.SecuritySafeCritical]
#endif
[HostProtection(UI=true)]
[ResourceExposure(ResourceScope.AppDomain)]
public static void SetIn(TextReader newIn) {
if (newIn == null)
throw new ArgumentNullException("newIn");
Contract.EndContractBlock();
#pragma warning disable 618
new SecurityPermission(SecurityPermissionFlag.UnmanagedCode).Demand();
#pragma warning restore 618
newIn = TextReader.Synchronized(newIn);
lock(InternalSyncObject) {
_in = newIn;
}
}
#if FEATURE_CORECLR
[System.Security.SecurityCritical] // auto-generated
#else
[System.Security.SecuritySafeCritical]
#endif
[HostProtection(UI=true)]
[ResourceExposure(ResourceScope.AppDomain)]
public static void SetOut(TextWriter newOut) {
if (newOut == null)
throw new ArgumentNullException("newOut");
Contract.EndContractBlock();
#pragma warning disable 618
new SecurityPermission(SecurityPermissionFlag.UnmanagedCode).Demand();
#pragma warning restore 618
#if FEATURE_CODEPAGES_FILE // if no codepages file then we are locked into default codepage and this field is not used
_isOutTextWriterRedirected = true;
#endif
newOut = TextWriter.Synchronized(newOut);
lock(InternalSyncObject) {
_out = newOut;
}
}
#if FEATURE_CORECLR
[System.Security.SecurityCritical] // auto-generated
#else
[System.Security.SecuritySafeCritical]
#endif
[HostProtection(UI=true)]
[ResourceExposure(ResourceScope.AppDomain)]
public static void SetError(TextWriter newError) {
if (newError == null)
throw new ArgumentNullException("newError");
Contract.EndContractBlock();
#pragma warning disable 618
new SecurityPermission(SecurityPermissionFlag.UnmanagedCode).Demand();
#pragma warning restore 618
#if FEATURE_CODEPAGES_FILE // if no codepages file then we are locked into default codepage and this field is not used
_isErrorTextWriterRedirected = true;
#endif
newError = TextWriter.Synchronized(newError);
lock(InternalSyncObject) {
_error = newError;
}
}
//
// Give a hint to the code generator to not inline the common console methods. The console methods are
// not performance critical. It is unnecessary code bloat to have them inlined.
//
// Moreover, simple repros for codegen bugs are often console-based. It is tedious to manually filter out
// the inlined console writelines from them.
//
[HostProtection(UI=true)]
[MethodImplAttribute(MethodImplOptions.NoInlining)]
public static int Read()
{
return In.Read();
}
[HostProtection(UI=true)]
[MethodImplAttribute(MethodImplOptions.NoInlining)]
public static String ReadLine()
{
return In.ReadLine();
}
[HostProtection(UI=true)]
[MethodImplAttribute(MethodImplOptions.NoInlining)]
public static void WriteLine()
{
Out.WriteLine();
}
[HostProtection(UI=true)]
[MethodImplAttribute(MethodImplOptions.NoInlining)]
public static void WriteLine(bool value)
{
Out.WriteLine(value);
}
[HostProtection(UI=true)]
[MethodImplAttribute(MethodImplOptions.NoInlining)]
public static void WriteLine(char value)
{
Out.WriteLine(value);
}
[HostProtection(UI=true)]
[MethodImplAttribute(MethodImplOptions.NoInlining)]
public static void WriteLine(char[] buffer)
{
Out.WriteLine(buffer);
}
[HostProtection(UI=true)]
[MethodImplAttribute(MethodImplOptions.NoInlining)]
public static void WriteLine(char[] buffer, int index, int count)
{
Out.WriteLine(buffer, index, count);
}
[HostProtection(UI=true)]
[MethodImplAttribute(MethodImplOptions.NoInlining)]
public static void WriteLine(decimal value)
{
Out.WriteLine(value);
}
[HostProtection(UI=true)]
[MethodImplAttribute(MethodImplOptions.NoInlining)]
public static void WriteLine(double value)
{
Out.WriteLine(value);
}
[HostProtection(UI=true)]
[MethodImplAttribute(MethodImplOptions.NoInlining)]
public static void WriteLine(float value)
{
Out.WriteLine(value);
}
[HostProtection(UI=true)]
[MethodImplAttribute(MethodImplOptions.NoInlining)]
public static void WriteLine(int value)
{
Out.WriteLine(value);
}
[HostProtection(UI=true)]
[CLSCompliant(false)]
[MethodImplAttribute(MethodImplOptions.NoInlining)]
public static void WriteLine(uint value)
{
Out.WriteLine(value);
}
[HostProtection(UI=true)]
[MethodImplAttribute(MethodImplOptions.NoInlining)]
public static void WriteLine(long value)
{
Out.WriteLine(value);
}
[HostProtection(UI=true)]
[CLSCompliant(false)]
[MethodImplAttribute(MethodImplOptions.NoInlining)]
public static void WriteLine(ulong value)
{
Out.WriteLine(value);
}
[HostProtection(UI=true)]
[MethodImplAttribute(MethodImplOptions.NoInlining)]
public static void WriteLine(Object value)
{
Out.WriteLine(value);
}
[HostProtection(UI=true)]
[MethodImplAttribute(MethodImplOptions.NoInlining)]
public static void WriteLine(String value)
{
Out.WriteLine(value);
}
[HostProtection(UI=true)]
[MethodImplAttribute(MethodImplOptions.NoInlining)]
public static void WriteLine(String format, Object arg0)
{
Out.WriteLine(format, arg0);
}
[HostProtection(UI=true)]
[MethodImplAttribute(MethodImplOptions.NoInlining)]
public static void WriteLine(String format, Object arg0, Object arg1)
{
Out.WriteLine(format, arg0, arg1);
}
[HostProtection(UI=true)]
[MethodImplAttribute(MethodImplOptions.NoInlining)]
public static void WriteLine(String format, Object arg0, Object arg1, Object arg2)
{
Out.WriteLine(format, arg0, arg1, arg2);
}
[HostProtection(UI=true)]
[CLSCompliant(false)]
[MethodImplAttribute(MethodImplOptions.NoInlining)]
public static void WriteLine(String format, Object arg0, Object arg1, Object arg2,Object arg3, __arglist)
{
Object[] objArgs;
int argCount;
ArgIterator args = new ArgIterator(__arglist);
//+4 to account for the 4 hard-coded arguments at the beginning of the list.
argCount = args.GetRemainingCount() + 4;
objArgs = new Object[argCount];
//Handle the hard-coded arguments
objArgs[0] = arg0;
objArgs[1] = arg1;
objArgs[2] = arg2;
objArgs[3] = arg3;
//Walk all of the args in the variable part of the argument list.
for (int i=4; i<argCount; i++) {
objArgs[i] = TypedReference.ToObject(args.GetNextArg());
}
Out.WriteLine(format, objArgs);
}
[HostProtection(UI=true)]
[MethodImplAttribute(MethodImplOptions.NoInlining)]
public static void WriteLine(String format, params Object[] arg)
{
if (arg == null) // avoid ArgumentNullException from String.Format
Out.WriteLine(format, null, null); // faster than Out.WriteLine(format, (Object)arg);
else
Out.WriteLine(format, arg);
}
[HostProtection(UI=true)]
[MethodImplAttribute(MethodImplOptions.NoInlining)]
public static void Write(String format, Object arg0)
{
Out.Write(format, arg0);
}
[HostProtection(UI=true)]
[MethodImplAttribute(MethodImplOptions.NoInlining)]
public static void Write(String format, Object arg0, Object arg1)
{
Out.Write(format, arg0, arg1);
}
[HostProtection(UI=true)]
[MethodImplAttribute(MethodImplOptions.NoInlining)]
public static void Write(String format, Object arg0, Object arg1, Object arg2)
{
Out.Write(format, arg0, arg1, arg2);
}
[HostProtection(UI=true)]
[CLSCompliant(false)]
[MethodImplAttribute(MethodImplOptions.NoInlining)]
public static void Write(String format, Object arg0, Object arg1, Object arg2, Object arg3, __arglist)
{
Object[] objArgs;
int argCount;
ArgIterator args = new ArgIterator(__arglist);
//+4 to account for the 4 hard-coded arguments at the beginning of the list.
argCount = args.GetRemainingCount() + 4;
objArgs = new Object[argCount];
//Handle the hard-coded arguments
objArgs[0] = arg0;
objArgs[1] = arg1;
objArgs[2] = arg2;
objArgs[3] = arg3;
//Walk all of the args in the variable part of the argument list.
for (int i=4; i<argCount; i++) {
objArgs[i] = TypedReference.ToObject(args.GetNextArg());
}
Out.Write(format, objArgs);
}
[HostProtection(UI=true)]
[MethodImplAttribute(MethodImplOptions.NoInlining)]
public static void Write(String format, params Object[] arg)
{
if (arg == null) // avoid ArgumentNullException from String.Format
Out.Write(format, null, null); // faster than Out.Write(format, (Object)arg);
else
Out.Write(format, arg);
}
[HostProtection(UI=true)]
[MethodImplAttribute(MethodImplOptions.NoInlining)]
public static void Write(bool value)
{
Out.Write(value);
}
[HostProtection(UI=true)]
[MethodImplAttribute(MethodImplOptions.NoInlining)]
public static void Write(char value)
{
Out.Write(value);
}
[HostProtection(UI=true)]
[MethodImplAttribute(MethodImplOptions.NoInlining)]
public static void Write(char[] buffer)
{
Out.Write(buffer);
}
[HostProtection(UI=true)]
[MethodImplAttribute(MethodImplOptions.NoInlining)]
public static void Write(char[] buffer, int index, int count)
{
Out.Write(buffer, index, count);
}
[HostProtection(UI=true)]
[MethodImplAttribute(MethodImplOptions.NoInlining)]
public static void Write(double value)
{
Out.Write (value);
}
[HostProtection(UI=true)]
[MethodImplAttribute(MethodImplOptions.NoInlining)]
public static void Write(decimal value)
{
Out.Write (value);
}
[HostProtection(UI=true)]
[MethodImplAttribute(MethodImplOptions.NoInlining)]
public static void Write(float value)
{
Out.Write (value);
}
[HostProtection(UI=true)]
[MethodImplAttribute(MethodImplOptions.NoInlining)]
public static void Write(int value)
{
Out.Write (value);
}
[HostProtection(UI=true)]
[CLSCompliant(false)]
[MethodImplAttribute(MethodImplOptions.NoInlining)]
public static void Write(uint value)
{
Out.Write (value);
}
[HostProtection(UI=true)]
[MethodImplAttribute(MethodImplOptions.NoInlining)]
public static void Write(long value)
{
Out.Write (value);
}
[HostProtection(UI=true)]
[CLSCompliant(false)]
[MethodImplAttribute(MethodImplOptions.NoInlining)]
public static void Write(ulong value)
{
Out.Write (value);
}
[HostProtection(UI=true)]
[MethodImplAttribute(MethodImplOptions.NoInlining)]
public static void Write(Object value)
{
Out.Write (value);
}
[HostProtection(UI=true)]
[MethodImplAttribute(MethodImplOptions.NoInlining)]
public static void Write(String value)
{
Out.Write (value);
}
} // public static class Console
} // namespace System