Condividi tramite

Stringhe di formato numerico standard

  • Articolo

Le stringhe di formato numerico standard vengono usate per formattare tipi numerici comuni. Una stringa di formato numerico standard usa il formato [format specifier][precision specifier], dove:

  • L'identificatore di formato è un singolo carattere alfabetico che specifica il tipo di formato numerico, ad esempio valuta o percentuale. Le stringhe di formato numerico contenenti più caratteri alfabetici, inclusi gli spazi, vengono interpretate come stringhe di formato numerico personalizzate. Per altre informazioni, vedere Stringhe di formato numerico personalizzate.

  • L'identificatore di precisione è un numero intero facoltativo che influisce sul numero di cifre nella stringa risultante. In .NET 7 e versioni successive il valore di precisione massima è 999.999.999. In .NET 6 il valore di precisione massima è Int32.MaxValue. Nelle versioni precedenti di .NET la precisione può variare da 0 a 99. L'identificatore di precisione controlla il numero di cifre nella rappresentazione di stringa di un numero. Non arrotonda il numero stesso. Per eseguire un'operazione di arrotondamento, usare il metodo Math.Ceiling, Math.Floor o Math.Round.

    Quando l'identificatore di precisione controlla il numero di cifre frazionali nella stringa del risultato, quest'ultima riflette un numero arrotondato al risultato rappresentabile più vicino al risultato con precisione all'infinito. In presenza di due risultati rappresentabili equivalenti:

    • In .NET Framework e .NET Core fino a .NET Core 2.0, il runtime seleziona il risultato con la cifra meno significativa , ovvero usando MidpointRounding.AwayFromZero.
    • In .NET Core 2.1 e versioni successive il runtime seleziona il risultato con una cifra meno significativa pari, ovvero usando MidpointRounding.ToEven.

    Nota

    L'identificatore di precisione determina il numero di cifre nella stringa risultato. Per riempire una stringa risultato con spazi iniziali o finali, usare la funzionalità di formattazione composita e definire un componente allineamento nell'elemento di formato.

Le stringhe di formato numerico standard sono supportate:

Suggerimento

È possibile scaricare l'utilità di formattazione, un'applicazione .NET Core Windows Forms che consente di applicare stringhe di formato a valori numerici o di data e ora e di visualizzare la stringa di risultato. Il codice sorgente è disponibile per C# e Visual Basic.

Identificatori di formato standard

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

Il risultato di una stringa formattata per impostazioni cultura specifiche può essere diverso dagli esempi seguenti. Le impostazioni del sistema operativo, le impostazioni utente, le variabili di ambiente e la versione .NET in uso possono influire sul formato. Ad esempio, a partire da .NET 5, .NET tenta di unificare i formati culturali tra le piattaforme. Per altre informazioni, vedere Globalizzazione .NET e ICU.

Identificatore di formato Nome Descrizione Esempi
"B" o "b" Binary Risultato: stringa binaria.

Supportato da: solo tipi integrali (.NET 8+).

Identificatore di precisione: numero di cifre nella stringa di risultato.

Altre informazioni: Identificatore di formato binario ("B").		 42 ("B")
-> 101010

255 ("b16")
-> 0000000011111111
"C" o "c" Valuta Risultato: un valore di valuta.

Supportato da: tutti i tipi numerici.

Identificatore di precisione: numero di cifre decimali.

Identificatore di precisione predefinito: definito da NumberFormatInfo.CurrencyDecimalDigits.

Altre informazioni: Identificatore di formato di valuta ("C").		 123.456 ("C", en-US)
-> \$123,46

123.456 ("C", fr-FR)
-> 123.46 €

123.456 ("C", ja-JP)
-> ^123

-123.456 ("C3", en-US)
-> (\$123,456)

-123.456 ("C3", fr-FR)
-> -123.456 €

-123.456 ("C3", ja-JP)
- -> ^123.456
"D" o "d" Decimal Risultato: cifre intere con segno negativo facoltativo.

Supportato da: solo tipi integrali.

Identificatore di precisione: numero minimo di cifre.

Identificatore di precisione predefinito: numero minimo di cifre richieste.

Altre informazioni: Identificatore di formato decimale ("D").		 1234 ("D")
-> 1234

-1234 ("D6")
-> -001234
"E" o "e" Esponenziale (scientifico) Risultato: notazione esponenziale.

Supportato da: tutti i tipi numerici.

Identificatore di precisione: numero di cifre decimali.

Identificatore di precisione predefinito: 6.

Altre informazioni: Identificatore di formato esponenziale ("E").		 1052.0329112756 ("E", en-US)
-> 1.052033E+003

1052.0329112756 ("e", fr-FR)
-> 1.052033e+003

-1052.0329112756 ("e2", en-US)
-> -1.05e+003

-1052.0329112756 ("E2", fr-FR)
-> -1.05E+003
"F" o "f" A virgola fissa Risultato: cifre integrali e decimali con segno negativo facoltativo.

Supportato da: tutti i tipi numerici.

Identificatore di precisione: numero di cifre decimali.

Identificatore di precisione predefinito: definito da NumberFormatInfo.NumberDecimalDigits.

Altre informazioni: Identificatore di formato a virgola fissa ("F").		 1234.567 ("F", en-US)
-> 1234.57

1234.567 ("F", de-DE)
-> 1234.57

1234 ("F1", en-US)
-> 1234.0

1234 ("F1", de-DE)
-> 1234.0

-1234.56 ("F4", en-US)
-> -1234.5600

-1234.56 ("F4", de-DE)
-> -1234.5600
"G" o "g" Generale Risultato: la più compatta tra la notazione a virgola fissa e quella scientifica.

Supportato da: tutti i tipi numerici.

Identificatore di precisione: numero di cifre significative.

Identificatore di precisione predefinito: dipende dal tipo numerico.

Altre informazioni: Identificatore di formato generale ("G").		 -123.456 ("G", en-US)
-> -123.456

-123.456 ("G", sv-SE)
-> -123.456

123.4546 ("G4", en-US)
-> 123.5

123.4546 ("G4", sv-SE)
-> 123.5

-1.234567890e-25 ("G", en-US)
-> -1.23456789E-25

-1.234567890e-25 ("G", sv-SE)
-> -1.23456789E-25
"N" o "n" Number Risultato: cifre integrali e decimali, separatori di gruppi e un separatore decimale con segno negativo facoltativo.

Supportato da: tutti i tipi numerici.

Identificatore di precisione: numero desiderato di posizioni decimali.

Identificatore di precisione predefinito: definito da NumberFormatInfo.NumberDecimalDigits.

Altre informazioni: Identificatore di formato numerico ("N").		 1234.567 ("N", en-US)
-> 1.234.57

1234.567 ("N", ru-UR)
-> 1 234.57

1234 ("N1", en-US)
-> 1.234.0

1234 ("N1", ru-UR)
-> 1 234.0

-1234.56 ("N3", en-US)
-> -1.234.560

-1234.56 ("N3", ru-UR)
-> -1 234.560
"P" o "p" Percentuale Risultato: numero moltiplicato per 100 e visualizzato con un simbolo di percentuale.

Supportato da: tutti i tipi numerici.

Identificatore di precisione: numero desiderato di posizioni decimali.

Identificatore di precisione predefinito: definito da NumberFormatInfo.PercentDecimalDigits.

Altre informazioni: Identificatore di formato percentuale ("P").		 1 ("P", en-US)
-> 100,00 %

1 ("P", fr-FR)
-> 100.00 %

-0.39678 ("P1", en-US)
-> -39,7 %

-0.39678 ("P1", fr-FR)
-> -39,7 %
"R" o "r" Round trip Risultato: stringa che può eseguire il round trip a un numero identico.

Supportato da: Single, Double e BigInteger.

Nota: consigliato solo per il tipo BigInteger. Per i tipi Double, usare "G17"; per i tipi Single, usare "G9".
Identificatore di precisione: ignorato.

Altre informazioni: Identificatore di formato di round trip ("R").		 123456789.12345678 ("R")
-> 123456789.12345678

-1234567890.12345678 ("R")
-> -1234567890.1234567
"X" o "x" Valore esadecimale Risultato: stringa esadecimale.

Supportato da: solo tipi integrali.

Identificatore di precisione: numero di cifre nella stringa di risultato.

Altre informazioni: Identificatore di formato Esadecimale ("X").		 255 ("X")
-> FF

-1 ("x")
-> ff

255 ("x4")
-> 00ff

-1 ("X4")
-> 00FF
Qualsiasi altro carattere singolo Identificatore sconosciuto Risultato: genera un evento FormatException in fase di esecuzione.

Usare stringhe di formato numerico standard

Nota

Gli esempi in C# in questo articolo vengono eseguiti nello strumento di esecuzione e playground per codice inline Try.NET. Selezionare il pulsante Esegui per eseguire un esempio in una finestra interattiva. Dopo aver eseguito il codice, è possibile modificarlo ed eseguire il codice modificato selezionando di nuovo Esegui. Il codice modificato viene eseguito nella finestra interattiva o, se la compilazione non riesce, la finestra interattiva visualizza tutti i messaggi di errore del compilatore C#.

Una stringa di formato numerico standard può essere usata per definire la formattazione di un valore numerico in uno dei modi seguenti:

  • Può essere passato al metodo o a TryFormat un overload del ToString metodo con un format parametro. Nell'esempio seguente un valore numerico viene formattato come stringa di valuta nelle impostazioni cultura correnti (in questo caso, en-US).

    Decimal value = static_cast<Decimal>(123.456);
Console::WriteLine(value.ToString("C2"));
// Displays $123.46

    decimal value = 123.456m;
Console.WriteLine(value.ToString("C2"));
// Displays $123.46

    Dim value As Decimal = 123.456d
Console.WriteLine(value.ToString("C2"))
' Displays $123.46

  • È possibile fornire la stringa come argomento formatString in un elemento di formato usato con metodi come String.Format, Console.WriteLine e StringBuilder.AppendFormat. Per altre informazioni, vedere Formattazione composita. Nell'esempio seguente viene usato un elemento di formato per inserire un valore di valuta in una stringa.

    Decimal value = static_cast<Decimal>(123.456);
Console::WriteLine("Your account balance is {0:C2}.", value);
// Displays "Your account balance is $123.46."

    decimal value = 123.456m;
Console.WriteLine("Your account balance is {0:C2}.", value);
// Displays "Your account balance is $123.46."

    Dim value As Decimal = 123.456d
Console.WriteLine("Your account balance is {0:C2}.", value)
' Displays "Your account balance is $123.46."

    Facoltativamente, fornire un argomento alignment per specificare la lunghezza del campo numerico e se il relativo valore è allineato a destra o a sinistra. L'esempio seguente allinea a sinistra un valore corrente in un campo a 28 caratteri e allinea a destra un valore di valuta in un campo a 14 caratteri.

    array<Decimal>^ amounts = { static_cast<Decimal>(16305.32), 
                            static_cast<Decimal>(18794.16) };
Console::WriteLine("   Beginning Balance           Ending Balance");
Console::WriteLine("   {0,-28:C2}{1,14:C2}", amounts[0], amounts[1]);
// Displays:
//        Beginning Balance           Ending Balance
//        $16,305.32                      $18,794.16      

    decimal[] amounts = { 16305.32m, 18794.16m };
Console.WriteLine("   Beginning Balance           Ending Balance");
Console.WriteLine("   {0,-28:C2}{1,14:C2}", amounts[0], amounts[1]);
// Displays:
//        Beginning Balance           Ending Balance
//        $16,305.32                      $18,794.16

    Dim amounts() As Decimal = {16305.32d, 18794.16d}
Console.WriteLine("   Beginning Balance           Ending Balance")
Console.WriteLine("   {0,-28:C2}{1,14:C2}", amounts(0), amounts(1))
' Displays:
'        Beginning Balance           Ending Balance
'        $16,305.32                      $18,794.16

  • Può essere passato come argomento formatString in un elemento espressione interpolata di una stringa interpolata. Per altre informazioni, vedere l'articolo Interpolazione stringhe nel riferimento C# o nell'articolo Stringhe interpolate nel riferimento a Visual Basic.

Nelle sezioni seguenti vengono fornite informazioni dettagliate su ognuna delle stringhe di formato numerico standard.

Identificatore di formato binario (B)

L'identificatore di formato binario ("B") converte un numero in una stringa di cifre binarie. Questo formato è supportato solo per i tipi integrali e solo in .NET 8+.

L'identificatore di precisione indica il numero minimo di cifre che si vogliono visualizzare nella stringa risultante. Se necessario, alla sinistra del numero verranno aggiunti degli zeri in modo da raggiungere il numero di cifre specificato dall'identificatore di precisione.

La stringa di risultato non è influenzata dalle informazioni sulla formattazione dell'oggetto NumberFormatInfo corrente.

Identificatore di formato valuta (C)

L'identificatore di formato di valuta ("C") consente di convertire un numero in una stringa che rappresenta un importo di valuta. L'identificatore di precisione indica il numero desiderato di posizioni decimali nella stringa di risultato. Se l'identificatore di precisione viene omesso, viene usata la precisione predefinita definita dalla proprietà NumberFormatInfo.CurrencyDecimalDigits.

