Cette documentation est archivée et n’est pas conservée.

Console.WriteLine, méthode (String, Object, Object)

Écrit dans le flux de sortie standard la représentation textuelle des objets spécifiés, suivie de la marque de fin de ligne active, à l'aide des informations de format spécifiées.

Espace de noms : System
Assembly : mscorlib (dans mscorlib.dll)

public static void WriteLine (
	string format,
	Object arg0,
	Object arg1
)
public static void WriteLine (
	String format, 
	Object arg0, 
	Object arg1
)
public static function WriteLine (
	format : String, 
	arg0 : Object, 
	arg1 : Object
)

Paramètres

format

Chaîne de format.

arg0

Premier objet à écrire à l'aide de format.

arg1

Second objet à écrire à l'aide de format.

Type d'exceptionCondition

IOException

Une erreur d'E/S s'est produite.

ArgumentNullException

format est référence Null (Nothing en Visual Basic).

FormatException

La spécification de format dans format n'est pas valide.

Cette méthode utilise la fonctionnalité de mise en forme composite du .NET Framework pour convertir la valeur d'un objet en sa représentation textuelle et incorporer cette représentation dans une chaîne. La chaîne obtenue est écrite dans le flux de sortie.

Le paramètre format se compose de zéro ou plusieurs séquences de texte associées à zéro ou plusieurs espaces réservés indexés, appelés éléments de format, qui correspondent à un objet de la liste de paramètres de cette méthode. Le processus de mise en forme remplace chaque élément de format par la représentation textuelle de la valeur de l'objet correspondant.

La syntaxe d'un élément de format est {index[,alignment][:formatString]}, qui spécifie un index obligatoire, la longueur facultative et l'alignement du texte mis en forme, et une chaîne facultative de caractères de spécificateur de format qui indiquent le mode de mise en forme de la valeur de l'objet correspondant.

Le .NET Framework assure une prise en charge étendue de la mise en forme, décrite plus en détail dans les rubriques suivantes relatives à la mise en forme.

Pour plus d'informations sur le terminateur de ligne, consultez la section Notes de la méthode WriteLine qui ne prend aucun paramètre.

L'exemple de code suivant illustre les spécificateurs de mise en forme standard pour les nombres, les dates et les énumérations.

// This code example demonstrates the Console.WriteLine() method.
// Formatting for this example uses the "en-US" culture.

using System;
class Sample 
{
    enum Color {Yellow = 1, Blue, Green};
    static DateTime thisDate = DateTime.Now;

    public static void Main() 
    {
    Console.Clear();

// Format a negative integer or floating-point number in various ways.
    Console.WriteLine("Standard Numeric Format Specifiers");
    Console.WriteLine(
        "(C) Currency: . . . . . . . . {0:C}\n" +
        "(D) Decimal:. . . . . . . . . {0:D}\n" +
        "(E) Scientific: . . . . . . . {1:E}\n" +
        "(F) Fixed point:. . . . . . . {1:F}\n" +
        "(G) General:. . . . . . . . . {0:G}\n" +
        "    (default):. . . . . . . . {0} (default = 'G')\n" +
        "(N) Number: . . . . . . . . . {0:N}\n" +
        "(P) Percent:. . . . . . . . . {1:P}\n" +
        "(R) Round-trip: . . . . . . . {1:R}\n" +
        "(X) Hexadecimal:. . . . . . . {0:X}\n",
        -123, -123.45f); 

// Format the current date in various ways.
    Console.WriteLine("Standard DateTime Format Specifiers");
    Console.WriteLine(
        "(d) Short date: . . . . . . . {0:d}\n" +
        "(D) Long date:. . . . . . . . {0:D}\n" +
        "(t) Short time: . . . . . . . {0:t}\n" +
        "(T) Long time:. . . . . . . . {0:T}\n" +
        "(f) Full date/short time: . . {0:f}\n" +
        "(F) Full date/long time:. . . {0:F}\n" +
        "(g) General date/short time:. {0:g}\n" +
        "(G) General date/long time: . {0:G}\n" +
        "    (default):. . . . . . . . {0} (default = 'G')\n" +
        "(M) Month:. . . . . . . . . . {0:M}\n" +
        "(R) RFC1123:. . . . . . . . . {0:R}\n" +
        "(s) Sortable: . . . . . . . . {0:s}\n" +
        "(u) Universal sortable: . . . {0:u} (invariant)\n" +
        "(U) Universal sortable: . . . {0:U}\n" +
        "(Y) Year: . . . . . . . . . . {0:Y}\n", 
        thisDate);

// Format a Color enumeration value in various ways.
    Console.WriteLine("Standard Enumeration Format Specifiers");
    Console.WriteLine(
        "(G) General:. . . . . . . . . {0:G}\n" +
        "    (default):. . . . . . . . {0} (default = 'G')\n" +
        "(F) Flags:. . . . . . . . . . {0:F} (flags or integer)\n" +
        "(D) Decimal number: . . . . . {0:D}\n" +
        "(X) Hexadecimal:. . . . . . . {0:X}\n", 
        Color.Green);       
    }
}
/*
This code example produces the following results:

Standard Numeric Format Specifiers
(C) Currency: . . . . . . . . ($123.00)
(D) Decimal:. . . . . . . . . -123
(E) Scientific: . . . . . . . -1.234500E+002
(F) Fixed point:. . . . . . . -123.45
(G) General:. . . . . . . . . -123
    (default):. . . . . . . . -123 (default = 'G')
(N) Number: . . . . . . . . . -123.00
(P) Percent:. . . . . . . . . -12,345.00 %
(R) Round-trip: . . . . . . . -123.45
(X) Hexadecimal:. . . . . . . FFFFFF85

Standard DateTime Format Specifiers
(d) Short date: . . . . . . . 6/26/2004
(D) Long date:. . . . . . . . Saturday, June 26, 2004
(t) Short time: . . . . . . . 8:11 PM
(T) Long time:. . . . . . . . 8:11:04 PM
(f) Full date/short time: . . Saturday, June 26, 2004 8:11 PM
(F) Full date/long time:. . . Saturday, June 26, 2004 8:11:04 PM
(g) General date/short time:. 6/26/2004 8:11 PM
(G) General date/long time: . 6/26/2004 8:11:04 PM
    (default):. . . . . . . . 6/26/2004 8:11:04 PM (default = 'G')
(M) Month:. . . . . . . . . . June 26
(R) RFC1123:. . . . . . . . . Sat, 26 Jun 2004 20:11:04 GMT
(s) Sortable: . . . . . . . . 2004-06-26T20:11:04
(u) Universal sortable: . . . 2004-06-26 20:11:04Z (invariant)
(U) Universal sortable: . . . Sunday, June 27, 2004 3:11:04 AM
(Y) Year: . . . . . . . . . . June, 2004

Standard Enumeration Format Specifiers
(G) General:. . . . . . . . . Green
    (default):. . . . . . . . Green (default = 'G')
(F) Flags:. . . . . . . . . . Green (flags or integer)
(D) Decimal number: . . . . . 3
(X) Hexadecimal:. . . . . . . 00000003

*/

