Stringhe di formato numerico standard

  • Articolo

Le stringhe di formato numerico standard vengono utilizzate per formattare tipi numerici comuni. Una stringa di formato numerico standard utilizza il formato Axx, dove A è un carattere alfabetico denominato identificatore di formato e xx è un intero facoltativo denominato identificatore di precisione. L'identificatore di precisione, compreso tra 0 e 99, controlla il numero di cifre nel risultato. Le stringhe di formato numerico contenenti più caratteri alfabetici, inclusi gli spazi, vengono interpretate come stringhe di formato numerico personalizzate. Per ulteriori informazioni, vedere Stringhe di formato numerico personalizzate.

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

SuggerimentoSuggerimento

È possibile scaricare l'utilità di formattazione, un'applicazione che consente di applicare le stringhe di formato a valori numerici o di data e ora e di visualizzare la stringa di risultato.

Nella tabella seguente vengono descritti gli identificatori di formato numerico standard e viene visualizzato l'output di esempio prodotto da ogni identificatore di formato. Vedere la sezione Note per informazioni aggiuntive sull'utilizzo di stringhe di formato numerico standard e la sezione Esempio per un'illustrazione completa dell'utilizzo.

Identificatore di formato

Nome

Descrizione

Esempi

"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 System.Globalization.NumberFormatInfo.

Ulteriori 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.

Ulteriori 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.

Ulteriori 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 System.Globalization.NumberFormatInfo.

Ulteriori 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.

Ulteriori 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"

Numero

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 System.Globalization.NumberFormatInfo.

Ulteriori informazioni: Identificatore di formato numerico ("N").

1234.567 ("N", en-US) -> 1,234.57

1234.567 ("N", ru-RU) -> 1 234,57

1234 ("N", en-US) -> 1,234.0

1234 ("N", ru-RU) -> 1 234,0

-1234.56 ("N", en-US) -> -1,234.560

-1234.56 ("N", ru-RU) -> -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 System.Globalization.NumberFormatInfo.

Ulteriori 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"

Riconversione

Risultato: stringa in grado di eseguire una sequenza di andata e ritorno a un numero identico.

Supportato da: Single, Double e BigInteger.

Identificatore di precisione: ignorato.

Ulteriori informazioni: Identificatore di formato di round trip ("R").

123456789.12345678 ("R") -> 123456789.12345678

-1234567890.12345678 ("R") -> -1234567890.1234567

"X" o "x"

Esadecimale

Risultato: stringa esadecimale.

Supportato da: solo tipi integrali.

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

Ulteriori 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.

Utilizzo di stringhe di formato numerico standard

È possibile utilizzare una stringa di formato numerico standard per definire la formattazione di un valore numerico in uno dei due modi seguenti:

  • È possibile passare la stringa a un overload del metodo ToString che dispone di un parametro format. Nell'esempio seguente un valore numerico viene formattato come stringa di valuta nelle impostazioni cultura correnti (in questo caso, en-US).

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

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

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

    Dim value As Decimal = 123.456d
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."

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

Identificatore di formato di 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 utilizzata 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 utilizzato se CurrencyNegativePattern indica che non vengono utilizzate 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 utilizzando 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 valore Double con l'identificatore di formato di valuta.

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

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

Torna alla tabella

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 desidera vengano visualizzate 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.

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

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

Torna alla tabella

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à utilizzato il numero predefinito di sei cifre dopo il separatore decimale.

Il fatto che per l'identificatore di formato venga utilizzata 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 valore Double con l'identificatore di formato esponenziale.

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

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

Torna alla tabella

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 ciascuna "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 utilizzando l'identificatore di precisione.

Nell'esempio seguente vengono formattati un valore Double e un valore Int32 con l'identificatore di formato a virgola fissa.

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                        

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

Torna alla tabella

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

29 cifre

Single

7 cifre

Double

15 cifre

Decimal

29 cifre

La notazione a virgola fissa verrà utilizzata 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à utilizzata 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 utilizzata sempre la notazione a virgola fissa e gli zeri finali vengono mantenuti.

Se viene utilizzata 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.

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.

NumberDecimalDigits

Definisce il numero predefinito di cifre decimali. È possibile eseguire l'override di questo valore utilizzando l'identificatore di precisione.

PositiveSign

Definisce la stringa che indica che un esponente è positivo.

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

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    

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

Torna alla tabella

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 utilizzando un identificatore di precisione.

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

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 

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

Torna alla tabella

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 utilizzata 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 utilizzando 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 vengono formattati diversi valori a virgola mobile con l'identificatore di formato percentuale.

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 %

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 %

Torna alla tabella

Identificatore di formato di round trip ("R")

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

Quando un valore BigInteger viene formattato utilizzando questo identificatore, la relativa rappresentazione di stringa contiene tutte le cifre significative nel valore BigInteger. Quando un valore Single o Double viene formattato con questo identificatore, ne viene dapprima eseguito il test utilizzando il formato generale, con 15 cifre di precisione nel caso di un tipo Double e 7 cifre nel caso di un tipo Single. Se la riconversione del valore nello stesso valore numerico iniziale viene eseguita correttamente, il valore verrà formattato con l'identificatore di formato generale. Se il valore non viene riconvertito correttamente nello stesso valore numerico, viene formattato con 17 cifre di precisione nel caso di un tipo Double e 9 cifre nel caso di un tipo Single.

Sebbene sia possibile includere un identificatore di precisione, questo viene ignorato. Quando si utilizza 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 vengono formattati valori Double con l'identificatore di formato round trip.

Dim value As Double

value = Math.Pi
Console.WriteLine(value.ToString("r"))
' Displays 3.1415926535897931
Console.WriteLine(value.ToString("r", _
                  CultureInfo.CreateSpecificCulture("fr-FR")))
' Displays 3,1415926535897931
value = 1.623e-21
Console.WriteLine(value.ToString("r"))
' Displays 1.623E-21

double value;

value = Math.PI;
Console.WriteLine(value.ToString("r"));
// Displays 3.1415926535897931
Console.WriteLine(value.ToString("r", 
                  CultureInfo.CreateSpecificCulture("fr-FR")));
// Displays 3,1415926535897931
value = 1.623e-21;
Console.WriteLine(value.ToString("r"));
// Displays 1.623E-21

Torna alla tabella

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 utilizzata una lettera maiuscola o minuscola indica, rispettivamente, se utilizzare caratteri maiuscoli o minuscoli per le cifre esadecimali maggiori di 9. Utilizzare 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 desidera vengano visualizzate 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.

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

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

Torna alla tabella

Note

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 del thread corrente, che fornisce i valori utilizzati per definire la formattazione. Computer con impostazioni diverse generano stringhe di risultato diverse.

Inoltre, se viene utilizzato il costruttore CultureInfo.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 utilizzare il costruttore di CultureInfo.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 NumberFormatInfo corrente, che viene fornito in modo implicito dalle impostazioni cultura del thread corrente o in modo esplicito dal parametro IFormatProvider del metodo che richiama la formattazione. Specificare un oggetto NumberFormatInfo o CultureInfo per questo parametro.

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, Single e Double.

Valori infiniti a virgola mobile e NaN

Indipendentemente dalla stringa di formato, se il valore di un tipo a virgola mobile Single o Double è un numero infinito positivo, un numero infinito negativo o un valore NaN (Not a Number, non un numero), la stringa formattata corrisponde al valore della proprietà PositiveInfinitySymbol, NegativeInfinitySymbol o NaNSymbol corrispondente specificata dall'oggetto NumberFormatInfo attualmente applicabile.

Esempio

Nell'esempio seguente vengono formattati un valore numerico a virgola mobile e uno integrale utilizzando le impostazioni cultura en-US e tutti gli identificatori di formato numerico standard. Nell'esempio vengono utilizzati due tipi numerici particolari (Double e Int32), tuttavia i risultati sarebbero simili con qualsiasi altro tipo numerico di base (Byte, SByte, Int16, Int32, Int64, UInt16, UInt32, UInt64, BigInteger, Decimal e Single).

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

using System;
using System.Globalization;
using System.Threading;

public class NumericFormats
{
   public static void Main()
   {
      // 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();
   }
}

Vedere anche

Attività

Procedura: aggiungere zeri iniziali a un numero

Riferimenti

NumberFormatInfo

Concetti

Stringhe di formato numerico personalizzate

Formattazione dei tipi di dati

Cronologia delle modifiche

Data

Cronologia

Motivo

Marzo 2011

Aggiunta di un collegamento all'utilità di formattazione.

Miglioramento delle informazioni.

Luglio 2010

Aggiunta di una nota relativa all'utilizzo dell'arrotondamento per eccesso con la stringa di formato standard "C".

Commenti e suggerimenti dei clienti.