Stringhe di formato numerico standard

 

Le stringhe di formato numerico standard vengono usate per formattare tipi numerici comuni. Una stringa di formato numerico standard usa il formato Axx, dove:

  • A è un carattere alfabetico denominato identificatore di formato. 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 personalizzato.

  • xx è un numero intero facoltativo denominato identificatore di precisione. L'identificatore di precisione, compreso tra 0 e 99, controlla il numero di cifre nel risultato. 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 frazionarie nella stringa di risultato, le stringhe di risultato riflettono numeri che vengono arrotondati per eccesso (vale a dire usando MidpointRounding.AwayFromZero).

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 usata da alcuni metodi Write e WriteLine delle classi Console e StreamWriter, dal metodo String.Format e dal metodo StringBuilder.AppendFormat. La funzionalità di formattazione composta consente di includere la rappresentazione di stringa di più elementi dati in un'unica stringa per specificare la larghezza di un campo e per allinearvi i numeri all'interno. Per altre informazioni, vedere Formattazione composita.

System_CAPS_ICON_tip.jpg Suggerimento

È possibile scaricare l'utilità di formattazione, un'applicazione che consente di applicare 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'uso di stringhe di formato numerico standard e la sezione Esempio per un'illustrazione completa dell'uso.

Identificatore di formatoNomeDescrizioneEsempi
"C" o "c"ValutaRisultato: 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"DecimalRisultato: 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 fissaRisultato: 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"GeneraleRisultato: 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"NumeroRisultato: 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-RU) -> 1 234,57

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

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

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

-1234.56 ("N3", ru-RU) -> -1 234,560
"P" o "p"PercentualeRisultato: 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 tripRisultato: stringa che può eseguire il round trip a un numero identico.

Supportato da: Single, Double e BigInteger.

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"EsadecimaleRisultato: 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 singoloIdentificatore sconosciutoRisultato: genera un evento FormatException in fase di esecuzione.

È possibile usare 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 ha un parametro format. Nell'esempio seguente un valore numerico viene formattato come stringa di valuta nelle impostazioni cultura correnti (in questo caso, en-US).

          decimal value = 123.456m;
          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 = 123.456m;
          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.

          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      
    

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

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 NumberFormatInfoDescrizione
CurrencyPositivePatternDefinisce la posizione del simbolo di valuta per i valori positivi.
CurrencyNegativePatternDefinisce la posizione del simbolo di valuta per i valori negativi e specifica se il segno negativo è rappresentato da parentesi o dalla proprietà NegativeSign.
NegativeSignDefinisce il segno negativo usato se CurrencyNegativePattern indica che non vengono usate le parentesi.
CurrencySymbolDefinisce il simbolo di valuta.
CurrencyDecimalDigitsDefinisce il numero predefinito di cifre decimali in un valore di valuta. È possibile eseguire l'override di questo valore usando l'identificatore di precisione.
CurrencyDecimalSeparatorDefinisce la stringa che separa le cifre integrali da quelle decimali.
CurrencyGroupSeparatorDefinisce la stringa che separa i gruppi di numeri integrali.
CurrencyGroupSizesDefinisce il numero di cifre intere visualizzate in un gruppo.

Nell'esempio seguente viene formattato un valore Double con l'identificatore di formato di 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

Torna alla tabella

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 NumberFormatInfoDescrizione
NegativeSignDefinisce 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

Torna alla tabella

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 NumberFormatInfoDescrizione
NegativeSignDefinisce la stringa che indica che un numero è negativo sia per il coefficiente che per l'esponente.
NumberDecimalSeparatorDefinisce la stringa che separa la cifra integrale dalle cifre decimali nel coefficiente.
PositiveSignDefinisce la stringa che indica che un esponente è positivo.

Nell'esempio seguente viene formattato un valore Double 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

Torna alla tabella

L'identificatore di formato a virgola fissa ("F) converte il numero di una stringa nel formato "-ddd.ddd…" dove ciascuna "d" indica una cifra (0-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 NumberFormatInfoDescrizione
NegativeSignDefinisce la stringa che indica che un numero è negativo.
NumberDecimalSeparatorDefinisce la stringa che separa le cifre integrali da quelle decimali.
NumberDecimalDigitsDefinisce il numero predefinito di cifre decimali. È possibile eseguire l'override di questo valore usando l'identificatore di precisione.