L'exemple de code suivant illustre l'utilisation de la méthode WriteLine.

// System.Console.WriteLine

using System;
public class TipCalculator {
    private const double tipRate = 0.18;
    public static int Main(string[] args) {
        double billTotal;
        if (args.Length == 0) {
            Console.WriteLine("usage: TIPCALC total");
            return 1;
        }
        else {
            try {
                billTotal = Double.Parse(args[0]);
            }
            catch(FormatException) {
                Console.WriteLine("usage: TIPCALC total");
                return 1;
            }
            double tip = billTotal * tipRate;
            Console.WriteLine();
            Console.WriteLine("Bill total:\t{0,8:c}", billTotal);
            Console.WriteLine("Tip total/rate:\t{0,8:c} ({1:p1})", tip, tipRate);
            Console.WriteLine(("").PadRight(24, '-'));
            Console.WriteLine("Grand total:\t{0,8:c}", billTotal + tip);
            return 0;
        }
    }
}

/*
Example Output:
---------------

Bill total:       $52.23
Tip total/rate:    $9.40 (18.0 %)
------------------------
Grand total:      $61.63
*/

// System.Console.WriteLine

import System.* ;

public class TipCalculator
{
    private static double tipRate = 0.18;

    public static void main(String[] args)
    {
        double billTotal = 0;

        if (args.length == 0) {
            Console.WriteLine("usage: TIPCALC total");            
        }
        else {

            try {
                billTotal = Double.parseDouble(args[0]);
            }
            catch (FormatException exp)    {
                Console.WriteLine("usage: TIPCALC total");                
            }

            double tip = billTotal * tipRate;

            Console.WriteLine();
            Console.WriteLine("Bill total:\t{0,8}", 
                ((System.Double)billTotal).ToString("c"));
            Console.WriteLine("Tip total/rate:\t{0,8} ({1})", 
                ((System.Double)tip).ToString("c"), 
                ((System.Double)tipRate).ToString("p1"));
            Console.WriteLine("".PadRight(24, '-'));
            Console.WriteLine("Grand total:\t{0,8}",
                ((System.Double)(billTotal + tip)).ToString("c"));                
        }
    } //main
} //TipCalculator

/*
Example Output:
---------------

Bill total:       $52.23
Tip total/rate:    $9.40 (18.0 %)
------------------------
Grand total:      $61.63
*/

// System.Console.WriteLine
import System;
    
const tipRate : Number = 0.18;
var billTotal : Number;
var args : String[] = Environment.GetCommandLineArgs();

if (args.Length != 2) {
    Console.WriteLine("usage: TIPCALC total");
    Environment.Exit(1);
}

try {
    billTotal = Double.Parse(args[1]);
}
catch(FormatException) {
    Console.WriteLine("usage: TIPCALC total");
    Environment.Exit(1);
}

var tip : double = billTotal * tipRate;
Console.WriteLine();
Console.WriteLine("Bill total:\t{0,8:c}", billTotal);
Console.WriteLine("Tip total/rate:\t{0,8:c} ({1:p1})", tip, tipRate);
Console.WriteLine(("").PadRight(24, '-'));
Console.WriteLine("Grand total:\t{0,8:c}", billTotal + tip);

/*
Example Output:
---------------

Bill total:       $52.23
Tip total/rate:    $9.40 (18.0 %)
------------------------
Grand total:      $61.63
*/

Windows 98, Windows 2000 SP4, Windows Millennium Edition, Windows Server 2003, Windows XP Édition Media Center, Windows XP Professionnel Édition x64, Windows XP SP2, Windows XP Starter Edition

Le .NET Framework ne prend pas en charge toutes les versions de chaque plate-forme. Pour obtenir la liste des versions prises en charge, consultez Configuration requise.

.NET Framework

Prise en charge dans : 2.0, 1.1, 1.0

.NET Compact Framework

Prise en charge dans : 2.0, 1.0
Afficher: