Console.Write Méthode

Définition

Espace de noms:

System

Assembly:

System.Console.dll

Écrit la représentation textuelle de la valeur ou des valeurs spécifiées dans le flux de sortie standard.

Surcharges

Write(String, Object, Object, Object)	Écrit la représentation textuelle des objets spécifiés dans le flux de sortie standard à l’aide des informations de format spécifiées.
Write(Char[], Int32, Int32)	Écrit le sous-tableau spécifié de caractères Unicode dans le flux de sortie standard.
Write(String, Object[])	Écrit la représentation textuelle du tableau d’objets spécifié dans le flux de sortie standard à l’aide des informations de format spécifiées.
Write(String, Object)	Écrit la représentation textuelle de l’objet spécifié dans le flux de sortie standard à l’aide des informations de format spécifiées.
Write(UInt64)	Écrit la représentation textuelle de la valeur entière non signée 64 bits spécifiée dans le flux de sortie standard.
Write(UInt32)	Écrit la représentation textuelle de la valeur entière non signée 32 bits spécifiée dans le flux de sortie standard.
Write(String)	Écrit la valeur de chaîne spécifiée dans le flux de sortie standard.
Write(String, Object, Object)	Écrit la représentation textuelle des objets spécifiés dans le flux de sortie standard à l’aide des informations de format spécifiées.
Write(Object)	Écrit la représentation textuelle de l’objet spécifié dans le flux de sortie standard.
Write(Single)	Écrit la représentation textuelle de la valeur à virgule flottante simple précision spécifiée dans le flux de sortie standard.
Write(Char)	Écrit la valeur de caractère Unicode spécifiée dans le flux de sortie standard.
Write(Char[])	Écrit le tableau spécifié de caractères Unicode dans le flux de sortie standard.
Write(Boolean)	Écrit la représentation textuelle de la valeur booléenne spécifiée dans le flux de sortie standard.
Write(Double)	Écrit la représentation textuelle de la valeur à virgule flottante double précision spécifiée dans le flux de sortie standard.
Write(Int32)	Écrit la représentation textuelle de la valeur entière signée 32 bits spécifiée dans le flux de sortie standard.
Write(Int64)	Écrit la représentation textuelle de la valeur entière signée 64 bits spécifiée dans le flux de sortie standard.
Write(Decimal)	Écrit la représentation textuelle de la valeur Decimal spécifiée dans le flux de sortie standard.

Write(String, Object, Object, Object)

Source:

Console.cs

Écrit la représentation textuelle des objets spécifiés dans le flux de sortie standard à l’aide des informations de format spécifiées.

C#

public static void Write (string format, object? arg0, object? arg1, object? arg2);

Paramètres

format

String

Chaîne de format composite.

arg0

Object

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

arg1

Object

Deuxième objet à écrire à l’aide de format.

arg2

Object

Troisième objet à écrire à l’aide de format.

Exceptions

IOException

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

ArgumentNullException

format est null.

FormatException

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

Exemples

L’exemple suivant utilise la méthode WriteLine pour illustrer les spécificateurs de mise en forme standard pour les nombres, les dates et les énumérations.

C#

// 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 full date/time: {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 full date/time: 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 suivant illustre l’utilisation de la méthode Write.

C#

public class FormatConverter
{
    public static void Main(string[] args)
    {
        string lineInput;
        while ((lineInput = Console.ReadLine()) != null)
        {
            string[] fields = lineInput.Split(new char[] {'\t'});
            bool isFirstField = true;
            foreach (var item in fields)
            {
                if (isFirstField)
                    isFirstField = false;
                else
                    Console.Write(',');

                // If the field represents a boolean, replace with a numeric representation.
                bool itemBool;
                if (Boolean.TryParse(item, out itemBool))
                    Console.Write(Convert.ToByte(itemBool));
                else
                    Console.Write(item);
            }
            Console.WriteLine();
        }
    }
}

Remarques

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

Le paramètre format se compose de zéro ou plusieurs exécutions de texte mélangées avec zéro ou plus d’espaces réservés indexés, appelés éléments de format, qui correspondent à un objet dans 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[,alignement][: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 spécificateurs de format qui régissent la façon dont la valeur de l’objet correspondant est mise en forme.

.NET fournit une prise en charge étendue de la mise en forme, qui est décrite plus en détail dans les rubriques de mise en forme suivantes.

• Pour plus d’informations sur la fonctionnalité de mise en forme composite prise en charge par des méthodes telles que Format, AppendFormatet certaines surcharges de WriteLine, consultez de mise en forme composite.

• Pour plus d’informations sur les spécificateurs de format numérique, consultez chaînes de format numérique standard et chaînes de format numérique personnalisées.

• Pour plus d’informations sur les spécificateurs de format de date et d’heure, consultez chaînes de format de date et d’heure standard et chaînes de format de date et d’heure personnalisées.

• Pour plus d’informations sur les spécificateurs de format d’énumération, consultez chaînes de format d’énumération.

• Pour plus d’informations sur la mise en forme, consultez types de mise en forme.

Voir aussi

• Read()
• ReadLine()
• WriteLine()
• types de mise en forme dans .NET
• de mise en forme composite

Write(Char[], Int32, Int32)

Source:

Console.cs

Écrit le sous-tableau spécifié de caractères Unicode dans le flux de sortie standard.

C#

public static void Write (char[] buffer, int index, int count);

Paramètres

buffer

Char[]

Tableau de caractères Unicode.

index

Int32

Position de départ dans buffer.

count

Int32

Nombre de caractères à écrire.

Exceptions

ArgumentNullException

buffer est null.

ArgumentOutOfRangeException

index ou count est inférieur à zéro.

ArgumentException

index plus count spécifier une position qui n’est pas comprise dans buffer.

IOException

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

Remarques

Cette méthode écrit count caractères commençant à la position index de buffer dans le flux de sortie standard.

Voir aussi

• Read()
• ReadLine()
• WriteLine()

Write(String, Object[])

Source:

Console.cs

Écrit la représentation textuelle du tableau d’objets spécifié dans le flux de sortie standard à l’aide des informations de format spécifiées.

C#

public static void Write (string format, params object?[]? arg);

Paramètres

format

String

Chaîne de format composite.

arg

Object[]

Tableau d’objets à écrire à l’aide de format.

Exceptions

IOException

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

ArgumentNullException

format ou arg est null.

FormatException

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

Exemples

L’exemple suivant définit une classe Person avec un certain nombre de propriétés qui fournissent des informations sur une personne. Sa méthode GetDescription retourne un tableau qui contient toutes les valeurs de propriété à l’exception d’une. L’exemple utilise ensuite le tableau retourné par la méthode GetDescription pour afficher les valeurs de l’objet Person.

C#

using System;

public class Person
{
   public String Name { get; set; }
   public DateTime BirthDate  { get; set; }
   public Double Height { get; set; }
   public Double Weight { get; set; }
   public Char Gender { get; set; }
   public String Remarks { get; set; }

   public object[] GetDescription()
   {
      return new object[] { Name, Gender, Height, Weight, BirthDate};
   }
}

public class Example
{
   public static void Main()
   {
      var p1 = new Person() { Name = "John", Gender = 'M',
                              BirthDate = new DateTime(1992, 5, 10),
                              Height = 73.5, Weight = 207 };
      p1.Remarks = "Client since 1/3/2012";
      Console.Write("{0}: {1}, born {4:d}  Height {2} inches, Weight {3} lbs  ",
                    p1.GetDescription());
      if (String.IsNullOrEmpty(p1.Remarks))
         Console.WriteLine();
      else
         Console.WriteLine("{1}Remarks: {0}", p1.Remarks,
                           Console.CursorLeft + p1.Remarks.Length + 10 > Console.WindowWidth ?
                              "\n   " : "");
   }
}
// The example displays the following output:
//    John: M, born 5/10/1992  Height 73.5 inches, Weight 207 lbs  Remarks: Client since 1/3/2012

Notez que l’exemple appelle la méthode Write(String, Object[]) plutôt que la méthode WriteLine(String, Object[]), car elle tente d’afficher la valeur de la propriété Person.Remarks sur la même ligne. Pour ce faire, il examine la valeur des propriétés CursorLeft et WindowWidth pour déterminer s’il y a suffisamment d’espace pour que la remarque s’adapte. S’il y en a, il affiche la ligne. Si ce n’est pas le cas, il écrit une ligne, met en retrait trois espaces et affiche la remarque.

L’exemple suivant est identique au premier, sauf qu’il fournit une liste à cinq éléments comme argument arg au lieu d’un tableau de paramètres.

C#

using System;

public class Person
{
   public String Name { get; set; }
   public DateTime BirthDate  { get; set; }
   public Double Height { get; set; }
   public Double Weight { get; set; }
   public Char Gender { get; set; }
   public String Remarks { get; set; }

   public object[] GetDescription()
   {
      return new object[] { Name, Gender, Height, Weight, BirthDate};
   }
}

public class Example
{
   public static void Main()
   {
      var p1 = new Person() { Name = "John", Gender = 'M',
                              BirthDate = new DateTime(1992, 5, 10),
                              Height = 73.5, Weight = 207 };
      p1.Remarks = "Client since 1/3/2012";
      Console.Write("{0}: {1}, born {2:d}  Height {3} inches, Weight {4} lbs  ",
                    p1.Name, p1.Gender, p1.BirthDate, p1.Height, p1.Weight);
      if (String.IsNullOrEmpty(p1.Remarks))
         Console.WriteLine();
      else
         Console.WriteLine("{1}Remarks: {0}", p1.Remarks,
                           Console.CursorLeft + p1.Remarks.Length + 10 > Console.WindowWidth ?
                              "\n   " : "");
   }
}
// The example displays the following output:
//    John: M, born 5/10/1992  Height 73.5 inches, Weight 207 lbs  Remarks: Client since 1/3/2012

Remarques

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

Le paramètre format se compose de zéro ou plusieurs exécutions de texte mélangées avec zéro ou plus d’espaces réservés indexés, appelés éléments de format, qui correspondent à un objet dans 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[,alignement][: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 spécificateurs de format qui régissent la façon dont la valeur de l’objet correspondant est mise en forme.

.NET fournit une prise en charge étendue de la mise en forme, qui est décrite plus en détail dans les rubriques de mise en forme suivantes.

• Pour plus d’informations sur la fonctionnalité de mise en forme composite prise en charge par des méthodes telles que Format, AppendFormatet certaines surcharges de WriteLine, consultez de mise en forme composite.

• Pour plus d’informations sur les spécificateurs de format numérique, consultez chaînes de format numérique standard et chaînes de format numérique personnalisées.

• Pour plus d’informations sur les spécificateurs de format de date et d’heure, consultez chaînes de format de date et d’heure standard et chaînes de format de date et d’heure personnalisées.

• Pour plus d’informations sur les spécificateurs de format d’énumération, consultez chaînes de format d’énumération.

• Pour plus d’informations sur la mise en forme, consultez types de mise en forme.

Le paramètre arg est un tableau de paramètres. Les arguments peuvent être passés à la méthode en tant que tableau ou en tant que liste de cinq éléments ou plus. Les exemples illustrent les deux formes d’appel de méthode.

Notes pour les appelants

Cette méthode n’est pas appelée par le code C++. Le compilateur C++ résout les appels à System.Console.Write qui incluent une chaîne et une liste de quatre paramètres d’objet ou plus en tant qu’appel à Write(String, Object, Object, Object, Object). Il résout les appels à System.Console.Write qui incluent une chaîne et un tableau d’objets comme appel à Write(String, Object).

Voir aussi

• Read()
• ReadLine()
• WriteLine()
• types de mise en forme dans .NET
• de mise en forme composite

Write(String, Object)

Source:

Console.cs

Écrit la représentation textuelle de l’objet spécifié dans le flux de sortie standard à l’aide des informations de format spécifiées.

C#

public static void Write (string format, object? arg0);

Paramètres

format

String

Chaîne de format composite.

arg0

Object

Objet à écrire à l’aide de format.

Exceptions

IOException

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

ArgumentNullException

format est null.

FormatException

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

Exemples

L’exemple suivant utilise la méthode WriteLine pour illustrer les spécificateurs de mise en forme standard pour les nombres, les dates et les énumérations.

C#

// 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 full date/time: {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 full date/time: 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 suivant illustre l’utilisation de la méthode Write.

C#

public class FormatConverter
{
    public static void Main(string[] args)
    {
        string lineInput;
        while ((lineInput = Console.ReadLine()) != null)
        {
            string[] fields = lineInput.Split(new char[] {'\t'});
            bool isFirstField = true;
            foreach (var item in fields)
            {
                if (isFirstField)
                    isFirstField = false;
                else
                    Console.Write(',');

                // If the field represents a boolean, replace with a numeric representation.
                bool itemBool;
                if (Boolean.TryParse(item, out itemBool))
                    Console.Write(Convert.ToByte(itemBool));
                else
                    Console.Write(item);
            }
            Console.WriteLine();
        }
    }
}

Remarques

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

Le paramètre format se compose de zéro ou plusieurs exécutions de texte mélangées avec zéro ou plus d’espaces réservés indexés, appelés éléments de format, qui correspondent à un objet dans 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[,alignement][: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 spécificateurs de format qui régissent la façon dont la valeur de l’objet correspondant est mise en forme.

.NET fournit une prise en charge étendue de la mise en forme, qui est décrite plus en détail dans les rubriques de mise en forme suivantes.

• Pour plus d’informations sur la fonctionnalité de mise en forme composite prise en charge par des méthodes telles que Format, AppendFormatet certaines surcharges de WriteLine, consultez de mise en forme composite.

• Pour plus d’informations sur les spécificateurs de format numérique, consultez chaînes de format numérique standard et chaînes de format numérique personnalisées.

• Pour plus d’informations sur les spécificateurs de format de date et d’heure, consultez chaînes de format de date et d’heure standard et chaînes de format de date et d’heure personnalisées.

• Pour plus d’informations sur les spécificateurs de format d’énumération, consultez chaînes de format d’énumération.

• Pour plus d’informations sur la mise en forme, consultez types de mise en forme.

Voir aussi

• Read()
• ReadLine()
• WriteLine()
• types de mise en forme dans .NET
• de mise en forme composite

Write(UInt64)

Source:

Console.cs

Important

Cette API n’est pas conforme CLS.

Écrit la représentation textuelle de la valeur entière non signée 64 bits spécifiée dans le flux de sortie standard.

C#

[System.CLSCompliant(false)]
public static void Write (ulong value);

Paramètres

value

UInt64

Valeur à écrire.

Attributs

CLSCompliantAttribute

Exceptions

IOException

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

Exemples

L’exemple suivant illustre l’utilisation de la méthode Write.

C#

public class FormatConverter
{
    public static void Main(string[] args)
    {
        string lineInput;
        while ((lineInput = Console.ReadLine()) != null)
        {
            string[] fields = lineInput.Split(new char[] {'\t'});
            bool isFirstField = true;
            foreach (var item in fields)
            {
                if (isFirstField)
                    isFirstField = false;
                else
                    Console.Write(',');

                // If the field represents a boolean, replace with a numeric representation.
                bool itemBool;
                if (Boolean.TryParse(item, out itemBool))
                    Console.Write(Convert.ToByte(itemBool));
                else
                    Console.Write(item);
            }
            Console.WriteLine();
        }
    }
}

Remarques

La représentation textuelle de value est produite en appelant la méthode UInt64.ToString.

Voir aussi

• Read()
• ReadLine()
• WriteLine()

Write(UInt32)

Source:

Console.cs

Important

Cette API n’est pas conforme CLS.

Écrit la représentation textuelle de la valeur entière non signée 32 bits spécifiée dans le flux de sortie standard.

C#

[System.CLSCompliant(false)]
public static void Write (uint value);

Paramètres

value

UInt32

Valeur à écrire.

Attributs

CLSCompliantAttribute

Exceptions

IOException

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

Exemples

L’exemple suivant illustre l’utilisation de la méthode Write.

C#

public class FormatConverter
{
    public static void Main(string[] args)
    {
        string lineInput;
        while ((lineInput = Console.ReadLine()) != null)
        {
            string[] fields = lineInput.Split(new char[] {'\t'});
            bool isFirstField = true;
            foreach (var item in fields)
            {
                if (isFirstField)
                    isFirstField = false;
                else
                    Console.Write(',');

                // If the field represents a boolean, replace with a numeric representation.
                bool itemBool;
                if (Boolean.TryParse(item, out itemBool))
                    Console.Write(Convert.ToByte(itemBool));
                else
                    Console.Write(item);
            }
            Console.WriteLine();
        }
    }
}

Remarques

La représentation textuelle de value est produite en appelant la méthode UInt32.ToString.

Voir aussi

• Read()
• ReadLine()
• WriteLine()

Write(String)

Source:

Console.cs

Écrit la valeur de chaîne spécifiée dans le flux de sortie standard.

C#

public static void Write (string? value);

Paramètres

value

String

Valeur à écrire.

Exceptions

IOException

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

Exemples

L’exemple suivant illustre l’utilisation de la méthode Write.

C#

public class FormatConverter
{
    public static void Main(string[] args)
    {
        string lineInput;
        while ((lineInput = Console.ReadLine()) != null)
        {
            string[] fields = lineInput.Split(new char[] {'\t'});
            bool isFirstField = true;
            foreach (var item in fields)
            {
                if (isFirstField)
                    isFirstField = false;
                else
                    Console.Write(',');

                // If the field represents a boolean, replace with a numeric representation.
                bool itemBool;
                if (Boolean.TryParse(item, out itemBool))
                    Console.Write(Convert.ToByte(itemBool));
                else
                    Console.Write(item);
            }
            Console.WriteLine();
        }
    }
}

Remarques

Si la valeur est null, rien n’est écrit dans le flux de sortie standard.

Voir aussi

• Read()
• ReadLine()
• WriteLine()

Write(String, Object, Object)

Source:

Console.cs

Écrit la représentation textuelle des objets spécifiés dans le flux de sortie standard à l’aide des informations de format spécifiées.

C#

public static void Write (string format, object? arg0, object? arg1);

Paramètres

format

String

Chaîne de format composite.

arg0

Object

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

arg1

Object

Deuxième objet à écrire à l’aide de format.

Exceptions

IOException

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

ArgumentNullException

format est null.

FormatException

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

Exemples

L’exemple suivant utilise la méthode WriteLine pour illustrer les spécificateurs de mise en forme standard pour les nombres, les dates et les énumérations.

C#

// 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 full date/time: {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 full date/time: 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 suivant illustre l’utilisation de la méthode Write.

C#

public class FormatConverter
{
    public static void Main(string[] args)
    {
        string lineInput;
        while ((lineInput = Console.ReadLine()) != null)
        {
            string[] fields = lineInput.Split(new char[] {'\t'});
            bool isFirstField = true;
            foreach (var item in fields)
            {
                if (isFirstField)
                    isFirstField = false;
                else
                    Console.Write(',');

                // If the field represents a boolean, replace with a numeric representation.
                bool itemBool;
                if (Boolean.TryParse(item, out itemBool))
                    Console.Write(Convert.ToByte(itemBool));
                else
                    Console.Write(item);
            }
            Console.WriteLine();
        }
    }
}

Remarques

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

Le paramètre format se compose de zéro ou plusieurs exécutions de texte mélangées avec zéro ou plus d’espaces réservés indexés, appelés éléments de format, qui correspondent à un objet dans 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[,alignement][: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 spécificateurs de format qui régissent la façon dont la valeur de l’objet correspondant est mise en forme.

.NET fournit une prise en charge étendue de la mise en forme, qui est décrite plus en détail dans les rubriques de mise en forme suivantes.

• Pour plus d’informations sur la fonctionnalité de mise en forme composite prise en charge par des méthodes telles que Format, AppendFormatet certaines surcharges de WriteLine, consultez de mise en forme composite.

• Pour plus d’informations sur les spécificateurs de format numérique, consultez chaînes de format numérique standard et chaînes de format numérique personnalisées.

• Pour plus d’informations sur les spécificateurs de format de date et d’heure, consultez chaînes de format de date et d’heure standard et chaînes de format de date et d’heure personnalisées.

• Pour plus d’informations sur les spécificateurs de format d’énumération, consultez chaînes de format d’énumération.

• Pour plus d’informations sur la mise en forme, consultez types de mise en forme.

Voir aussi

• Read()
• ReadLine()
• WriteLine()
• types de mise en forme dans .NET
• de mise en forme composite

Write(Object)

Source:

Console.cs

Écrit la représentation textuelle de l’objet spécifié dans le flux de sortie standard.

C#

public static void Write (object? value);

Paramètres

value

Object

Valeur à écrire, ou null.

Exceptions

IOException

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

Exemples

L’exemple suivant illustre l’utilisation de la méthode Write.

C#

public class FormatConverter
{
    public static void Main(string[] args)
    {
        string lineInput;
        while ((lineInput = Console.ReadLine()) != null)
        {
            string[] fields = lineInput.Split(new char[] {'\t'});
            bool isFirstField = true;
            foreach (var item in fields)
            {
                if (isFirstField)
                    isFirstField = false;
                else
                    Console.Write(',');

                // If the field represents a boolean, replace with a numeric representation.
                bool itemBool;
                if (Boolean.TryParse(item, out itemBool))
                    Console.Write(Convert.ToByte(itemBool));
                else
                    Console.Write(item);
            }
            Console.WriteLine();
        }
    }
}

Remarques

Si value est null, rien n’est écrit et aucune exception n’est levée. Sinon, la méthode ToString de value est appelée pour produire sa représentation sous forme de chaîne et la chaîne résultante est écrite dans le flux de sortie standard.

Voir aussi

• Read()
• ReadLine()
• WriteLine()

Write(Single)

Source:

Console.cs

Écrit la représentation textuelle de la valeur à virgule flottante simple précision spécifiée dans le flux de sortie standard.

C#

public static void Write (float value);

Paramètres

value

Single

Valeur à écrire.

Exceptions

IOException

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

Exemples

L’exemple suivant illustre l’utilisation de la méthode Write.

C#

public class FormatConverter
{
    public static void Main(string[] args)
    {
        string lineInput;
        while ((lineInput = Console.ReadLine()) != null)
        {
            string[] fields = lineInput.Split(new char[] {'\t'});
            bool isFirstField = true;
            foreach (var item in fields)
            {
                if (isFirstField)
                    isFirstField = false;
                else
                    Console.Write(',');

                // If the field represents a boolean, replace with a numeric representation.
                bool itemBool;
                if (Boolean.TryParse(item, out itemBool))
                    Console.Write(Convert.ToByte(itemBool));
                else
                    Console.Write(item);
            }
            Console.WriteLine();
        }
    }
}

Remarques

La représentation textuelle de value est produite en appelant la méthode Single.ToString.

Voir aussi

• Read()
• ReadLine()
• WriteLine()

Write(Char)

Source:

Console.cs

Écrit la valeur de caractère Unicode spécifiée dans le flux de sortie standard.

C#

public static void Write (char value);

Paramètres

value

Char

Valeur à écrire.

Exceptions

IOException

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

Exemples

L’exemple suivant illustre l’utilisation de la méthode Write.

C#

public class FormatConverter
{
    public static void Main(string[] args)
    {
        string lineInput;
        while ((lineInput = Console.ReadLine()) != null)
        {
            string[] fields = lineInput.Split(new char[] {'\t'});
            bool isFirstField = true;
            foreach (var item in fields)
            {
                if (isFirstField)
                    isFirstField = false;
                else
                    Console.Write(',');

                // If the field represents a boolean, replace with a numeric representation.
                bool itemBool;
                if (Boolean.TryParse(item, out itemBool))
                    Console.Write(Convert.ToByte(itemBool));
                else
                    Console.Write(item);
            }
            Console.WriteLine();
        }
    }
}

Voir aussi

• Read()
• ReadLine()
• WriteLine()

Write(Char[])

Source:

Console.cs

Écrit le tableau spécifié de caractères Unicode dans le flux de sortie standard.

C#

public static void Write (char[]? buffer);

Paramètres

buffer

Char[]

Tableau de caractères Unicode.

Exceptions

IOException

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

Voir aussi

• Read()
• ReadLine()
• WriteLine()

Write(Boolean)

Source:

Console.cs

Écrit la représentation textuelle de la valeur booléenne spécifiée dans le flux de sortie standard.

C#

public static void Write (bool value);

Paramètres

value

Boolean

Valeur à écrire.

Exceptions

IOException

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

Exemples

L’exemple suivant illustre l’utilisation de la méthode Write.

C#

public class FormatConverter
{
    public static void Main(string[] args)
    {
        string lineInput;
        while ((lineInput = Console.ReadLine()) != null)
        {
            string[] fields = lineInput.Split(new char[] {'\t'});
            bool isFirstField = true;
            foreach (var item in fields)
            {
                if (isFirstField)
                    isFirstField = false;
                else
                    Console.Write(',');

                // If the field represents a boolean, replace with a numeric representation.
                bool itemBool;
                if (Boolean.TryParse(item, out itemBool))
                    Console.Write(Convert.ToByte(itemBool));
                else
                    Console.Write(item);
            }
            Console.WriteLine();
        }
    }
}

Remarques

La représentation textuelle de value est produite en appelant Boolean.ToString, qui génère des sorties Boolean.TrueString ou Boolean.FalseString.

Voir aussi

• Read()
• ReadLine()
• WriteLine()

Write(Double)

Source:

Console.cs

Écrit la représentation textuelle de la valeur à virgule flottante double précision spécifiée dans le flux de sortie standard.

C#

public static void Write (double value);

Paramètres

value

Double

Valeur à écrire.

Exceptions

IOException

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

Exemples

L’exemple suivant illustre l’utilisation de la méthode Write.

C#

public class FormatConverter
{
    public static void Main(string[] args)
    {
        string lineInput;
        while ((lineInput = Console.ReadLine()) != null)
        {
            string[] fields = lineInput.Split(new char[] {'\t'});
            bool isFirstField = true;
            foreach (var item in fields)
            {
                if (isFirstField)
                    isFirstField = false;
                else
                    Console.Write(',');

                // If the field represents a boolean, replace with a numeric representation.
                bool itemBool;
                if (Boolean.TryParse(item, out itemBool))
                    Console.Write(Convert.ToByte(itemBool));
                else
                    Console.Write(item);
            }
            Console.WriteLine();
        }
    }
}

Remarques

La représentation textuelle de value est produite en appelant la méthode Double.ToString.

Voir aussi

• Read()
• ReadLine()
• WriteLine()

Write(Int32)

Source:

Console.cs

Écrit la représentation textuelle de la valeur entière signée 32 bits spécifiée dans le flux de sortie standard.

C#

public static void Write (int value);

Paramètres

value

Int32

Valeur à écrire.

Exceptions

IOException

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

Exemples

L’exemple suivant illustre l’utilisation de la méthode Write.

C#

public class FormatConverter
{
    public static void Main(string[] args)
    {
        string lineInput;
        while ((lineInput = Console.ReadLine()) != null)
        {
            string[] fields = lineInput.Split(new char[] {'\t'});
            bool isFirstField = true;
            foreach (var item in fields)
            {
                if (isFirstField)
                    isFirstField = false;
                else
                    Console.Write(',');

                // If the field represents a boolean, replace with a numeric representation.
                bool itemBool;
                if (Boolean.TryParse(item, out itemBool))
                    Console.Write(Convert.ToByte(itemBool));
                else
                    Console.Write(item);
            }
            Console.WriteLine();
        }
    }
}

Remarques

La représentation textuelle de value est produite en appelant la méthode Int32.ToString.

Voir aussi

• Read()
• ReadLine()
• WriteLine()

Write(Int64)

Source:

Console.cs

Écrit la représentation textuelle de la valeur entière signée 64 bits spécifiée dans le flux de sortie standard.

C#

public static void Write (long value);

Paramètres

value

Int64

Valeur à écrire.

Exceptions

IOException

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

Exemples

L’exemple suivant illustre l’utilisation de la méthode Write.

C#

public class FormatConverter
{
    public static void Main(string[] args)
    {
        string lineInput;
        while ((lineInput = Console.ReadLine()) != null)
        {
            string[] fields = lineInput.Split(new char[] {'\t'});
            bool isFirstField = true;
            foreach (var item in fields)
            {
                if (isFirstField)
                    isFirstField = false;
                else
                    Console.Write(',');

                // If the field represents a boolean, replace with a numeric representation.
                bool itemBool;
                if (Boolean.TryParse(item, out itemBool))
                    Console.Write(Convert.ToByte(itemBool));
                else
                    Console.Write(item);
            }
            Console.WriteLine();
        }
    }
}

Remarques

La représentation textuelle de value est produite en appelant la méthode Int64.ToString.

Voir aussi

• Read()
• ReadLine()
• WriteLine()

Write(Decimal)

Source:

Console.cs

Écrit la représentation textuelle de la valeur Decimal spécifiée dans le flux de sortie standard.

C#

public static void Write (decimal value);

Paramètres

value

Decimal

Valeur à écrire.

Exceptions

IOException

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

Exemples

L’exemple suivant illustre l’utilisation de la méthode Write.

C#

public class FormatConverter
{
    public static void Main(string[] args)
    {
        string lineInput;
        while ((lineInput = Console.ReadLine()) != null)
        {
            string[] fields = lineInput.Split(new char[] {'\t'});
            bool isFirstField = true;
            foreach (var item in fields)
            {
                if (isFirstField)
                    isFirstField = false;
                else
                    Console.Write(',');

                // If the field represents a boolean, replace with a numeric representation.
                bool itemBool;
                if (Boolean.TryParse(item, out itemBool))
                    Console.Write(Convert.ToByte(itemBool));
                else
                    Console.Write(item);
            }
            Console.WriteLine();
        }
    }
}

Remarques

La représentation textuelle de value est produite en appelant Decimal.ToString.

Voir aussi

• Read()
• ReadLine()
• WriteLine()