C# Language
String.Format

Introduction

Syntaxe

• string.Format (format de chaîne, params object [] args)
• string.Format (fournisseur IFormatProvider, format de chaîne, paramètres params [] args)
• $ "string {text} blablabla" // Depuis C # 6

Paramètres

Remarques

Endroits où String.Format est "incorporé" dans la structure

Il y a plusieurs endroits où vous pouvez utiliser String.Format indirectement : Le secret est de rechercher la surcharge avec le string format, params object[] args signature string format, params object[] args , par exemple:

Console.WriteLine(String.Format("{0} - {1}", name, value));

Peut être remplacé par une version plus courte:

Console.WriteLine("{0} - {1}", name, value);

Il existe d'autres méthodes qui utilisent également String.Format par exemple:

Debug.WriteLine(); // and Print()
StringBuilder.AppendFormat();

Utilisation du format numérique personnalisé

NumberFormatInfo peut être utilisé pour formater des nombres entiers et flottants.

// invariantResult is "1,234,567.89"
var invarianResult = string.Format(CultureInfo.InvariantCulture, "{0:#,###,##}", 1234567.89);

// NumberFormatInfo is one of classes that implement IFormatProvider
var customProvider = new NumberFormatInfo
{
    NumberDecimalSeparator = "_NS_", // will be used instead of ','
    NumberGroupSeparator = "_GS_", // will be used instead of '.'
};

// customResult is "1_GS_234_GS_567_NS_89"
var customResult = string.Format(customProvider, "{0:#,###.##}", 1234567.89);

Créer un fournisseur de format personnalisé

public class CustomFormat : IFormatProvider, ICustomFormatter
{
    public string Format(string format, object arg, IFormatProvider formatProvider)
    {
        if (!this.Equals(formatProvider))
        {
            return null;
        }

        if (format == "Reverse")
        {
            return String.Join("", arg.ToString().Reverse());
        }

        return arg.ToString();
    }

    public object GetFormat(Type formatType)
    {
        return formatType==typeof(ICustomFormatter) ? this:null;
    }
}

Usage:

String.Format(new CustomFormat(), "-> {0:Reverse} <-", "Hello World");

Sortie:

-> dlroW olleH <-

Aligner à gauche / à droite, pad avec des espaces

La deuxième valeur dans les accolades indique la longueur de la chaîne de remplacement. En ajustant la deuxième valeur pour qu'elle soit positive ou négative, l'alignement de la chaîne peut être modifié.

string.Format("LEFT:  string: ->{0,-5}<- int: ->{1,-5}<-", "abc", 123);
string.Format("RIGHT: string: ->{0,5}<- int: ->{1,5}<-", "abc", 123);

Sortie:

LEFT:  string: ->abc  <- int: ->123  <-
RIGHT: string: ->  abc<- int: ->  123<-

Formats numériques

// Integral types as hex
string.Format("Hexadecimal: byte2: {0:x2}; byte4: {0:X4}; char: {1:x2}", 123, (int)'A');

// Integers with thousand separators
string.Format("Integer, thousand sep.: {0:#,#}; fixed length: >{0,10:#,#}<", 1234567);

// Integer with leading zeroes
string.Format("Integer, leading zeroes: {0:00}; ", 1);

// Decimals
string.Format("Decimal, fixed precision: {0:0.000}; as percents: {0:0.00%}", 0.12);

Sortie:

Hexadecimal: byte2: 7b; byte4: 007B; char: 41
Integer, thousand sep.: 1,234,567; fixed length: > 1,234,567<
Integer, leading zeroes: 01; 
Decimal, fixed precision: 0.120; as percents: 12.00%

Mise en forme de devise

Le spécificateur de format "c" (ou devise) convertit un nombre en une chaîne représentant un montant en devise.

string.Format("{0:c}", 112.236677) // $112.23 - defaults to system

Précision

La valeur par défaut est 2. Utilisez c1, c2, c3, etc. pour contrôler la précision.

string.Format("{0:C1}", 112.236677) //$112.2
string.Format("{0:C3}", 112.236677) //$112.237
string.Format("{0:C4}", 112.236677) //$112.2367
string.Format("{0:C9}", 112.236677) //$112.236677000

Symbole de la monnaie

1. Passez l'instance de CultureInfo pour utiliser le symbole de culture personnalisé.

string.Format(new CultureInfo("en-US"), "{0:c}", 112.236677); //$112.24
string.Format(new CultureInfo("de-DE"), "{0:c}", 112.236677); //112,24 €
string.Format(new CultureInfo("hi-IN"), "{0:c}", 112.236677); //₹ 112.24

