C# Language
String.Format

introduzione

Sintassi

• string.Format (formato stringa, oggetto params [] args)
• string.Format (provider IFormatProvider, formato stringa, oggetto params [] args)
• $ "stringa {testo} blablabla" // Poiché C # 6

Parametri

Osservazioni

Luoghi in cui String.Format è "incorporato" nel framework

Esistono diversi punti in cui è possibile utilizzare String.Format indirettamente : il segreto è cercare il sovraccarico con il string format, params object[] args firma string format, params object[] args , ad esempio:

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

Può essere sostituito con una versione più corta:

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

Esistono altri metodi che usano anche String.Format ad esempio:

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

Utilizzando il formato numerico personalizzato

NumberFormatInfo può essere utilizzato per formattare sia numeri interi che numeri a virgola mobile.

// 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);

Creare un fornitore di formato personalizzato

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;
    }
}

Uso:

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

Produzione:

-> dlroW olleH <-

Allinea a sinistra / a destra, pad con spazi

Il secondo valore nelle parentesi graffe determina la lunghezza della stringa di sostituzione. Regolando il secondo valore come positivo o negativo, è possibile modificare l'allineamento della stringa.

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

Produzione:

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

Formati numerici

// 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);

Produzione:

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%

Formattazione della valuta

L'identificatore di formato "c" (o valuta) converte un numero in una stringa che rappresenta un importo in valuta.

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

Precisione

Il valore predefinito è 2. Usa c1, c2, c3 e così via per controllare la precisione.

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

Simbolo di valuta

1. Passa l'istanza di CultureInfo per usare il simbolo di cultura personalizzato.

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. Usa qualsiasi stringa come simbolo di valuta. Usa NumberFormatInfo per personalizzare il simbolo di valuta.

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

Posizione del simbolo di valuta

Utilizzare CurrencyPositivePattern per i valori positivi e CurrencyNegativePattern per i valori negativi.

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'utilizzo del pattern negativo è lo stesso del pattern positivo. Molto più casi d'uso si prega di fare riferimento al link originale.

Separatore decimale personalizzato

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

Dal momento che C # 6.0

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

Sfuggire parentesi graffe all'interno di un'espressione 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"

Formattazione della data

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}");

produzione :

06
Лхагва
06

Accordare()

Il metodo ToString () è presente su tutti i tipi di oggetti di riferimento. Ciò è dovuto al fatto che tutti i tipi di riferimento derivano da Object su cui è presente il metodo ToString (). Il metodo ToString () sulla classe base dell'oggetto restituisce il nome del tipo. Il frammento seguente stamperà "Utente" sulla 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());

Tuttavia, la classe User può anche sovrascrivere ToString () per modificare la stringa restituita. Il frammento di codice sottostante stampa "Id: 5, Name: User1" sulla 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());

Relazione con ToString ()

Mentre il metodo String.Format() è certamente utile per la formattazione dei dati come stringhe, può spesso essere un po 'eccessivo, specialmente quando si ha a che fare con un singolo oggetto come mostrato di seguito:

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

Un approccio più semplice potrebbe essere quello di utilizzare semplicemente il metodo ToString() disponibile su tutti gli oggetti all'interno di C #. Supporta tutte le stesse stringhe di formattazione standard e personalizzate , ma non richiede la mappatura dei parametri necessaria in quanto ci sarà un solo argomento:

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

Avvertenze e restrizioni alla formattazione

Sebbene questo approccio possa essere più semplice in alcuni scenari, l'approccio ToString() è limitato per quanto riguarda l'aggiunta del String.Format() sinistro o destro come si farebbe nel metodo String.Format() :

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

Per ottenere lo stesso comportamento con il metodo ToString() , è necessario utilizzare un altro metodo come PadLeft() o PadRight() rispettivamente:

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