Se il valore da formattare contiene un numero di posizioni decimali maggiore del numero specificato o predefinito, il valore frazionario viene arrotondato nella stringa di risultato. Se il valore a destra del numero di posizioni decimali specificate è maggiore o uguale a 5, l'ultima cifra nella stringa di risultato viene arrotondata per eccesso.

La stringa di risultato è influenzata dalle informazioni sulla formattazione dell'oggetto NumberFormatInfo corrente. Nella tabella seguente sono elencate le proprietà di NumberFormatInfo che consentono di controllare la formattazione della stringa restituita.

Proprietà di NumberFormatInfo Descrizione
CurrencyPositivePattern Definisce la posizione del simbolo di valuta per i valori positivi.
CurrencyNegativePattern Definisce la posizione del simbolo di valuta per i valori negativi e specifica se il segno negativo è rappresentato da parentesi o dalla proprietà NegativeSign.
NegativeSign Definisce il segno negativo usato se CurrencyNegativePattern indica che non vengono usate le parentesi.
CurrencySymbol Definisce il simbolo di valuta.
CurrencyDecimalDigits Definisce il numero predefinito di cifre decimali in un valore di valuta. È possibile eseguire l'override di questo valore usando l'identificatore di precisione.
CurrencyDecimalSeparator Definisce la stringa che separa le cifre integrali da quelle decimali.
CurrencyGroupSeparator Definisce la stringa che separa i gruppi di numeri integrali.
CurrencyGroupSizes Definisce il numero di cifre intere visualizzate in un gruppo.

Nell'esempio seguente viene formattato un Double valore con l'identificatore di formato valuta:

double value = 12345.6789;
Console::WriteLine(value.ToString("C", CultureInfo::CurrentCulture));

Console::WriteLine(value.ToString("C3", CultureInfo::CurrentCulture));

Console::WriteLine(value.ToString("C3", 
                  CultureInfo::CreateSpecificCulture("da-DK")));
// The example displays the following output on a system whose
// current culture is English (United States):
//       $12,345.68
//       $12,345.679
//       kr 12.345,679

double value = 12345.6789;
Console.WriteLine(value.ToString("C", CultureInfo.CurrentCulture));

Console.WriteLine(value.ToString("C3", CultureInfo.CurrentCulture));

Console.WriteLine(value.ToString("C3",
                  CultureInfo.CreateSpecificCulture("da-DK")));
// The example displays the following output on a system whose
// current culture is English (United States):
//       $12,345.68
//       $12,345.679
//       12.345,679 kr

Dim value As Double = 12345.6789
Console.WriteLine(value.ToString("C", CultureInfo.CurrentCulture))

Console.WriteLine(value.ToString("C3", CultureInfo.CurrentCulture))

Console.WriteLine(value.ToString("C3", _
                  CultureInfo.CreateSpecificCulture("da-DK")))
' The example displays the following output on a system whose
' current culture is English (United States):
'       $12,345.68
'       $12,345.679
'       kr 12.345,679

Identificatore di formato decimale (D)

L'identificatore di formato decimale ("D") consente di convertire un numero in una stringa di cifre decimali, da 0 a 9, preceduta da un segno meno se il numero è negativo. Questo formato è supportato solo per i tipi integrali.

L'identificatore di precisione indica il numero minimo di cifre che si vogliono visualizzare nella stringa risultante. Se necessario, alla sinistra del numero verranno aggiunti degli zeri in modo da raggiungere il numero di cifre specificato dall'identificatore di precisione. Se non viene specificato alcun identificatore di precisione, il valore predefinito corrisponde al valore minimo richiesto per rappresentare il numero intero senza zeri iniziali.

La stringa di risultato è influenzata dalle informazioni sulla formattazione dell'oggetto NumberFormatInfo corrente. Come illustrato nella tabella seguente, una singola proprietà influisce sulla formattazione della stringa di risultato.

Proprietà di NumberFormatInfo Descrizione
NegativeSign Definisce la stringa che indica che un numero è negativo.

Nell'esempio seguente viene formattato un valore Int32 con l'identificatore di formato decimale.

int value; 

value = 12345;
Console::WriteLine(value.ToString("D"));
// Displays 12345
Console::WriteLine(value.ToString("D8"));
// Displays 00012345

value = -12345;
Console::WriteLine(value.ToString("D"));
// Displays -12345
Console::WriteLine(value.ToString("D8"));
// Displays -00012345

int value;

value = 12345;
Console.WriteLine(value.ToString("D"));
// Displays 12345
Console.WriteLine(value.ToString("D8"));
// Displays 00012345

value = -12345;
Console.WriteLine(value.ToString("D"));
// Displays -12345
Console.WriteLine(value.ToString("D8"));
// Displays -00012345

Dim value As Integer

value = 12345
Console.WriteLine(value.ToString("D"))
' Displays 12345   
Console.WriteLine(value.ToString("D8"))
' Displays 00012345

value = -12345
Console.WriteLine(value.ToString("D"))
' Displays -12345
Console.WriteLine(value.ToString("D8"))
' Displays -00012345

Identificatore di formato esponenziale (E)

L'identificatore di formato esponenziale ("E") consente di convertire un numero in una stringa nel formato "-d.ddd…E+ddd" o "-d.ddd…e+ddd", dove ciascuna "d" indica una cifra da 0 a 9. Se il numero è negativo, la stringa inizierà con un segno meno. Il separatore decimale è sempre preceduto esattamente da una cifra.

L'identificatore di precisione indica il numero di cifre desiderato dopo il separatore decimale. Se l'identificatore di precisione viene omesso, verrà usato il numero predefinito di sei cifre dopo il separatore decimale.

Il fatto che per l'identificatore di formato venga usata una lettera maiuscola o minuscola indica, rispettivamente, se l'esponente debba essere preceduto dal prefisso "E" o "e". L'esponente consiste sempre in un segno più o meno e in un minimo di tre cifre. Se necessario, vengono aggiunti all'esponente degli zeri in modo da raggiungere tale numero di cifre.

La stringa di risultato è influenzata dalle informazioni sulla formattazione dell'oggetto NumberFormatInfo corrente. Nella tabella seguente sono elencate le proprietà di NumberFormatInfo che consentono di controllare la formattazione della stringa restituita.

Proprietà di NumberFormatInfo Descrizione
NegativeSign Definisce la stringa che indica che un numero è negativo sia per il coefficiente che per l'esponente.
NumberDecimalSeparator Definisce la stringa che separa la cifra integrale dalle cifre decimali nel coefficiente.
PositiveSign Definisce la stringa che indica che un esponente è positivo.

Nell'esempio seguente viene formattato un Double valore con l'identificatore di formato esponenziale:

double value = 12345.6789;
Console::WriteLine(value.ToString("E", CultureInfo::InvariantCulture));
// Displays 1.234568E+004

