String.Format

Il Format i metodi sono un insieme di overload nel System.String classe utilizzata per creare stringhe che combinano oggetti in rappresentazioni di stringhe specifiche. Queste informazioni possono essere applicate a String.Format , vari WriteLine metodi così come altri metodi nel framework .NET.

# Dal C# 6.0

Da C# 6.0 è possibile utilizzare l'interpolazione di stringhe al posto di String.Format .

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

Ciao John Doe!

^{Altri esempi per questo nell'argomento Funzionalità di C# 6.0:Interpolazione di stringhe .}

# Luoghi in cui String.Format è 'incorporato' nel framework

Ci sono diversi posti in cui puoi usare String.Format indirettamente :Il segreto è cercare l'overload con la 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);

Ci sono altri metodi che usano anche String.Format es.:

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

# Crea un fornitore di formati 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;
    }
}

Utilizzo:

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

Uscita:

-> dlroW olleH <-

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

uscita :

06
Лхагва
06

# Formattazione 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 CultureInfo istanza per utilizzare il simbolo delle impostazioni cultura personalizzate.

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

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

Usa CurrencyPositivePattern per valori positivi e CurrencyNegativePattern per 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 modello negativo è lo stesso del modello positivo. Molti altri 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

# Utilizzo del formato numerico personalizzato

NumberFormatInfo può essere utilizzato per formattare sia numeri interi che float.

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

# Allinea sinistra/destra, riempi con spazi

Il secondo valore tra parentesi graffe determina la lunghezza della stringa sostitutiva. Regolando il secondo valore in modo che sia 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);

Uscita:

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

Uscita:

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%

# Espressione di 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"

# ToString()

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 che contiene 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 che restituisce. Il frammento di codice seguente 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 String.Format() è sicuramente utile nella formattazione dei dati come stringhe, spesso può 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 ToString() metodo 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 poiché ci sarà un solo argomento:

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

# Avvertenze e restrizioni di formattazione

Sebbene questo approccio possa essere più semplice in alcuni scenari, il ToString() l'approccio è limitato per quanto riguarda l'aggiunta di padding sinistro o destro come potresti fare all'interno del String.Format() metodo :

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

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

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

# Sintassi

• string.Format(formato stringa, parametri oggetto[] args)
• string.Format(provider IFormatProvider, formato stringa, parametri oggetto[] args)
• $"string {text} blablabla" // Dal C#6

# parametri

# Osservazioni

Note:

• String.Format() gestisce null argomenti senza generare un'eccezione.
• Ci sono sovraccarichi che sostituiscono il args parametro con uno, due o tre parametri oggetto.