Nell'esempio seguente vengono formattati un valore Double e un valore Int32 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                        

Torna alla tabella

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 numericoPrecisione predefinita
Byte o SByte3 cifre
Int16 o UInt165 cifre
Int32 o UInt3210 cifre
Int6419 cifre
UInt6420 cifre
BigInteger50 cifre
Single7 cifre
Double15 cifre
Decimal29 cifre

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.

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 NumberFormatInfoDescrizione
NegativeSignDefinisce la stringa che indica che un numero è negativo.
NumberDecimalSeparatorDefinisce la stringa che separa le cifre integrali da quelle decimali.
PositiveSignDefinisce la stringa che indica che un esponente è positivo.

Nell'esempio seguente vengono formattati diversi valori a virgola mobile 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    

Torna alla tabella

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 NumberFormatInfoDescrizione
NegativeSignDefinisce la stringa che indica che un numero è negativo.
NumberNegativePatternDefinisce il formato dei valori negativi e specifica se il segno negativo è rappresentato da parentesi o dalla proprietà NegativeSign.
NumberGroupSizesDefinisce il numero di cifre integrali visualizzate tra i separatori di gruppi.
NumberGroupSeparatorDefinisce la stringa che separa i gruppi di numeri integrali.
NumberDecimalSeparatorDefinisce la stringa che separa le cifre integrali da quelle decimali.
NumberDecimalDigitsDefinisce il numero predefinito di cifre decimali. È possibile eseguire l'override di questo valore usando un identificatore di precisione.

Nell'esempio seguente vengono formattati diversi valori a virgola mobile 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 

Torna alla tabella

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 NumberFormatInfoDescrizione
PercentPositivePatternDefinisce la posizione del simbolo di percentuale per i valori positivi.
PercentNegativePatternDefinisce la posizione del simbolo di percentuale e del simbolo negativo per i valori negativi.
NegativeSignDefinisce la stringa che indica che un numero è negativo.
PercentSymbolDefinisce il simbolo di percentuale.
PercentDecimalDigitsDefinisce il numero predefinito di cifre decimali in un valore percentuale. È possibile eseguire l'override di questo valore usando l'identificatore di precisione.
PercentDecimalSeparatorDefinisce la stringa che separa le cifre integrali da quelle decimali.
PercentGroupSeparatorDefinisce la stringa che separa i gruppi di numeri integrali.
PercentGroupSizesDefinisce 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.

      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

L'identificatore di formato di round trip ("R") viene usato per garantire 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 usando 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 usando 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 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 NumberFormatInfoDescrizione
NegativeSignDefinisce la stringa che indica che un numero è negativo.
NumberDecimalSeparatorDefinisce la stringa che separa le cifre integrali da quelle decimali.
PositiveSignDefinisce la stringa che indica che un esponente è positivo.

Nell'esempio seguente vengono formattati valori Double con l'identificatore di formato round trip.

      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

System_CAPS_ICON_important.jpg 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 ovviare al problema dei valori Double formattati con la stringa di formato numerico standard "R" che non completano correttamente il round trip se compilati usando l'opzione /platform:x64 o /platform:anycpu e in esecuzione in sistemi a 64 bit, è possibile formattare i valori Double usando la stringa di formato numerico standard "G17". Nell'esempio seguente viene usata la stringa di formato "R" con un valore Double che non completa il round trip e viene anche usata la stringa di formato "G17" per completare correttamente il round trip sul valore originale.

using System;
using System.Globalization;

public class Example
{
   static void Main(string[] args)
   {
      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':
//       0.6822871999174 = 0.68228719991740006: False
//
//       Attempting to round-trip a Double with 'G17':
//       0.6822871999174 = 0.6822871999174: True

Torna alla tabella

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

Torna alla tabella

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 usate per inizializzare l'oggetto NumberFormatInfo associato alle impostazioni cultura del thread corrente, che fornisce i valori usati per definire la formattazione. Computer con impostazioni diverse generano stringhe di risultato diverse.

Inoltre, se viene usato 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 usare 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.

System_CAPS_ICON_note.jpg 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, 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.

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. Nell'esempio vengono usati 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).

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

NumberFormatInfo
Stringhe di formato numerico personalizzato
Formattazione di tipi
Procedura: aggiungere zeri iniziali a un numero
Esempio: Utilità di formattazione in .NET Framework 4
Formattazione composita

Mostra: