Console.WriteLine Method (String, Object, Object, Object, Object)

.NET Framework (current version)
 

Writes the text representation of the specified objects and variable-length parameter list, followed by the current line terminator, to the standard output stream using the specified format information.

This API is not CLS-compliant.

Namespace:   System
Assembly:  mscorlib (in mscorlib.dll)

C#
C++
F#
VB
Copy 
C# does not support methods that use variable length arguments (varargs).
The compiler automatically resolves calls to this method to the same method that uses a parameter array.

Parameters

format
Type: System.String

A composite format string (see Remarks).

arg0
Type: System.Object

The first object to write using format.

arg1
Type: System.Object

The second object to write using format.

arg2
Type: System.Object

The third object to write using format.

arg3
Type: System.Object

The fourth object to write using format.

…

A comma-delimited list of one or more additional objects to write using format.

Exception Condition
IOException

An I/O error occurred.

ArgumentNullException

format is null.

FormatException

The format specification in format is invalid.

System_CAPS_noteNote

This API is not CLS-compliant. The CLS-compliant alternative is Console.WriteLine(String, Object[]). The C# and Visual Basic compilers automatically resolve a call to this method as a call to Console.WriteLine(String, Object[]).

This method uses the composite formatting feature of the .NET Framework to convert the value of an object to its text representation and embed that representation in a string. The resulting string is written to the output stream.

The format parameter consists of zero or more runs of text intermixed with zero or more indexed placeholders, called format items, that correspond to an object in the parameter list of this method. The formatting process replaces each format item with the text representation of the value of the corresponding object.

The syntax of a format item is {index[,alignment][:formatString]}, which specifies a mandatory index, the optional length and alignment of the formatted text, and an optional string of format specifier characters that govern how the value of the corresponding object is formatted.

The .NET Framework provides extensive formatting support, which is described in greater detail in the following formatting topics.

For more information about the line terminator, see the Remarks section of the WriteLine method that takes no parameters.

Notes to Callers:

This method is marked with the vararg keyword, which means that it supports a variable number of parameters. The method can be called from Visual C++, but it cannot be called from C# or Visual Basic code. The C# and Visual Basic compilers resolve calls to WriteLine(String, Object, Object, Object, Object) as calls to WriteLine(String, Object[]).

The following example illustrates the use of variable arguments with the WriteLine(String, Object, Object, Object, Object) method. The method is called with a composite format string and five format items.

C++
Copy 
using namespace System;

int CountLetters(String^ value);
int CountWhitespace(String^ value);

void main()
{
   String^ value = "This is a test string.";


   Console::WriteLine("The string '{0}' consists of:" +
                      "{4}{1} characters{4}{2} letters{4}" +
                      "{3} whitespace characters", 
                      value, value->Length, CountLetters(value), 
                      CountWhitespace(value), Environment::NewLine);
}

int CountLetters(String^ value)
{
   int nLetters = 0;
   for each (Char ch in value) {
      if (Char::IsLetter(ch))
         nLetters++;
   }
   return nLetters;
}

int CountWhitespace(String^ value)
{
   int nWhitespace = 0;
   for each (Char ch in value) {
      if (Char::IsWhiteSpace(ch))
         nWhitespace++;
   }
   return nWhitespace;
}
// The example displays the following output:
//    The string 'This is a test string.' consists of:
//    22 characters
//    17 letters
//    4 whitespace characters

UIPermission

for modifying safe top-level windows and subwindows. Associated enumeration: UIPermissionWindow.SafeTopLevelWindows

Return to top
Show: