Stringhe di formato numerico personalizzato

È possibile creare una stringa di formato numerico personalizzata costituita da uno o più identificatori numerici personalizzati, per definire la formattazione dei dati numerici. Una stringa di formato numerico personalizzata è qualsiasi stringa di formato che non è una stringa di formato numerico standard.

Le stringhe di formato numerico personalizzate sono supportate da alcuni overload del ToString metodo di tutti i tipi numerici. Ad esempio, è possibile fornire una stringa di formato numerico ai ToString(String) metodi e ToString(String, IFormatProvider) del Int32 tipo . Le stringhe di formato numerico personalizzate sono supportate anche dalla funzionalità di formattazione composita .NET, usata da alcuni Write metodi e WriteLine delle Console classi e StreamWriter , dal String.Format metodo e dal StringBuilder.AppendFormat metodo . La funzionalità di interpolazione di stringhe supporta anche stringhe di formato numerico personalizzate.

Nella tabella seguente vengono descritti gli identificatori di formato numerico personalizzati e viene visualizzato l'output di esempio prodotto da ogni identificatore di formato. Per altre informazioni sull'uso di stringhe di formato numerico personalizzate, vedere la sezione Note e la sezione Esempio per un'illustrazione completa dell'uso.

Nelle sezioni seguenti vengono fornite informazioni dettagliate su ognuno degli identificatori di formato numerico personalizzati.

Identificatore personalizzato "0"

L'identificatore di formato personalizzato "0" serve come simbolo di segnaposto zero. Se nel valore da formattare è presente una cifra nella posizione in cui nella stringa di formato si trova lo zero, tale cifra viene copiata nella stringa di risultato. In caso contrario, nella stringa di risultato viene visualizzato uno zero. La posizione dello zero più a sinistra prima del separatore decimale e quella dello zero più a destra dopo il separatore decimale determinano l'intervallo di cifre sempre presenti nella stringa di risultato.

L'identificatore "00" determina l'arrotondamento del valore alla cifra più vicina prima del decimale, in cui viene sempre usato l'arrotondamento a un valore diverso da zero. La formattazione di 34,5 con "00", ad esempio, restituisce come risultato il valore 35.

Nell'esempio seguente vengono visualizzati diversi valori formattati usando stringhe di formato personalizzate che includono segnaposto zero.

 double value;

 value = 123;
 Console.WriteLine(value.ToString("00000"));
 Console.WriteLine(String.Format("{0:00000}", value));
 // Displays 00123

 value = 1.2;
 Console.WriteLine(value.ToString("0.00", CultureInfo.InvariantCulture));
 Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
                   "{0:0.00}", value));
 // Displays 1.20

 Console.WriteLine(value.ToString("00.00", CultureInfo.InvariantCulture));
 Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
                                 "{0:00.00}", value));
 // Displays 01.20

 CultureInfo daDK = CultureInfo.CreateSpecificCulture("da-DK");
 Console.WriteLine(value.ToString("00.00", daDK));
 Console.WriteLine(String.Format(daDK, "{0:00.00}", value));
 // Displays 01,20

 value = .56;
 Console.WriteLine(value.ToString("0.0", CultureInfo.InvariantCulture));
 Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
                                 "{0:0.0}", value));
 // Displays 0.6

 value = 1234567890;
 Console.WriteLine(value.ToString("0,0", CultureInfo.InvariantCulture));	
 Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
                                 "{0:0,0}", value));	
 // Displays 1,234,567,890

 CultureInfo elGR = CultureInfo.CreateSpecificCulture("el-GR");
 Console.WriteLine(value.ToString("0,0", elGR));	
Console.WriteLine(String.Format(elGR, "{0:0,0}", value));	
 // Displays 1.234.567.890

 value = 1234567890.123456;
 Console.WriteLine(value.ToString("0,0.0", CultureInfo.InvariantCulture));	
 Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
                                 "{0:0,0.0}", value));	
 // Displays 1,234,567,890.1

 value = 1234.567890;
 Console.WriteLine(value.ToString("0,0.00", CultureInfo.InvariantCulture));	
 Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
                                 "{0:0,0.00}", value));	
 // Displays 1,234.57

Dim value As Double

value = 123
Console.WriteLine(value.ToString("00000"))
Console.WriteLine(String.Format("{0:00000}", value))
' Displays 00123

value = 1.2
Console.WriteLine(value.ToString("0.00", CultureInfo.InvariantCulture))
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
                  "{0:0.00}", value))
' Displays 1.20
Console.WriteLine(value.ToString("00.00", CultureInfo.InvariantCulture))
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
                                "{0:00.00}", value))
' Displays 01.20
Dim daDK As CultureInfo = CultureInfo.CreateSpecificCulture("da-DK")
Console.WriteLine(value.ToString("00.00", daDK))
Console.WriteLine(String.Format(daDK, "{0:00.00}", value))
' Displays 01,20

value = .56
Console.WriteLine(value.ToString("0.0", CultureInfo.InvariantCulture))
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
                                "{0:0.0}", value))
' Displays 0.6

value = 1234567890
Console.WriteLine(value.ToString("0,0", CultureInfo.InvariantCulture))
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
                                "{0:0,0}", value))
' Displays 1,234,567,890
Dim elGR As CultureInfo = CultureInfo.CreateSpecificCulture("el-GR")
Console.WriteLine(value.ToString("0,0", elGR))
Console.WriteLine(String.Format(elGR, "{0:0,0}", value))
' Displays 1.234.567.890

value = 1234567890.123456
Console.WriteLine(value.ToString("0,0.0", CultureInfo.InvariantCulture))
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
                                "{0:0,0.0}", value))
' Displays 1,234,567,890.1

value = 1234.567890
Console.WriteLine(value.ToString("0,0.00", CultureInfo.InvariantCulture))
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
                                "{0:0,0.00}", value))
' Displays 1,234.57

Torna alla tabella

Identificatore personalizzato "#"

L'identificatore di formato personalizzato "#" serve come simbolo di segnaposto per cifre. Se il valore da formattare ha una cifra nella posizione in cui si trova il simbolo "#" nella stringa di formato, tale cifra viene copiata nella stringa di risultato. In caso contrario, nella stringa di risultato non viene memorizzato alcun valore in tale posizione.

Si noti che questo identificatore non visualizza mai uno zero che non è una cifra significativa, anche se zero è l'unica cifra nella stringa. Verrà visualizzato zero solo se è una cifra significativa nel numero visualizzato.

La stringa di formato "##" determina l'arrotondamento del valore alla cifra più vicina prima del decimale, in cui viene sempre usato l'arrotondamento a un valore diverso da zero. La formattazione di 34,5 con "##", ad esempio, restituisce come risultato il valore 35.

Nell'esempio seguente vengono visualizzati diversi valori formattati usando stringhe di formato personalizzate che includono segnaposto per cifre.

double value;

value = 1.2;
Console.WriteLine(value.ToString("#.##", CultureInfo.InvariantCulture));
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
                                "{0:#.##}", value));
// Displays 1.2

value = 123;
Console.WriteLine(value.ToString("#####"));
Console.WriteLine(String.Format("{0:#####}", value));
// Displays 123

value = 123456;
Console.WriteLine(value.ToString("[##-##-##]"));
Console.WriteLine(String.Format("{0:[##-##-##]}", value));
 // Displays [12-34-56]

value = 1234567890;
Console.WriteLine(value.ToString("#"));
Console.WriteLine(String.Format("{0:#}", value));
// Displays 1234567890

Console.WriteLine(value.ToString("(###) ###-####"));
Console.WriteLine(String.Format("{0:(###) ###-####}", value));
// Displays (123) 456-7890

Dim value As Double

value = 1.2
Console.WriteLine(value.ToString("#.##", CultureInfo.InvariantCulture))
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
                                "{0:#.##}", value))
' Displays 1.2

value = 123
Console.WriteLine(value.ToString("#####"))
Console.WriteLine(String.Format("{0:#####}", value))
' Displays 123

value = 123456
Console.WriteLine(value.ToString("[##-##-##]"))
Console.WriteLine(String.Format("{0:[##-##-##]}", value))
' Displays [12-34-56]

value = 1234567890
Console.WriteLine(value.ToString("#"))
Console.WriteLine(String.Format("{0:#}", value))
' Displays 1234567890

Console.WriteLine(value.ToString("(###) ###-####"))
Console.WriteLine(String.Format("{0:(###) ###-####}", value))
' Displays (123) 456-7890

Per restituire una stringa di risultato in cui le cifre assenti o gli zeri iniziali vengono sostituite da spazi, utilizzare la funzionalità di formattazione composita e specificare una larghezza del campo, come illustrato nell'esempio seguente.

using System;

public class SpaceOrDigit
{
   public static void Main()
   {
      Double value = .324;
      Console.WriteLine("The value is: '{0,5:#.###}'", value);
   }
}
// The example displays the following output if the current culture
// is en-US:
//      The value is: ' .324'

Module SpaceExample
    Public Sub Main()
        Dim value As Double = 0.324
        Console.WriteLine("The value is: '{0,5:#.###}'", value)
    End Sub
End Module

' The example displays the following output if the current culture
' is en-US:
'      The value is: ' .324'

Torna alla tabella

Identificatore personalizzato "."

L'identificatore di formato personalizzato "." inserisce un separatore decimale localizzato nella stringa di risultato. Il primo carattere punto nella stringa di formato determina la posizione del separatore decimale nel valore formattato. Eventuali punti aggiuntivi vengono ignorati. Se l'identificatore di formato termina con un valore "." solo le cifre significative vengono formattate nella stringa di risultato.

Il carattere utilizzato come separatore decimale nella stringa di risultato non è sempre un punto; è determinato dalla NumberDecimalSeparator proprietà dell'oggetto NumberFormatInfo che controlla la formattazione.

Nell'esempio seguente viene usato l'identificatore di formato "." per definire la posizione del separatore decimale in alcune stringhe di risultato.

double value;

value = 1.2;
Console.WriteLine(value.ToString("0.00", CultureInfo.InvariantCulture));
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
                                "{0:0.00}", value));
// Displays 1.20

Console.WriteLine(value.ToString("00.00", CultureInfo.InvariantCulture));
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
                                "{0:00.00}", value));
// Displays 01.20

Console.WriteLine(value.ToString("00.00",
                  CultureInfo.CreateSpecificCulture("da-DK")));
Console.WriteLine(String.Format(CultureInfo.CreateSpecificCulture("da-DK"),
                  "{0:00.00}", value));
// Displays 01,20

value = .086;
Console.WriteLine(value.ToString("#0.##%", CultureInfo.InvariantCulture));
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
                                "{0:#0.##%}", value));
// Displays 8.6%

value = 86000;
Console.WriteLine(value.ToString("0.###E+0", CultureInfo.InvariantCulture));
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
                  "{0:0.###E+0}", value));
 // Displays 8.6E+4

Dim value As Double

value = 1.2
Console.WriteLine(value.ToString("0.00", CultureInfo.InvariantCulture))
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
                                "{0:0.00}", value))
' Displays 1.20

Console.WriteLine(value.ToString("00.00", CultureInfo.InvariantCulture))
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
                                "{0:00.00}", value))
' Displays 01.20

Console.WriteLine(value.ToString("00.00", _
                  CultureInfo.CreateSpecificCulture("da-DK")))
Console.WriteLine(String.Format(CultureInfo.CreateSpecificCulture("da-DK"),
                  "{0:00.00}", value))
' Displays 01,20

value = .086
Console.WriteLine(value.ToString("#0.##%", CultureInfo.InvariantCulture))
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
                                "{0:#0.##%}", value))
' Displays 8.6%

value = 86000
Console.WriteLine(value.ToString("0.###E+0", CultureInfo.InvariantCulture))
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
                  "{0:0.###E+0}", value))
' Displays 8.6E+4

Torna alla tabella

Identificatore personalizzato ","

Il carattere "," viene usato sia come separatore di gruppi che come identificatore di rappresentazione in scala dei numeri.

• Separatore di gruppi: se vengono specificate una o più virgole tra due segnaposto per cifre (0 o #) che formattano le cifre integrali di un numero, viene inserito un carattere di separazione di gruppi tra ogni gruppo di numeri nella parte integrale dell'output.

  Le NumberGroupSeparator proprietà e NumberGroupSizes dell'oggetto corrente NumberFormatInfo determinano il carattere utilizzato come separatore del gruppo di numeri e le dimensioni di ogni gruppo di numeri. Se ad esempio vengono usate la stringa "#, #" e le impostazioni cultura invarianti per formattare il numero 1000, l'output sarà "1,000".

• Identificatore di rappresentazione in scala dei numeri: se vengono specificate una o più virgole immediatamente a sinistra del separatore decimale esplicito o implicito, il numero da formattare viene diviso per 1000 per ogni virgola presente. Se ad esempio viene usata la stringa "0" per formattare il numero 100 milioni, l'output sarà "100".

È possibile usare gli identificatori del separatore di gruppi e di rappresentazione in scala dei numeri nella stessa stringa di formato. Se ad esempio vengono usate la stringa "#,0,," e le impostazioni cultura invarianti per formattare il numero un miliardo, l'output sarà "1,000".

Nell'esempio seguente viene illustrato l'utilizzo della virgola come separatore di gruppi.

double value = 1234567890;
Console.WriteLine(value.ToString("#,#", CultureInfo.InvariantCulture));
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
                                "{0:#,#}", value));
// Displays 1,234,567,890

Console.WriteLine(value.ToString("#,##0,,", CultureInfo.InvariantCulture));
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
                                "{0:#,##0,,}", value));
// Displays 1,235      	

Dim value As Double = 1234567890
Console.WriteLine(value.ToString("#,#", CultureInfo.InvariantCulture))
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
                                "{0:#,#}", value))
' Displays 1,234,567,890

Console.WriteLine(value.ToString("#,##0,,", CultureInfo.InvariantCulture))
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
                                "{0:#,##0,,}", value))
' Displays 1,235

Nell'esempio seguente viene illustrato l'utilizzo della virgola come identificatore di rappresentazione in scala.

double value = 1234567890;
Console.WriteLine(value.ToString("#,,", CultureInfo.InvariantCulture));	
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
                                "{0:#,,}", value));	
// Displays 1235

Console.WriteLine(value.ToString("#,,,", CultureInfo.InvariantCulture));
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
                                "{0:#,,,}", value));
// Displays 1

Console.WriteLine(value.ToString("#,##0,,", CultureInfo.InvariantCulture));
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
                                "{0:#,##0,,}", value));
// Displays 1,235

Dim value As Double = 1234567890
Console.WriteLine(value.ToString("#,,", CultureInfo.InvariantCulture))
Console.WriteLine(String.Format(CultureInfo.InvariantCulture, "{0:#,,}", value))
' Displays 1235

Console.WriteLine(value.ToString("#,,,", CultureInfo.InvariantCulture))
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
                                "{0:#,,,}", value))
' Displays 1

Console.WriteLine(value.ToString("#,##0,,", CultureInfo.InvariantCulture))
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
                                "{0:#,##0,,}", value))
' Displays 1,235

Torna alla tabella

Identificatore personalizzato "%"

Un segno di percentuale (%) in una stringa di formato fa sì che un numero venga moltiplicato per 100 prima che venga formattato. Il simbolo di percentuale localizzato viene inserito nel numero stesso nella posizione in cui è stato inserito il segno % nella stringa di formato. Il carattere percentuale utilizzato è definito dalla PercentSymbol proprietà dell'oggetto corrente NumberFormatInfo .

Nell'esempio seguente vengono definite diverse stringhe di formato personalizzate che includono l'identificatore personalizzato "%".

double value = .086;
Console.WriteLine(value.ToString("#0.##%", CultureInfo.InvariantCulture));
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
                                "{0:#0.##%}", value));
// Displays 8.6%

Dim value As Double = .086
Console.WriteLine(value.ToString("#0.##%", CultureInfo.InvariantCulture))
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
                                "{0:#0.##%}", value))
' Displays 8.6%

Torna alla tabella

Identificatore personalizzato "‰"

Un carattere per mille (™ o \u2030) in una stringa di formato fa sì che un numero venga moltiplicato per 1000 prima che venga formattato. Il simbolo per mille appropriato viene inserito nella stringa restituita nella posizione in cui è stato inserito il simbolo ‰ nella stringa di formato. Il carattere per mille utilizzato è definito dalla NumberFormatInfo.PerMilleSymbol proprietà dell'oggetto che fornisce informazioni di formattazione specifiche delle impostazioni cultura.

Nell'esempio seguente viene definita una stringa di formato personalizzata che include l'identificatore personalizzato "‰".

double value = .00354;
string perMilleFmt = "#0.## " + '\u2030';
Console.WriteLine(value.ToString(perMilleFmt, CultureInfo.InvariantCulture));
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
                                "{0:" + perMilleFmt + "}", value));
// Displays 3.54‰

Dim value As Double = .00354
Dim perMilleFmt As String = "#0.## " & ChrW(&h2030)
Console.WriteLine(value.ToString(perMilleFmt, CultureInfo.InvariantCulture))
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
                                "{0:" + perMilleFmt + "}", value))
' Displays 3.54 ‰

Torna alla tabella

Identificatori personalizzati "E" ed "e"

Se nella stringa di formato è presente una delle stringhe "E", "E+", "E-", "e", "e+" o "e-" immediatamente seguita da almeno uno zero, il numero viene formattato usando la notazione scientifica con una "E" o "e" inserita tra il numero e l'esponente. Il numero di zeri che seguono l'indicatore della notazione scientifica determina il numero minimo di cifre da visualizzare nell'output per l'esponente. I formati "E+" ed "e+" indicano che l'esponente deve essere sempre preceduto da un segno più o meno. I formati "E", "E-", "e" ed "e-" indicano che solo gli esponenti negativi devono essere preceduti da un carattere di segno.

Nell'esempio seguente vengono formattati alcuni valori numerici usando gli identificatori per notazione scientifica.

double value = 86000;
Console.WriteLine(value.ToString("0.###E+0", CultureInfo.InvariantCulture));
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
                                "{0:0.###E+0}", value));
// Displays 8.6E+4

Console.WriteLine(value.ToString("0.###E+000", CultureInfo.InvariantCulture));
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
                                "{0:0.###E+000}", value));
// Displays 8.6E+004

Console.WriteLine(value.ToString("0.###E-000", CultureInfo.InvariantCulture));
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
                                "{0:0.###E-000}", value));
// Displays 8.6E004

Dim value As Double = 86000
Console.WriteLine(value.ToString("0.###E+0", CultureInfo.InvariantCulture))
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
                                "{0:0.###E+0}", value))
' Displays 8.6E+4

Console.WriteLine(value.ToString("0.###E+000", CultureInfo.InvariantCulture))
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
                                "{0:0.###E+000}", value))
' Displays 8.6E+004

Console.WriteLine(value.ToString("0.###E-000", CultureInfo.InvariantCulture))
Console.WriteLine(String.Format(CultureInfo.InvariantCulture,
                                "{0:0.###E-000}", value))
' Displays 8.6E004

Torna alla tabella

Carattere di escape "\"

I simboli "#", "0", ".", ",", "%" e "‰" in una stringa di formato vengono interpretati come identificatori di formato anziché come caratteri letterali. A seconda della posizione in una stringa di formato personalizzata, i simboli maiuscoli e minuscoli "E" e + e - possono anche essere interpretati come identificatori di formato.

Per impedire che un carattere venga interpretato come identificatore di formato, è possibile precederlo con una barra rovesciata, ovvero il carattere di escape. Il carattere di escape indica che il carattere seguente è un valore letterale carattere che deve essere incluso nella stringa di risultato senza modifiche.

Per includere una barra rovesciata in una stringa dei risultati, è necessario aggiungere un carattere di escape facendolo quindi precedere da un'altra barra rovesciata (\\).

Nell'esempio seguente viene utilizzato il carattere di escape per impedire all'operazione di formattazione di interpretare i caratteri "#", "0" e "\" come caratteri di escape o identificatori di formato. Gli esempi C# usano una barra rovesciata aggiuntiva per garantire che una barra rovesciata venga interpretata come carattere letterale.

int value = 123;
Console.WriteLine(value.ToString("\\#\\#\\# ##0 dollars and \\0\\0 cents \\#\\#\\#"));
Console.WriteLine(String.Format("{0:\\#\\#\\# ##0 dollars and \\0\\0 cents \\#\\#\\#}",
                                value));
// Displays ### 123 dollars and 00 cents ###

Console.WriteLine(value.ToString(@"\#\#\# ##0 dollars and \0\0 cents \#\#\#"));
Console.WriteLine(String.Format(@"{0:\#\#\# ##0 dollars and \0\0 cents \#\#\#}",
                                value));
// Displays ### 123 dollars and 00 cents ###

Console.WriteLine(value.ToString("\\\\\\\\\\\\ ##0 dollars and \\0\\0 cents \\\\\\\\\\\\"));
Console.WriteLine(String.Format("{0:\\\\\\\\\\\\ ##0 dollars and \\0\\0 cents \\\\\\\\\\\\}",
                                value));
// Displays \\\ 123 dollars and 00 cents \\\

Console.WriteLine(value.ToString(@"\\\\\\ ##0 dollars and \0\0 cents \\\\\\"));
Console.WriteLine(String.Format(@"{0:\\\\\\ ##0 dollars and \0\0 cents \\\\\\}",
                                value));
// Displays \\\ 123 dollars and 00 cents \\\

Dim value As Integer = 123
Console.WriteLine(value.ToString("\#\#\# ##0 dollars and \0\0 cents \#\#\#"))
Console.WriteLine(String.Format("{0:\#\#\# ##0 dollars and \0\0 cents \#\#\#}",
                                value))
' Displays ### 123 dollars and 00 cents ###

Console.WriteLine(value.ToString("\\\\\\ ##0 dollars and \0\0 cents \\\\\\"))
Console.WriteLine(String.Format("{0:\\\\\\ ##0 dollars and \0\0 cents \\\\\\}",
                                value))
' Displays \\\ 123 dollars and 00 cents \\\

Torna alla tabella

Separatore di sezione ";"

Il punto e virgola (;) è un identificatore di formato condizionale che applica una formattazione diversa a un numero, a seconda del fatto che il suo valore sia positivo, negativo o zero. A tale scopo, una stringa di formato personalizzata può contenere un massimo di tre sezioni separate da punti e virgola. Queste sezioni sono descritte nella tabella seguente.

Con i separatori di sezione, quando viene formattato il valore finale viene ignorata qualsiasi formattazione preesistente associata a un numero. Quando vengono usati separatori di sezione, ad esempio, i numeri negativi vengono sempre visualizzati senza segno meno. Se si desidera che il valore formattato finale disponga di un segno meno, è opportuno includere il segno meno in modo esplicito nell'ambito dell'identificatore di formato personalizzato.

Nell'esempio seguente viene usato l'identificatore di formato ";" per formattare numeri positivi, negativi e zero in modo diverso.

double posValue = 1234;
double negValue = -1234;
double zeroValue = 0;

string fmt2 = "##;(##)";
string fmt3 = "##;(##);**Zero**";

Console.WriteLine(posValue.ToString(fmt2));
Console.WriteLine(String.Format("{0:" + fmt2 + "}", posValue));
// Displays 1234

Console.WriteLine(negValue.ToString(fmt2));
Console.WriteLine(String.Format("{0:" + fmt2 + "}", negValue));
// Displays (1234)

Console.WriteLine(zeroValue.ToString(fmt3));
Console.WriteLine(String.Format("{0:" + fmt3 + "}", zeroValue));
// Displays **Zero**

Dim posValue As Double = 1234
Dim negValue As Double = -1234
Dim zeroValue As Double = 0

Dim fmt2 As String = "##;(##)"
Dim fmt3 As String = "##;(##);**Zero**"

Console.WriteLine(posValue.ToString(fmt2))
Console.WriteLine(String.Format("{0:" + fmt2 + "}", posValue))
' Displays 1234

Console.WriteLine(negValue.ToString(fmt2))
Console.WriteLine(String.Format("{0:" + fmt2 + "}", negValue))
' Displays (1234)

Console.WriteLine(zeroValue.ToString(fmt3))
Console.WriteLine(String.Format("{0:" + fmt3 + "}", zeroValue))
' Displays **Zero**

Torna alla tabella

Letterali di carattere

Gli identificatori di formato presenti in una stringa di formato numerico personalizzato vengono sempre interpretati come caratteri di formattazione e mai come caratteri letterali. Sono inclusi i caratteri seguenti:

• 0
• #
• %
• ‰
• '
• \
• .
• ,
• E o e, a seconda della posizione nella stringa di formato.

Tutti gli altri caratteri vengono sempre interpretati come valori letterali carattere e in un'operazione di formattazione vengono inclusi senza modifiche nella stringa di risultato. In un'operazione di analisi questi caratteri devono corrispondere esattamente ai caratteri nella stringa di input. Il confronto tiene conto di maiuscole e minuscole.

L'esempio seguente illustra un uso comune di unità di carattere letterale (in questo caso migliaia):

double n = 123.8;
Console.WriteLine($"{n:#,##0.0K}");
// The example displays the following output:
//      123.8K

Dim n As Double = 123.8
Console.WriteLine($"{n:#,##0.0K}")
' The example displays the following output:
'       123.8K

Esistono due modi per indicare che determinati caratteri devono essere interpretati come caratteri letterali e non come caratteri di formattazione, in modo da includerli in una stringa di risultato o eseguirne l'analisi in una stringa di input:

• Usando un carattere di escape per un carattere di formattazione. Per altre informazioni, vedere Carattere di escape "\".

• Racchiudendo l'intera stringa letterale tra apostrofi.

L'esempio seguente usa entrambi gli approcci per includere i caratteri riservati in una stringa di formato numerico personalizzato.

double n = 9.3;
Console.WriteLine($@"{n:##.0\%}");
Console.WriteLine($@"{n:\'##\'}");
Console.WriteLine($@"{n:\\##\\}");
Console.WriteLine();
Console.WriteLine($"{n:##.0'%'}");
Console.WriteLine($@"{n:'\'##'\'}");
// The example displays the following output:
//      9.3%
//      '9'
//      \9\
//
//      9.3%
//      \9\

Dim n As Double = 9.3
Console.WriteLine($"{n:##.0\%}")
Console.WriteLine($"{n:\'##\'}")
Console.WriteLine($"{n:\\##\\}")
Console.WriteLine()
Console.WriteLine($"{n:##.0'%'}")
Console.WriteLine($"{n:'\'##'\'}")
' The example displays the following output:
'      9.3%
'      '9'
'      \9\
'
'      9.3%
'      \9\

Note

Valori infiniti a virgola mobile e NaN

Indipendentemente dalla stringa di formato, se il valore di un tipo a Singlevirgola mobile , o Double è infinito positivo, infinito negativo o non un numero (NaN), la stringa formattata è il valore della rispettiva PositiveInfinitySymbolproprietà , NegativeInfinitySymbolo NaNSymbol specificata dall'oggetto attualmente applicabileNumberFormatInfo.Half

Impostazioni del Pannello di controllo

Le impostazioni nell'elemento Opzioni internazionali e linguistiche nel Pannello di controllo influenzano la stringa di risultato prodotta da un'operazione di formattazione. Tali impostazioni vengono utilizzate per inizializzare l'oggetto NumberFormatInfo associato alle impostazioni cultura correnti e le impostazioni cultura correnti forniscono valori usati per gestire la formattazione. I computer che usano impostazioni diverse generano stringhe di risultati diverse.

Inoltre, se si usa il CultureInfo(String) costruttore per creare un'istanza di un nuovo CultureInfo oggetto che rappresenta le stesse impostazioni cultura delle impostazioni cultura di sistema correnti, tutte le personalizzazioni stabilite dall'elemento Opzioni internazionali e linguistiche nel Pannello di controllo verranno applicate al nuovo CultureInfo oggetto. È possibile utilizzare il CultureInfo(String, Boolean) costruttore per creare un CultureInfo oggetto che non riflette le personalizzazioni di un sistema.

Arrotondamento e stringhe di formato a virgola fissa

Per le stringhe di formato a virgola fissa( ovvero le stringhe di formato di formato non scientifico), i numeri vengono arrotondati a quante cifre decimali ci sono segnaposto a destra del separatore decimale. Se la stringa di formato non contiene un separatore decimale, il numero viene arrotondato all'intero più vicino. Se le cifre del numero sono più numerose dei segnaposto per le cifre riportati a sinistra del separatore decimale, le cifre eccedenti vengono copiate nella stringa di risultato immediatamente prima del primo segnaposto per le cifre.

Torna alla tabella

Esempio

Nell'esempio seguente vengono illustrate due stringhe di formato numerico personalizzate. In entrambi i casi il segnaposto per le cifre (#) consente di visualizzare i dati numerici e tutti gli altri caratteri vengono copiati nella stringa di risultato.

double number1 = 1234567890;
string value1 = number1.ToString("(###) ###-####");
Console.WriteLine(value1);

int number2 = 42;
string value2 = number2.ToString("My Number = #");
Console.WriteLine(value2);
// The example displays the following output:
//       (123) 456-7890
//       My Number = 42

Dim number1 As Double = 1234567890
Dim value1 As String = number1.ToString("(###) ###-####")
Console.WriteLine(value1)

Dim number2 As Integer = 42
Dim value2 As String = number2.ToString("My Number = #")
Console.WriteLine(value2)
' The example displays the following output:
'       (123) 456-7890
'       My Number = 42

Torna alla tabella

Vedere anche

• System.Globalization.NumberFormatInfo
• Tipi di formattazione
• Stringhe di formato numerico standard
• Procedura: Aggiungere un numero con zeri iniziali
• Esempio: Utilità di formattazione WinForms .NET Core (C#)
• Esempio: Utilità di formattazione WinForms di .NET Core (Visual Basic)