2. Utilisez n'importe quelle chaîne comme symbole de devise. Utilisez NumberFormatInfo pour personnaliser le symbole monétaire.

NumberFormatInfo nfi = new CultureInfo( "en-US", false ).NumberFormat;
nfi = (NumberFormatInfo) nfi.Clone();
nfi.CurrencySymbol = "?";
string.Format(nfi, "{0:C}", 112.236677); //?112.24
nfi.CurrencySymbol = "?%^&";
string.Format(nfi, "{0:C}", 112.236677); //?%^&112.24

Position du symbole monétaire

Utilisez CurrencyPositivePattern pour les valeurs positives et CurrencyNegativePattern pour les valeurs négatives.

NumberFormatInfo nfi = new CultureInfo( "en-US", false ).NumberFormat;        
nfi.CurrencyPositivePattern = 0;
string.Format(nfi, "{0:C}", 112.236677); //$112.24 - default
nfi.CurrencyPositivePattern = 1;
string.Format(nfi, "{0:C}", 112.236677); //112.24$
nfi.CurrencyPositivePattern = 2;
string.Format(nfi, "{0:C}", 112.236677); //$ 112.24
nfi.CurrencyPositivePattern = 3; 
string.Format(nfi, "{0:C}", 112.236677); //112.24 $

L'utilisation d'un motif négatif est identique à un motif positif. Beaucoup plus de cas d'utilisation s'il vous plaît se référer au lien original.

Séparateur décimal personnalisé

NumberFormatInfo nfi = new CultureInfo( "en-US", false ).NumberFormat;        
nfi.CurrencyPositivePattern = 0;
nfi.CurrencyDecimalSeparator = "..";
string.Format(nfi, "{0:C}", 112.236677); //$112..24

Depuis C # 6.0

string name = "John";
string lastname = "Doe";
Console.WriteLine($"Hello {name} {lastname}!");

Echappement des accolades dans une expression String.Format ()

string outsidetext = "I am outside of bracket";
string.Format("{{I am in brackets!}} {0}", outsidetext);

//Outputs "{I am in brackets!} I am outside of bracket"

Formatage de date

DateTime date = new DateTime(2016, 07, 06, 18, 30, 14);
// Format: year, month, day hours, minutes, seconds

Console.Write(String.Format("{0:dd}",date)); 

//Format by Culture info
String.Format(new System.Globalization.CultureInfo("mn-MN"),"{0:dddd}",date);

Console.Write($"{date:ddd}");

sortie:

06
Лхагва
06

ToString ()

La méthode ToString () est présente sur tous les types d’objets de référence. Cela est dû au fait que tous les types de référence sont dérivés de Object qui a la méthode ToString (). La méthode ToString () sur la classe de base de l'objet renvoie le nom du type. Le fragment ci-dessous imprimera "Utilisateur" sur la console.

public class User
{
    public string Name { get; set; }
    public int Id { get; set; }
}

...

var user = new User {Name = "User1", Id = 5};
Console.WriteLine(user.ToString());

Cependant, la classe User peut également remplacer ToString () afin de modifier la chaîne renvoyée. Le fragment de code ci-dessous affiche "Id: 5, Name: User1" sur la console.

public class User
{
    public string Name { get; set; }
    public int Id { get; set; }
    public override ToString()
    {
        return string.Format("Id: {0}, Name: {1}", Id, Name);
    }
}

...

var user = new User {Name = "User1", Id = 5};
Console.WriteLine(user.ToString());

Relation avec ToString ()

Bien que la méthode String.Format() soit certainement utile pour formater des données sous forme de chaînes, cela peut souvent être un peu exagéré, en particulier lorsque vous travaillez avec un seul objet, comme indiqué ci-dessous:

String.Format("{0:C}", money);  // yields "$42.00"

Une approche plus simple pourrait être d'utiliser simplement la méthode ToString() disponible sur tous les objets de C #. Il prend en charge toutes les mêmes chaînes de formatage standard et personnalisées , mais ne nécessite pas le mappage de paramètres nécessaire, car il n'y aura qu'un seul argument:

money.ToString("C");  // yields "$42.00"

Restrictions relatives aux mises en garde et au formatage

Bien que cette approche soit peut-être plus simple dans certains scénarios, l’approche ToString() est limitée en ce qui concerne l’ajout de padding à gauche ou à droite comme vous le feriez dans la méthode String.Format() :

String.Format("{0,10:C}", money);  // yields "    $42.00"

Pour accomplir ce même comportement avec la méthode ToString() , vous devez utiliser une autre méthode comme PadLeft() ou PadRight() respectivement:

money.ToString("C").PadLeft(10);  // yields "    $42.00"