Console::WriteLine(value.ToString("E10", CultureInfo::InvariantCulture));
// Displays 1.2345678900E+004

Console::WriteLine(value.ToString("e4", CultureInfo::InvariantCulture));
// Displays 1.2346e+004

Console::WriteLine(value.ToString("E", 
                  CultureInfo::CreateSpecificCulture("fr-FR")));
// Displays 1,234568E+004

double value = 12345.6789;
Console.WriteLine(value.ToString("E", CultureInfo.InvariantCulture));
// Displays 1.234568E+004

Console.WriteLine(value.ToString("E10", CultureInfo.InvariantCulture));
// Displays 1.2345678900E+004

Console.WriteLine(value.ToString("e4", CultureInfo.InvariantCulture));
// Displays 1.2346e+004

Console.WriteLine(value.ToString("E",
                  CultureInfo.CreateSpecificCulture("fr-FR")));
// Displays 1,234568E+004

Dim value As Double = 12345.6789
Console.WriteLine(value.ToString("E", CultureInfo.InvariantCulture))
' Displays 1.234568E+004

Console.WriteLine(value.ToString("E10", CultureInfo.InvariantCulture))
' Displays 1.2345678900E+004

Console.WriteLine(value.ToString("e4", CultureInfo.InvariantCulture))
' Displays 1.2346e+004

Console.WriteLine(value.ToString("E", _
                  CultureInfo.CreateSpecificCulture("fr-FR")))
' Displays 1,234568E+004

Identificatore di formato a virgola fissa (F)

L'identificatore di formato a virgola fissa ("F") consente di convertire un numero in una stringa nel formato "-ddd.ddd…", dove ogni "d" indica una cifra da 0 a 9. Se il numero è negativo, la stringa inizierà con un segno meno.

L'identificatore di precisione indica il numero di posizioni decimali desiderato. Se l'identificatore di precisione viene omesso, la precisione numerica viene fornita dalla proprietà NumberFormatInfo.NumberDecimalDigits corrente.

La stringa di risultato è influenzata dalle informazioni sulla formattazione dell'oggetto NumberFormatInfo corrente. Nella tabella seguente sono elencate le proprietà dell'oggetto NumberFormatInfo che consentono di controllare la formattazione della stringa di risultato.

Proprietà di NumberFormatInfo Descrizione
NegativeSign Definisce la stringa che indica che un numero è negativo.
NumberDecimalSeparator Definisce la stringa che separa le cifre integrali da quelle decimali.
NumberDecimalDigits Definisce il numero predefinito di cifre decimali. È possibile eseguire l'override di questo valore usando l'identificatore di precisione.

Nell'esempio seguente viene formattato un DoubleInt32 valore e con l'identificatore di formato a virgola fissa:

int integerNumber;
integerNumber = 17843;
Console::WriteLine(integerNumber.ToString("F", 
                  CultureInfo::InvariantCulture));
// Displays 17843.00

integerNumber = -29541;
Console::WriteLine(integerNumber.ToString("F3", 
                  CultureInfo::InvariantCulture));
// Displays -29541.000

double doubleNumber;
doubleNumber = 18934.1879;
Console::WriteLine(doubleNumber.ToString("F", CultureInfo::InvariantCulture));
// Displays 18934.19

Console::WriteLine(doubleNumber.ToString("F0", CultureInfo::InvariantCulture));
// Displays 18934

doubleNumber = -1898300.1987;
Console::WriteLine(doubleNumber.ToString("F1", CultureInfo::InvariantCulture));  
// Displays -1898300.2

Console::WriteLine(doubleNumber.ToString("F3", 
                  CultureInfo::CreateSpecificCulture("es-ES")));
// Displays -1898300,199                        

int integerNumber;
integerNumber = 17843;
Console.WriteLine(integerNumber.ToString("F",
                  CultureInfo.InvariantCulture));
// Displays 17843.00

integerNumber = -29541;
Console.WriteLine(integerNumber.ToString("F3",
                  CultureInfo.InvariantCulture));
// Displays -29541.000

double doubleNumber;
doubleNumber = 18934.1879;
Console.WriteLine(doubleNumber.ToString("F", CultureInfo.InvariantCulture));
// Displays 18934.19

Console.WriteLine(doubleNumber.ToString("F0", CultureInfo.InvariantCulture));
// Displays 18934

doubleNumber = -1898300.1987;
Console.WriteLine(doubleNumber.ToString("F1", CultureInfo.InvariantCulture));
// Displays -1898300.2

Console.WriteLine(doubleNumber.ToString("F3",
                  CultureInfo.CreateSpecificCulture("es-ES")));
// Displays -1898300,199

Dim integerNumber As Integer
integerNumber = 17843
Console.WriteLine(integerNumber.ToString("F", CultureInfo.InvariantCulture))
' Displays 17843.00

integerNumber = -29541
Console.WriteLine(integerNumber.ToString("F3", CultureInfo.InvariantCulture))
' Displays -29541.000

Dim doubleNumber As Double
doubleNumber = 18934.1879
Console.WriteLine(doubleNumber.ToString("F", CultureInfo.InvariantCulture))
' Displays 18934.19

Console.WriteLine(doubleNumber.ToString("F0", CultureInfo.InvariantCulture))
' Displays 18934

doubleNumber = -1898300.1987
Console.WriteLine(doubleNumber.ToString("F1", CultureInfo.InvariantCulture))
' Displays -1898300.2

Console.WriteLine(doubleNumber.ToString("F3", _
                  CultureInfo.CreateSpecificCulture("es-ES")))
' Displays -1898300,199

Identificatore di formato generale (G)

L'identificatore di formato generale ("G") consente di convertire un numero nel formato più compatto tra la notazione scientifica e quella a virgola fissa, a seconda del tipo di numero e della presenza di un identificatore di precisione. L'identificatore di precisione definisce il numero massimo di cifre significative che possono essere visualizzate nella stringa di risultato. Se l'identificatore di precisione viene omesso o è uguale a zero, il tipo di numero determina la precisione predefinita, come indicato nella tabella seguente.

Tipo numerico Precisione predefinita
Byte o SByte 3 cifre
Int16 o UInt16 5 cifre
Int32 o UInt32 10 cifre
Int64 19 cifre
UInt64 20 cifre
BigInteger Illimitato (uguale a "R")
Half Numero di cifre più piccolo round trippable per rappresentare il numero
Single Numero più piccolo di cifre di round trippable per rappresentare il numero (in .NET Framework, G7 è l'impostazione predefinita)
Double Numero più piccolo di cifre di round trippable per rappresentare il numero (in .NET Framework, G15 è l'impostazione predefinita)
Decimal Numero di cifre più piccolo round trippable per rappresentare il numero

La notazione a virgola fissa verrà usata se l'esponente ottenuto esprimendo il numero con la notazione scientifica risulta maggiore di -5 e minore dell'identificatore di precisione. In caso contrario, verrà usata la notazione scientifica. Il risultato contiene un separatore decimale, se richiesto, e gli zeri finali dopo la virgola decimale vengono omessi. Se l'identificatore di precisione è presente e il numero di cifre significative nel risultato è superiore alla precisione specificata, le cifre finali in eccesso vengono rimosse mediante arrotondamento.

Se, tuttavia, il numero è di tipo Decimal e l'identificatore di precisione viene omesso, viene usata sempre la notazione a virgola fissa e gli zeri finali vengono mantenuti.

Se viene usata la notazione scientifica, l'esponente nel risultato sarà preceduto da un prefisso "E" se l'identificatore di formato è "G" o da un prefisso "e" se l'identificatore di formato è "g". L'esponente contiene un minimo di due cifre. Questo aspetto è diverso rispetto al formato per la notazione scientifica, prodotto dall'identificatore di formato esponenziale, che include un minimo di tre cifre nell'esponente.

Se usato con un Double valore, l'identificatore di formato "G17" garantisce che il valore originale Double sia stato eseguito correttamente. Questo perché Double è un numero a virgola mobile conforme a IEEE 754-2008 chebinary64 dà fino a 17 cifre significative di precisione. In .NET Framework è consigliabile usarlo anziché l'identificatore di formato "R", perché in alcuni casi "R" non riesce a eseguire correttamente il round trip con valori a virgola mobile a precisione doppia.

Se usato con un valore Single, l'identificatore di formato "G9" assicura che il valore Single originale esegua correttamente il round trip. Ciò è dovuto al fatto Single che è un numero a virgola mobile conforme a IEEE 754-2008 conforme a precisione singola (binary32) che restituisce fino a nove cifre significative di precisione. Per motivi di prestazioni, è consigliabile usare questo anziché l'identificatore di formato "R".

La stringa di risultato è influenzata dalle informazioni sulla formattazione dell'oggetto NumberFormatInfo corrente. Nella tabella seguente sono elencate le proprietà di NumberFormatInfo che consentono di controllare la formattazione della stringa di risultato.

Proprietà di NumberFormatInfo Descrizione
NegativeSign Definisce la stringa che indica che un numero è negativo.
NumberDecimalSeparator Definisce la stringa che separa le cifre integrali da quelle decimali.
PositiveSign Definisce la stringa che indica che un esponente è positivo.

Nell'esempio seguente vengono formattati valori a virgola mobile diversi con l'identificatore di formato generale:

double number;

number = 12345.6789;      
Console::WriteLine(number.ToString("G", CultureInfo::InvariantCulture));
// Displays  12345.6789
Console::WriteLine(number.ToString("G", 
                  CultureInfo::CreateSpecificCulture("fr-FR")));
// Displays 12345,6789
                        
Console::WriteLine(number.ToString("G7", CultureInfo::InvariantCulture));
// Displays 12345.68 

number = .0000023;
Console::WriteLine(number.ToString("G", CultureInfo::InvariantCulture));
// Displays 2.3E-06       
Console::WriteLine(number.ToString("G", 
                  CultureInfo::CreateSpecificCulture("fr-FR")));
// Displays 2,3E-06

number = .0023;
Console::WriteLine(number.ToString("G", CultureInfo::InvariantCulture));
// Displays 0.0023

number = 1234;
Console::WriteLine(number.ToString("G2", CultureInfo::InvariantCulture));
// Displays 1.2E+03

number = Math::PI;
Console::WriteLine(number.ToString("G5", CultureInfo::InvariantCulture));
// Displays 3.1416    

double number;

number = 12345.6789;
Console.WriteLine(number.ToString("G", CultureInfo.InvariantCulture));
// Displays  12345.6789
Console.WriteLine(number.ToString("G",
                  CultureInfo.CreateSpecificCulture("fr-FR")));
// Displays 12345,6789

Console.WriteLine(number.ToString("G7", CultureInfo.InvariantCulture));
// Displays 12345.68

number = .0000023;
Console.WriteLine(number.ToString("G", CultureInfo.InvariantCulture));
// Displays 2.3E-06
Console.WriteLine(number.ToString("G",
                  CultureInfo.CreateSpecificCulture("fr-FR")));
// Displays 2,3E-06

number = .0023;
Console.WriteLine(number.ToString("G", CultureInfo.InvariantCulture));
// Displays 0.0023

number = 1234;
Console.WriteLine(number.ToString("G2", CultureInfo.InvariantCulture));
// Displays 1.2E+03

number = Math.PI;
Console.WriteLine(number.ToString("G5", CultureInfo.InvariantCulture));
// Displays 3.1416

Dim number As Double

number = 12345.6789
Console.WriteLine(number.ToString("G", CultureInfo.InvariantCulture))
' Displays  12345.6789
Console.WriteLine(number.ToString("G", _
                  CultureInfo.CreateSpecificCulture("fr-FR")))
' Displays 12345,6789

Console.WriteLine(number.ToString("G7", CultureInfo.InvariantCulture))
' Displays 12345.68 

number = .0000023
Console.WriteLine(number.ToString("G", CultureInfo.InvariantCulture))
' Displays 2.3E-06       
Console.WriteLine(number.ToString("G", _
                  CultureInfo.CreateSpecificCulture("fr-FR")))
' Displays 2,3E-06

number = .0023
Console.WriteLine(number.ToString("G", CultureInfo.InvariantCulture))
' Displays 0.0023

number = 1234
Console.WriteLine(number.ToString("G2", CultureInfo.InvariantCulture))
' Displays 1.2E+03

number = Math.Pi
Console.WriteLine(number.ToString("G5", CultureInfo.InvariantCulture))
' Displays 3.1416

Identificatore di formato numerico (N)

L'identificatore di formato numerico ("N") converte un numero in una stringa in formato "-c.ccc.ccc,ccc…", dove "-" indica un simbolo di numero negativo, se richiesto, "c" indica una cifra (0-9), "." indica il separatore delle migliaia tra gruppi numerici e "," indica il simbolo di separatore decimale. L'identificatore di precisione indica il numero di cifre desiderato dopo il separatore decimale. Se l'identificatore di precisione viene omesso, il numero di cifre decimali viene definito dalla proprietà NumberFormatInfo.NumberDecimalDigits corrente.

La stringa di risultato è influenzata dalle informazioni sulla formattazione dell'oggetto NumberFormatInfo corrente. Nella tabella seguente sono elencate le proprietà di NumberFormatInfo che consentono di controllare la formattazione della stringa di risultato.

Proprietà di NumberFormatInfo Descrizione
NegativeSign Definisce la stringa che indica che un numero è negativo.
NumberNegativePattern Definisce il formato dei valori negativi e specifica se il segno negativo è rappresentato da parentesi o dalla proprietà NegativeSign.
NumberGroupSizes Definisce il numero di cifre integrali visualizzate tra i separatori di gruppi.
NumberGroupSeparator Definisce la stringa che separa i gruppi di numeri integrali.
NumberDecimalSeparator Definisce la stringa che separa le cifre integrali da quelle decimali.
NumberDecimalDigits Definisce il numero predefinito di cifre decimali. È possibile eseguire l'override di questo valore usando un identificatore di precisione.

Nell'esempio seguente vengono formattati valori a virgola mobile diversi con l'identificatore di formato numerico:

double dblValue = -12445.6789;
Console::WriteLine(dblValue.ToString("N", CultureInfo::InvariantCulture));
// Displays -12,445.68
Console::WriteLine(dblValue.ToString("N1", 
                  CultureInfo::CreateSpecificCulture("sv-SE")));
// Displays -12 445,7

int intValue = 123456789;
Console::WriteLine(intValue.ToString("N1", CultureInfo::InvariantCulture));
// Displays 123,456,789.0 

double dblValue = -12445.6789;
Console.WriteLine(dblValue.ToString("N", CultureInfo.InvariantCulture));
// Displays -12,445.68
Console.WriteLine(dblValue.ToString("N1",
                  CultureInfo.CreateSpecificCulture("sv-SE")));
// Displays -12 445,7

int intValue = 123456789;
Console.WriteLine(intValue.ToString("N1", CultureInfo.InvariantCulture));
// Displays 123,456,789.0

Dim dblValue As Double = -12445.6789
Console.WriteLine(dblValue.ToString("N", CultureInfo.InvariantCulture))
' Displays -12,445.68
Console.WriteLine(dblValue.ToString("N1", _
                  CultureInfo.CreateSpecificCulture("sv-SE")))
' Displays -12 445,7

Dim intValue As Integer = 123456789
Console.WriteLine(intValue.ToString("N1", CultureInfo.InvariantCulture))
' Displays 123,456,789.0

Identificatore di formato percentuale (P)

L'identificatore di formato percentuale ("P") moltiplica un numero per 100 e lo converte in una stringa che rappresenta una percentuale. L'identificatore di precisione indica il numero di posizioni decimali desiderato. Se l'identificatore di precisione viene omesso, viene usata la precisione numerica predefinita fornita dalla proprietà PercentDecimalDigits corrente.

Nella tabella seguente sono elencate le proprietà di NumberFormatInfo che consentono di controllare la formattazione della stringa restituita.

Proprietà di NumberFormatInfo Descrizione
PercentPositivePattern Definisce la posizione del simbolo di percentuale per i valori positivi.
PercentNegativePattern Definisce la posizione del simbolo di percentuale e del simbolo negativo per i valori negativi.
NegativeSign Definisce la stringa che indica che un numero è negativo.
PercentSymbol Definisce il simbolo di percentuale.
PercentDecimalDigits Definisce il numero predefinito di cifre decimali in un valore percentuale. È possibile eseguire l'override di questo valore usando l'identificatore di precisione.
PercentDecimalSeparator Definisce la stringa che separa le cifre integrali da quelle decimali.
PercentGroupSeparator Definisce la stringa che separa i gruppi di numeri integrali.
PercentGroupSizes Definisce il numero di cifre intere visualizzate in un gruppo.

Nell'esempio seguente i valori a virgola mobile vengono formattati con l'identificatore di formato percentuale:

double number = .2468013;
Console::WriteLine(number.ToString("P", CultureInfo::InvariantCulture));
// Displays 24.68 %
Console::WriteLine(number.ToString("P", 
                  CultureInfo::CreateSpecificCulture("hr-HR")));
// Displays 24,68%     
Console::WriteLine(number.ToString("P1", CultureInfo::InvariantCulture));
// Displays 24.7 %

double number = .2468013;
Console.WriteLine(number.ToString("P", CultureInfo.InvariantCulture));
// Displays 24.68 %
Console.WriteLine(number.ToString("P",
                  CultureInfo.CreateSpecificCulture("hr-HR")));
// Displays 24,68%
Console.WriteLine(number.ToString("P1", CultureInfo.InvariantCulture));
// Displays 24.7 %

Dim number As Double = .2468013
Console.WriteLine(number.ToString("P", CultureInfo.InvariantCulture))
' Displays 24.68 %
Console.WriteLine(number.ToString("P", _
                  CultureInfo.CreateSpecificCulture("hr-HR")))
' Displays 24,68%     
Console.WriteLine(number.ToString("P1", CultureInfo.InvariantCulture))
' Displays 24.7 %

Identificatore di formato round trip (R)

L'identificatore di formato di round trip ("R") cerca di garantire che un valore numerico convertito in una stringa venga riportato al medesimo valore numerico. Questo formato è supportato solo per i Halftipi , Single, Doublee BigInteger .

In .NET Framework e nelle versioni di .NET Core precedenti alla 3.0, l'identificatore di formato "R" non riesce a eseguire correttamente il round trip Double in alcuni casi. Per entrambi i Double valori e Single , l'identificatore di formato "R" offre prestazioni relativamente scarse. È invece consigliabile usare l'identificatore di formato "G17" per i valori Double e l'identificatore di formato "G9" per eseguire correttamente il round trip dei valori Single.

Quando un valore BigInteger viene formattato usando questo identificatore, la relativa rappresentazione di stringa contiene tutte le cifre significative nel valore BigInteger.

Sebbene sia possibile includere un identificatore di precisione, questo viene ignorato. Quando si usa questo identificatore, infatti, il formato della riconversione ha la precedenza sulla precisione. La stringa di risultato è influenzata dalle informazioni sulla formattazione dell'oggetto NumberFormatInfo corrente. Nella tabella seguente sono elencate le proprietà di NumberFormatInfo che consentono di controllare la formattazione della stringa di risultato.

Proprietà di NumberFormatInfo Descrizione
NegativeSign Definisce la stringa che indica che un numero è negativo.
NumberDecimalSeparator Definisce la stringa che separa le cifre integrali da quelle decimali.
PositiveSign Definisce la stringa che indica che un esponente è positivo.

Nell'esempio seguente viene formattato un valore BigInteger con l'identificatore di formato round trip.

#using <System.Numerics.dll>

using namespace System;
using namespace System::Numerics;

void main()
{ 
   BigInteger value = BigInteger::Pow(Int64::MaxValue, 2);
   Console::WriteLine(value.ToString("R"));
}
// The example displays the following output:
//      85070591730234615847396907784232501249  



using System;
using System.Numerics;

public class Example
{
   public static void Main()
   {
      var value = BigInteger.Pow(Int64.MaxValue, 2);
      Console.WriteLine(value.ToString("R"));
   }
}
// The example displays the following output:
//      85070591730234615847396907784232501249

Imports System.Numerics

Module Example
    Public Sub Main()
        Dim value = BigInteger.Pow(Int64.MaxValue, 2)
        Console.WriteLine(value.ToString("R"))
    End Sub
End Module
' The example displays the following output:
'      85070591730234615847396907784232501249

Importante

In alcuni casi, i valori Double formattati con la stringa di formato numerico standard "R" non completano il round trip se compilati usando le opzioni /platform:x64 o /platform:anycpu e in esecuzione su sistemi a 64 bit. Per altre informazioni, vedere il paragrafo seguente.

Per risolvere il problema dei Double valori formattati con la stringa di formato numerico standard "R" non viene eseguito correttamente il round trip se compilato usando le /platform:x64 opzioni o /platform:anycpu ed eseguito su sistemi a 64 bit, è possibile formattare Double i valori usando la stringa di formato numerico standard "G17". L'esempio seguente usa la stringa di formato "R" con un Double valore che non esegue correttamente il round trip e usa anche la stringa di formato "G17" per eseguire correttamente il round trip del valore originale:

Console.WriteLine("Attempting to round-trip a Double with 'R':");
double initialValue = 0.6822871999174;
string valueString = initialValue.ToString("R",
                                           CultureInfo.InvariantCulture);
double roundTripped = double.Parse(valueString,
                                   CultureInfo.InvariantCulture);
Console.WriteLine("{0:R} = {1:R}: {2}\n",
                  initialValue, roundTripped, initialValue.Equals(roundTripped));

Console.WriteLine("Attempting to round-trip a Double with 'G17':");
string valueString17 = initialValue.ToString("G17",
                                             CultureInfo.InvariantCulture);
double roundTripped17 = double.Parse(valueString17,
                                     CultureInfo.InvariantCulture);
Console.WriteLine("{0:R} = {1:R}: {2}\n",
                  initialValue, roundTripped17, initialValue.Equals(roundTripped17));
// If compiled to an application that targets anycpu or x64 and run on an x64 system,
// the example displays the following output:
//       Attempting to round-trip a Double with 'R':
//       .NET Framework:
//       0.6822871999174 = 0.68228719991740006: False
//       .NET:
//       0.6822871999174 = 0.6822871999174: True
//
//       Attempting to round-trip a Double with 'G17':
//       0.6822871999174 = 0.6822871999174: True

Imports System.Globalization

Module Example
    Public Sub Main()
        Console.WriteLine("Attempting to round-trip a Double with 'R':")
        Dim initialValue As Double = 0.6822871999174
        Dim valueString As String = initialValue.ToString("R",
                                                 CultureInfo.InvariantCulture)
        Dim roundTripped As Double = Double.Parse(valueString,
                                                  CultureInfo.InvariantCulture)
        Console.WriteLine("{0:R} = {1:R}: {2}",
                          initialValue, roundTripped, initialValue.Equals(roundTripped))
        Console.WriteLine()

        Console.WriteLine("Attempting to round-trip a Double with 'G17':")
        Dim valueString17 As String = initialValue.ToString("G17",
                                                   CultureInfo.InvariantCulture)
        Dim roundTripped17 As Double = double.Parse(valueString17,
                                              CultureInfo.InvariantCulture)
        Console.WriteLine("{0:R} = {1:R}: {2}",
                          initialValue, roundTripped17, initialValue.Equals(roundTripped17))
    End Sub
End Module
' If compiled to an application that targets anycpu or x64 and run on an x64 system,
' the example displays the following output:
'       Attempting to round-trip a Double with 'R':
'       .NET Framework:
'       0.6822871999174 = 0.68228719991740006: False
'       .NET:
'       0.6822871999174 = 0.6822871999174: True
'
'       Attempting to round-trip a Double with 'G17':
'       0.6822871999174 = 0.6822871999174: True

Identificatore di formato esadecimale (X)

L'identificatore di formato esadecimale ("X") consente di convertire un numero in una stringa di cifre esadecimali. Il fatto che per l'identificatore di formato venga usata una lettera maiuscola o minuscola indica, rispettivamente, se usare caratteri maiuscoli o minuscoli per le cifre esadecimali maggiori di 9. usare ad esempio "X" per produrre la stringa "ABCDEF" e "x" per produrre "abcdef". Questo formato è supportato solo per i tipi integrali.

L'identificatore di precisione indica il numero minimo di cifre che si vogliono visualizzare nella stringa risultante. Se necessario, alla sinistra del numero verranno aggiunti degli zeri in modo da raggiungere il numero di cifre specificato dall'identificatore di precisione.

La stringa di risultato non è influenzata dalle informazioni sulla formattazione dell'oggetto NumberFormatInfo corrente.

Nell'esempio seguente vengono formattati valori Int32 con l'identificatore di formato esadecimale.

int value; 

value = 0x2045e;
Console::WriteLine(value.ToString("x"));
// Displays 2045e
Console::WriteLine(value.ToString("X"));
// Displays 2045E
Console::WriteLine(value.ToString("X8"));
// Displays 0002045E

value = 123456789;
Console::WriteLine(value.ToString("X"));
// Displays 75BCD15
Console::WriteLine(value.ToString("X2"));
// Displays 75BCD15

int value;

value = 0x2045e;
Console.WriteLine(value.ToString("x"));
// Displays 2045e
Console.WriteLine(value.ToString("X"));
// Displays 2045E
Console.WriteLine(value.ToString("X8"));
// Displays 0002045E

value = 123456789;
Console.WriteLine(value.ToString("X"));
// Displays 75BCD15
Console.WriteLine(value.ToString("X2"));
// Displays 75BCD15

Dim value As Integer

value = &h2045e
Console.WriteLine(value.ToString("x"))
' Displays 2045e
Console.WriteLine(value.ToString("X"))
' Displays 2045E
Console.WriteLine(value.ToString("X8"))
' Displays 0002045E

value = 123456789
Console.WriteLine(value.ToString("X"))
' Displays 75BCD15
Console.WriteLine(value.ToString("X2"))
' Displays 75BCD15

Note

Questa sezione contiene informazioni aggiuntive sull'uso di stringhe di formato numerico standard.

Impostazioni del Pannello di controllo

Le impostazioni di Opzioni internazionali e della lingua nel Pannello di controllo influiscono sulla stringa risultato prodotta da un'operazione di formattazione. Queste impostazioni vengono utilizzate per inizializzare l'oggetto NumberFormatInfo associato alle impostazioni cultura correnti, che fornisce i valori utilizzati per gestire la formattazione. Computer con impostazioni diverse generano stringhe di risultato diverse.

Inoltre, se viene usato il costruttore CultureInfo(String) per creare un'istanza di un nuovo oggetto CultureInfo che rappresenta le stesse impostazioni cultura delle impostazioni cultura del sistema correnti, le eventuali personalizzazioni definite dall'elemento Opzioni internazionali e della lingua nel Pannello Controllo verranno applicate al nuovo oggetto CultureInfo. È possibile usare il costruttore di CultureInfo(String, Boolean) per creare un oggetto CultureInfo che non rifletta le personalizzazioni di un sistema.

Proprietà NumberFormatInfo

La formattazione è influenzata dalle proprietà dell'oggetto corrente NumberFormatInfo , fornite in modo implicito dalle impostazioni cultura correnti o in modo esplicito dal IFormatProvider parametro del metodo che richiama la formattazione. Specificare un oggetto NumberFormatInfo o CultureInfo per questo parametro.

Nota

Per informazioni sulla personalizzazione delle stringhe o dei modelli usati nella formattazione di valori numerici, vedere l'argomento relativo alla classe NumberFormatInfo.

Tipi numerici integrali e a virgola mobile

Alcune descrizioni di identificatori di formato numerico standard fanno riferimento a tipi numerici integrali o a virgola mobile. I tipi numerici integrali sono Byte, SByte, Int16, Int32, Int64, UInt16, UInt32, UInt64 e BigInteger. I tipi numerici a virgola mobile sono Decimal, , HalfSinglee Double.

Valori infiniti a virgola mobile e NaN

Indipendentemente dalla stringa di formato, se il valore di un Halftipo , Singleo Double a virgola mobile è infinito positivo, infinito negativo o non un numero (NaN), la stringa formattata è il valore della PositiveInfinitySymbolrispettiva proprietà , NegativeInfinitySymbolo NaNSymbol specificata dall'oggetto attualmente applicabile NumberFormatInfo .

Esempio di codice

Nell'esempio seguente vengono formattati un valore numerico a virgola mobile e uno integrale usando le impostazioni cultura en-US e tutti gli identificatori di formato numerico standard. In questo esempio vengono usati due tipi numerici specifici (Double e ), ma si ottengono risultati simili per uno degli altri tipi di base numerici (Byte, UInt16UInt32Int16SByteBigIntegerHalfInt32Int64UInt64Decimale ).SingleInt32

// Display string representations of numbers for en-us culture
CultureInfo ci = new CultureInfo("en-us");

// Output floating point values
double floating = 10761.937554;
Console.WriteLine("C: {0}",
        floating.ToString("C", ci));           // Displays "C: $10,761.94"
Console.WriteLine("E: {0}",
        floating.ToString("E03", ci));         // Displays "E: 1.076E+004"
Console.WriteLine("F: {0}",
        floating.ToString("F04", ci));         // Displays "F: 10761.9376"
Console.WriteLine("G: {0}",
        floating.ToString("G", ci));           // Displays "G: 10761.937554"
Console.WriteLine("N: {0}",
        floating.ToString("N03", ci));         // Displays "N: 10,761.938"
Console.WriteLine("P: {0}",
        (floating/10000).ToString("P02", ci)); // Displays "P: 107.62 %"
Console.WriteLine("R: {0}",
        floating.ToString("R", ci));           // Displays "R: 10761.937554"
Console.WriteLine();

// Output integral values
int integral = 8395;
Console.WriteLine("C: {0}",
        integral.ToString("C", ci));           // Displays "C: $8,395.00"
Console.WriteLine("D: {0}",
        integral.ToString("D6", ci));          // Displays "D: 008395"
Console.WriteLine("E: {0}",
        integral.ToString("E03", ci));         // Displays "E: 8.395E+003"
Console.WriteLine("F: {0}",
        integral.ToString("F01", ci));         // Displays "F: 8395.0"
Console.WriteLine("G: {0}",
        integral.ToString("G", ci));           // Displays "G: 8395"
Console.WriteLine("N: {0}",
        integral.ToString("N01", ci));         // Displays "N: 8,395.0"
Console.WriteLine("P: {0}",
        (integral/10000.0).ToString("P02", ci)); // Displays "P: 83.95 %"
Console.WriteLine("X: 0x{0}",
        integral.ToString("X", ci));           // Displays "X: 0x20CB"
Console.WriteLine();

Option Strict On

Imports System.Globalization
Imports System.Threading

Module NumericFormats
    Public Sub Main()
        ' Display string representations of numbers for en-us culture
        Dim ci As New CultureInfo("en-us")

        ' Output floating point values
        Dim floating As Double = 10761.937554
        Console.WriteLine("C: {0}", _
                floating.ToString("C", ci))           ' Displays "C: $10,761.94"
        Console.WriteLine("E: {0}", _
                floating.ToString("E03", ci))         ' Displays "E: 1.076E+004"
        Console.WriteLine("F: {0}", _
                floating.ToString("F04", ci))         ' Displays "F: 10761.9376"         
        Console.WriteLine("G: {0}", _
                floating.ToString("G", ci))           ' Displays "G: 10761.937554"
        Console.WriteLine("N: {0}", _
                floating.ToString("N03", ci))         ' Displays "N: 10,761.938"
        Console.WriteLine("P: {0}", _
                (floating / 10000).ToString("P02", ci)) ' Displays "P: 107.62 %"
        Console.WriteLine("R: {0}", _
                floating.ToString("R", ci))           ' Displays "R: 10761.937554"            
        Console.WriteLine()

        ' Output integral values
        Dim integral As Integer = 8395
        Console.WriteLine("C: {0}", _
                integral.ToString("C", ci))           ' Displays "C: $8,395.00"
        Console.WriteLine("D: {0}", _
                integral.ToString("D6"))              ' Displays "D: 008395" 
        Console.WriteLine("E: {0}", _
                integral.ToString("E03", ci))         ' Displays "E: 8.395E+003"
        Console.WriteLine("F: {0}", _
                integral.ToString("F01", ci))         ' Displays "F: 8395.0"    
        Console.WriteLine("G: {0}", _
                integral.ToString("G", ci))           ' Displays "G: 8395"
        Console.WriteLine("N: {0}", _
                integral.ToString("N01", ci))         ' Displays "N: 8,395.0"
        Console.WriteLine("P: {0}", _
                (integral / 10000).ToString("P02", ci)) ' Displays "P: 83.95 %"
        Console.WriteLine("X: 0x{0}", _
                integral.ToString("X", ci))           ' Displays "X: 0x20CB"
        Console.WriteLine()
    End Sub
End Module

Vedi anche