Stringhe di formato numerico standardStandard Numeric Format Strings

Le stringhe di formato numerico standard vengono usate per formattare tipi numerici comuni.Standard numeric format strings are used to format common numeric types. Una stringa di formato numerico standard usa il formato Axx, dove:A standard numeric format string takes the form Axx, where:

  • A è un carattere alfabetico denominato identificatore di formato.A is a single alphabetic character called the format specifier. Le stringhe di formato numerico contenenti più caratteri alfabetici, inclusi gli spazi, vengono interpretate come stringhe di formato numerico personalizzate.Any numeric format string that contains more than one alphabetic character, including white space, is interpreted as a custom numeric format string. Per altre informazioni, vedere Stringhe di formato numerico personalizzato.For more information, see Custom Numeric Format Strings.

  • xx è un numero intero facoltativo denominato identificatore di precisione.xx is an optional integer called the precision specifier. L'identificatore di precisione, compreso tra 0 e 99, controlla il numero di cifre nel risultato.The precision specifier ranges from 0 to 99 and affects the number of digits in the result. L'identificatore di precisione controlla il numero di cifre nella rappresentazione di stringa di un numero.Note that the precision specifier controls the number of digits in the string representation of a number. Non arrotonda il numero stesso.It does not round the number itself. Per eseguire un'operazione di arrotondamento, usare il metodo Math.Ceiling, Math.Floor o Math.Round.To perform a rounding operation, use the Math.Ceiling, Math.Floor, or Math.Round method.

    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.When precision specifier controls the number of fractional digits in the result string, the result string reflects a number that is rounded to a representable result nearest to the infinitely precise result. In presenza di due risultati rappresentabili equivalenti:If there are two equally near representable results:

    • In .NET Framework e .NET Core fino alla versione .NET Core 2.0 il runtime seleziona il risultato con la cifra meno significativa maggiore, ovvero usando MidpointRounding.AwayFromZero.On the .NET Framework and .NET Core up to .NET Core 2.0, the runtime selects the result with the greater least significant digit (that is, using 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.On .NET Core 2.1 and later, the runtime selects the result with an even least significant digit (that is, using MidpointRounding.ToEven).

    Nota

    L'identificatore di precisione determina il numero di cifre nella stringa risultato.The precision specifier determines the number of digits in the result string. 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.To pad a result string with leading or trailing spaces, use the composite formatting feature and define an alignment component in the format item.

Le stringhe di formato numerico standard sono supportate:Standard numeric format strings are supported by:

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.You can download the Formatting Utility, an application that enables you to apply format strings to either numeric or date and time values and displays the result string.

La tabella seguente descrive gli identificatori di formato numerico standard e visualizza l'output di esempio prodotto da ogni identificatore di formato.The following table describes the standard numeric format specifiers and displays sample output produced by each format specifier. 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.See the Notes section for additional information about using standard numeric format strings, and the Example section for a comprehensive illustration of their use.

Identificatore di formatoFormat specifier nomeName DescriptionDescription EsempiExamples
"C" o "c""C" or "c" ValutaCurrency Risultato: un valore di valuta.Result: A currency value.

Supportato da: tutti i tipi numerici.Supported by: All numeric types.

Identificatore di precisione: numero di posizioni decimali.Precision specifier: Number of decimal digits.

Identificatore di precisione predefinito: definito da NumberFormatInfo.CurrencyDecimalDigits.Default precision specifier: Defined by NumberFormatInfo.CurrencyDecimalDigits.

Altre informazioni: Identificatore di formato di valuta ("C").More information: The Currency ("C") Format Specifier.
123.456 ("C", en-US) -> $123.46123.456 ("C", en-US) -> $123.46

123.456 ("C", fr-FR) -> 123,46 €123.456 ("C", fr-FR) -> 123,46 €

123.456 ("C", ja-JP) -> ¥123123.456 ("C", ja-JP) -> ¥123

-123.456 ("C3", en-US) -> ($123.456)-123.456 ("C3", en-US) -> ($123.456)

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

-123.456 ("C3", ja-JP) -> -¥123.456-123.456 ("C3", ja-JP) -> -¥123.456
"D" o "d""D" or "d" DecimaleDecimal Risultato: cifre intere con segno negativo facoltativo.Result: Integer digits with optional negative sign.

Supportato da: solo tipi integrali.Supported by: Integral types only.

Identificatore di precisione: numero minimo di cifre.Precision specifier: Minimum number of digits.

Identificatore di precisione predefinito: numero minimo di cifre richieste.Default precision specifier: Minimum number of digits required.

Altre informazioni: Identificatore di formato decimale ("D").More information: The Decimal("D") Format Specifier.
1234 ("D") -> 12341234 ("D") -> 1234

-1234 ("D6") -> -001234-1234 ("D6") -> -001234
"E" o "e""E" or "e" Esponenziale (scientifico)Exponential (scientific) Risultato: notazione esponenziale.Result: Exponential notation.

Supportato da: tutti i tipi numerici.Supported by: All numeric types.

Identificatore di precisione: numero di posizioni decimali.Precision specifier: Number of decimal digits.

Identificatore di precisione predefinito: 6.Default precision specifier: 6.

Altre informazioni: Identificatore di formato esponenziale ("E").More information: The Exponential ("E") Format Specifier.
1052.0329112756 ("E", en-US) -> 1.052033E+0031052.0329112756 ("E", en-US) -> 1.052033E+003

1052.0329112756 ("e", fr-FR) -> 1,052033e+0031052.0329112756 ("e", fr-FR) -> 1,052033e+003

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

-1052.0329112756 ("E2", fr-FR) -> -1,05E+003-1052.0329112756 ("E2", fr-FR) -> -1,05E+003
"F" o "f""F" or "f" A virgola fissaFixed-point Risultato: cifre integrali e decimali con segno negativo facoltativo.Result: Integral and decimal digits with optional negative sign.

Supportato da: tutti i tipi numerici.Supported by: All numeric types.

Identificatore di precisione: numero di posizioni decimali.Precision specifier: Number of decimal digits.

Identificatore di precisione predefinito: definito da NumberFormatInfo.NumberDecimalDigits.Default precision specifier: Defined by NumberFormatInfo.NumberDecimalDigits.

Altre informazioni: Identificatore di formato a virgola fissa ("F").More information: The Fixed-Point ("F") Format Specifier.
1234.567 ("F", en-US) -> 1234.571234.567 ("F", en-US) -> 1234.57

1234.567 ("F", de-DE) -> 1234,571234.567 ("F", de-DE) -> 1234,57

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

1234 ("F1", de-DE) -> 1234,01234 ("F1", de-DE) -> 1234,0

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

-1234.56 ("F4", de-DE) -> -1234,5600-1234.56 ("F4", de-DE) -> -1234,5600
"G" o "g""G" or "g" GeneraleGeneral Risultato: la più compatta tra la notazione a virgola fissa e quella scientifica.Result: The more compact of either fixed-point or scientific notation.

Supportato da: tutti i tipi numerici.Supported by: All numeric types.

Identificatore di precisione: numero di cifre significative.Precision specifier: Number of significant digits.

Identificatore di precisione predefinito: dipende dal tipo numerico.Default precision specifier: Depends on numeric type.

Altre informazioni: Identificatore di formato generale ("G").More information: The General ("G") Format Specifier.
-123.456 ("G", en-US) -> -123.456-123.456 ("G", en-US) -> -123.456

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

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

123.4546 ("G4", sv-SE) -> 123,5123.4546 ("G4", sv-SE) -> 123,5

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

-1.234567890e-25 ("G", sv-SE) -> -1,23456789E-25-1.234567890e-25 ("G", sv-SE) -> -1,23456789E-25
"N" o "n""N" or "n" NumberNumber Risultato: cifre integrali e decimali, separatori di gruppi e un separatore decimale con segno negativo facoltativo.Result: Integral and decimal digits, group separators, and a decimal separator with optional negative sign.

Supportato da: tutti i tipi numerici.Supported by: All numeric types.

Identificatore di precisione: numero di posizioni decimali desiderate.Precision specifier: Desired number of decimal places.

Identificatore di precisione predefinito: definito da NumberFormatInfo.NumberDecimalDigits.Default precision specifier: Defined by NumberFormatInfo.NumberDecimalDigits.

Altre informazioni: Identificatore di formato numerico ("N").More information: The Numeric ("N") Format Specifier.
1234.567 ("N", en-US) -> 1,234.571234.567 ("N", en-US) -> 1,234.57

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

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

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

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

-1234.56 ("N3", ru-RU) -> -1 234,560-1234.56 ("N3", ru-RU) -> -1 234,560
"P" o "p""P" or "p" PercentualePercent Risultato: numero moltiplicato per 100 e visualizzato con un simbolo di percentuale.Result: Number multiplied by 100 and displayed with a percent symbol.

Supportato da: tutti i tipi numerici.Supported by: All numeric types.

Identificatore di precisione: numero di posizioni decimali desiderate.Precision specifier: Desired number of decimal places.

Identificatore di precisione predefinito: definito da NumberFormatInfo.PercentDecimalDigits.Default precision specifier: Defined by NumberFormatInfo.PercentDecimalDigits.

Altre informazioni: Identificatore di formato percentuale ("P").More information: The Percent ("P") Format Specifier.
1 ("P", en-US) -> 100.00 %1 ("P", en-US) -> 100.00 %

1 ("P", fr-FR) -> 100,00 %1 ("P", fr-FR) -> 100,00 %

-0.39678 ("P1", en-US) -> -39.7 %-0.39678 ("P1", en-US) -> -39.7 %

-0.39678 ("P1", fr-FR) -> -39,7 %-0.39678 ("P1", fr-FR) -> -39,7 %
"R" o "r""R" or "r" Round tripRound-trip Risultato: stringa che può eseguire il round trip a un numero identico.Result: A string that can round-trip to an identical number.

Supportato da: Single, Double e BigInteger.Supported by: Single, Double, and BigInteger.

Nota: consigliato solo per il tipo BigInteger.Note: Recommended for the BigInteger type only. Per i tipi Double, usare "G17"; per i tipi Single, usare "G9".For Double types, use "G17"; for Single types, use "G9".
Identificatore di precisione: Ignorato.Precision specifier: Ignored.

Altre informazioni: Identificatore di formato di round trip ("R").More information: The Round-trip ("R") Format Specifier.
123456789.12345678 ("R") -> 123456789.12345678123456789.12345678 ("R") -> 123456789.12345678

-1234567890.12345678 ("R") -> -1234567890.1234567-1234567890.12345678 ("R") -> -1234567890.1234567
"X" o "x""X" or "x" EsadecimaleHexadecimal Risultato: stringa esadecimale.Result: A hexadecimal string.

Supportato da: solo tipi integrali.Supported by: Integral types only.

Identificatore di precisione: numero di cifre nella stringa di risultato.Precision specifier: Number of digits in the result string.

Altre informazioni: Identificatore di formato esadecimale ("X").More information: The HexaDecimal ("X") Format Specifier.
255 ("X") -> FF255 ("X") -> FF

-1 ("x") -> ff-1 ("x") -> ff

255 ("x4") -> 00ff255 ("x4") -> 00ff

-1 ("X4") -> 00FF-1 ("X4") -> 00FF
Qualsiasi altro carattere singoloAny other single character Identificatore sconosciutoUnknown specifier Risultato: genera un evento FormatException in fase di esecuzione.Result: Throws a FormatException at run time.

uso di stringhe di formato numerico standardUsing Standard Numeric Format Strings

Nota

Gli esempi in C# in questo articolo vengono eseguiti nello strumento di esecuzione e playground per codice inline Try.NET.The C# examples in this article run in the Try.NET inline code runner and playground. Selezionare il pulsante Esegui per eseguire un esempio in una finestra interattiva.Select the Run button to run an example in an interactive window. Dopo aver eseguito il codice, è possibile modificarlo ed eseguire il codice modificato selezionando di nuovo Esegui.Once you execute the code, you can modify it and run the modified code by selecting Run again. 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#.The modified code either runs in the interactive window or, if compilation fails, the interactive window displays all C# compiler error messages.

È possibile usare una stringa di formato numerico standard per definire la formattazione di un valore numerico in uno dei due modi seguenti:A standard numeric format string can be used to define the formatting of a numeric value in one of two ways:

  • È possibile passare la stringa a un overload del metodo ToString che ha un parametro format.It can be passed to an overload of the ToString method that has a format parameter. Nell'esempio seguente un valore numerico viene formattato come stringa di valuta nelle impostazioni cultura correnti (in questo caso, en-US).The following example formats a numeric value as a currency string in the current culture (in this case, the en-US culture).

    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.It can be supplied as the formatString argument in a format item used with such methods as String.Format, Console.WriteLine, and StringBuilder.AppendFormat. Per altre informazioni, vedere Formattazione composita.For more information, see Composite Formatting. Nell'esempio seguente viene usato un elemento di formato per inserire un valore di valuta in una stringa.The following example uses a format item to insert a currency value in a string.

    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.Optionally, you can supply an alignment argument to specify the width of the numeric field and whether its value is right- or left-aligned. 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.The following example left-aligns a currency value in a 28-character field, and it right-aligns a currency value in a 14-character field.

    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.It can be supplied as the formatString argument in an interpolated expression item of an interpolated string. Per altre informazioni, vedere l'argomento Interpolazione di stringhe nelle informazioni di riferimento di C# o l'argomento Stringhe interpolate nelle informazioni di riferimento di Visual Basic.For more information, see the String interpolation topic in the C# reference or the Interpolated strings topic in the Visual Basic reference.

Nelle sezioni seguenti vengono fornite informazioni dettagliate su ognuna delle stringhe di formato numerico standard.The following sections provide detailed information about each of the standard numeric format strings.

Identificatore di formato di valuta ("C")The Currency ("C") Format Specifier

L'identificatore di formato di valuta ("C") consente di convertire un numero in una stringa che rappresenta un importo di valuta.The "C" (or currency) format specifier converts a number to a string that represents a currency amount. L'identificatore di precisione indica il numero desiderato di posizioni decimali nella stringa di risultato.The precision specifier indicates the desired number of decimal places in the result string. Se l'identificatore di precisione viene omesso, viene usata la precisione predefinita definita dalla proprietà NumberFormatInfo.CurrencyDecimalDigits.If the precision specifier is omitted, the default precision is defined by the NumberFormatInfo.CurrencyDecimalDigits property.

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.If the value to be formatted has more than the specified or default number of decimal places, the fractional value is rounded in the result string. 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.If the value to the right of the number of specified decimal places is 5 or greater, the last digit in the result string is rounded away from zero.

La stringa di risultato è influenzata dalle informazioni sulla formattazione dell'oggetto NumberFormatInfo corrente.The result string is affected by the formatting information of the current NumberFormatInfo object. Nella tabella seguente sono elencate le proprietà di NumberFormatInfo che consentono di controllare la formattazione della stringa restituita.The following table lists the NumberFormatInfo properties that control the formatting of the returned string.

Proprietà di NumberFormatInfoNumberFormatInfo property DescriptionDescription
CurrencyPositivePattern Definisce la posizione del simbolo di valuta per i valori positivi.Defines the placement of the currency symbol for positive values.
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.Defines the placement of the currency symbol for negative values, and specifies whether the negative sign is represented by parentheses or the NegativeSign property.
NegativeSign Definisce il segno negativo usato se CurrencyNegativePattern indica che non vengono usate le parentesi.Defines the negative sign used if CurrencyNegativePattern indicates that parentheses are not used.
CurrencySymbol Definisce il simbolo di valuta.Defines the currency symbol.
CurrencyDecimalDigits Definisce il numero predefinito di cifre decimali in un valore di valuta.Defines the default number of decimal digits in a currency value. È possibile eseguire l'override di questo valore usando l'identificatore di precisione.This value can be overridden by using the precision specifier.
CurrencyDecimalSeparator Definisce la stringa che separa le cifre integrali da quelle decimali.Defines the string that separates integral and decimal digits.
CurrencyGroupSeparator Definisce la stringa che separa i gruppi di numeri integrali.Defines the string that separates groups of integral numbers.
CurrencyGroupSizes Definisce il numero di cifre intere visualizzate in un gruppo.Defines the number of integer digits that appear in a group.

Nell'esempio seguente viene formattato un valore Double con l'identificatore di formato di valuta.The following example formats a Double value with the currency format specifier.

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

Torna alla tabellaBack to table

Identificatore di formato decimale ("D")The Decimal ("D") Format Specifier

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.The "D" (or decimal) format specifier converts a number to a string of decimal digits (0-9), prefixed by a minus sign if the number is negative. Questo formato è supportato solo per i tipi integrali.This format is supported only for integral types.

L'identificatore di precisione indica il numero minimo di cifre che si vogliono visualizzare nella stringa risultante.The precision specifier indicates the minimum number of digits desired in the resulting string. Se necessario, alla sinistra del numero verranno aggiunti degli zeri in modo da raggiungere il numero di cifre specificato dall'identificatore di precisione.If required, the number is padded with zeros to its left to produce the number of digits given by the precision specifier. Se non viene specificato alcun identificatore di precisione, il valore predefinito corrisponde al valore minimo richiesto per rappresentare il numero intero senza zeri iniziali.If no precision specifier is specified, the default is the minimum value required to represent the integer without leading zeros.

La stringa di risultato è influenzata dalle informazioni sulla formattazione dell'oggetto NumberFormatInfo corrente.The result string is affected by the formatting information of the current NumberFormatInfo object. Come illustrato nella tabella seguente, una singola proprietà influisce sulla formattazione della stringa di risultato.As the following table shows, a single property affects the formatting of the result string.

Proprietà di NumberFormatInfoNumberFormatInfo property DescriptionDescription
NegativeSign Definisce la stringa che indica che un numero è negativo.Defines the string that indicates that a number is negative.

Nell'esempio seguente viene formattato un valore Int32 con l'identificatore di formato decimale.The following example formats an Int32 value with the decimal format specifier.

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

Torna alla tabellaBack to table

Identificatore di formato esponenziale ("E")The Exponential ("E") Format Specifier

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.The exponential ("E") format specifier converts a number to a string of the form "-d.ddd…E+ddd" or "-d.ddd…e+ddd", where each "d" indicates a digit (0-9). Se il numero è negativo, la stringa inizierà con un segno meno.The string starts with a minus sign if the number is negative. Il separatore decimale è sempre preceduto esattamente da una cifra.Exactly one digit always precedes the decimal point.

L'identificatore di precisione indica il numero di cifre desiderato dopo il separatore decimale.The precision specifier indicates the desired number of digits after the decimal point. Se l'identificatore di precisione viene omesso, verrà usato il numero predefinito di sei cifre dopo il separatore decimale.If the precision specifier is omitted, a default of six digits after the decimal point is used.

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".The case of the format specifier indicates whether to prefix the exponent with an "E" or an "e". L'esponente consiste sempre in un segno più o meno e in un minimo di tre cifre.The exponent always consists of a plus or minus sign and a minimum of three digits. Se necessario, vengono aggiunti all'esponente degli zeri in modo da raggiungere tale numero di cifre.The exponent is padded with zeros to meet this minimum, if required.

La stringa di risultato è influenzata dalle informazioni sulla formattazione dell'oggetto NumberFormatInfo corrente.The result string is affected by the formatting information of the current NumberFormatInfo object. Nella tabella seguente sono elencate le proprietà di NumberFormatInfo che consentono di controllare la formattazione della stringa restituita.The following table lists the NumberFormatInfo properties that control the formatting of the returned string.

Proprietà di NumberFormatInfoNumberFormatInfo property DescriptionDescription
NegativeSign Definisce la stringa che indica che un numero è negativo sia per il coefficiente che per l'esponente.Defines the string that indicates that a number is negative for both the coefficient and exponent.
NumberDecimalSeparator Definisce la stringa che separa la cifra integrale dalle cifre decimali nel coefficiente.Defines the string that separates the integral digit from decimal digits in the coefficient.
PositiveSign Definisce la stringa che indica che un esponente è positivo.Defines the string that indicates that an exponent is positive.

Nell'esempio seguente viene formattato un valore Double con l'identificatore di formato esponenziale.The following example formats a Double value with the exponential format specifier.

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

Torna alla tabellaBack to table

Identificatore di formato a virgola fissa ("F")The Fixed-Point ("F") Format Specifier

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.The fixed-point ("F") format specifier converts a number to a string of the form "-ddd.ddd…" where each "d" indicates a digit (0-9). Se il numero è negativo, la stringa inizierà con un segno meno.The string starts with a minus sign if the number is negative.

L'identificatore di precisione indica il numero di posizioni decimali desiderato.The precision specifier indicates the desired number of decimal places. Se l'identificatore di precisione viene omesso, la precisione numerica viene fornita dalla proprietà NumberFormatInfo.NumberDecimalDigits corrente.If the precision specifier is omitted, the current NumberFormatInfo.NumberDecimalDigits property supplies the numeric precision.

La stringa di risultato è influenzata dalle informazioni sulla formattazione dell'oggetto NumberFormatInfo corrente.The result string is affected by the formatting information of the current NumberFormatInfo object. Nella tabella seguente sono elencate le proprietà dell'oggetto NumberFormatInfo che consentono di controllare la formattazione della stringa di risultato.The following table lists the properties of the NumberFormatInfo object that control the formatting of the result string.

Proprietà di NumberFormatInfoNumberFormatInfo property DescriptionDescription
NegativeSign Definisce la stringa che indica che un numero è negativo.Defines the string that indicates that a number is negative.
NumberDecimalSeparator Definisce la stringa che separa le cifre integrali da quelle decimali.Defines the string that separates integral digits from decimal digits.
NumberDecimalDigits Definisce il numero predefinito di cifre decimali.Defines the default number of decimal digits. È possibile eseguire l'override di questo valore usando l'identificatore di precisione.This value can be overridden by using the precision specifier.

Nell'esempio seguente vengono formattati un valore Double e un valore Int32 con l'identificatore di formato a virgola fissa.The following example formats a Double and an Int32 value with the fixed-point format specifier.

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                        

Torna alla tabellaBack to table

Identificatore di formato generale ("G")The General ("G") Format Specifier

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.The general ("G") format specifier converts a number to the more compact of either fixed-point or scientific notation, depending on the type of the number and whether a precision specifier is present. L'identificatore di precisione definisce il numero massimo di cifre significative che possono essere visualizzate nella stringa di risultato.The precision specifier defines the maximum number of significant digits that can appear in the result string. Se l'identificatore di precisione viene omesso o è uguale a zero, il tipo di numero determina la precisione predefinita, come indicato nella tabella seguente.If the precision specifier is omitted or zero, the type of the number determines the default precision, as indicated in the following table.

Tipo numericoNumeric type Precisione predefinitaDefault precision
Byte o SByteByte or SByte 3 cifre3 digits
Int16 o UInt16Int16 or UInt16 5 cifre5 digits
Int32 o UInt32Int32 or UInt32 10 cifre10 digits
Int64 19 cifre19 digits
UInt64 20 cifre20 digits
BigInteger Senza limiti (come "R")Unlimited (same as "R")
Single 7 cifre7 digits
Double 15 cifre15 digits
Decimal 29 cifre29 digits

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.Fixed-point notation is used if the exponent that would result from expressing the number in scientific notation is greater than -5 and less than the precision specifier; otherwise, scientific notation is used. Il risultato contiene un separatore decimale, se richiesto, e gli zeri finali dopo la virgola decimale vengono omessi.The result contains a decimal point if required, and trailing zeros after the decimal point are omitted. 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.If the precision specifier is present and the number of significant digits in the result exceeds the specified precision, the excess trailing digits are removed by rounding.

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.However, if the number is a Decimal and the precision specifier is omitted, fixed-point notation is always used and trailing zeros are preserved.

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".If scientific notation is used, the exponent in the result is prefixed with "E" if the format specifier is "G", or "e" if the format specifier is "g". L'esponente contiene un minimo di due cifre.The exponent contains a minimum of two digits. 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.This differs from the format for scientific notation that is produced by the exponential format specifier, which includes a minimum of three digits in the exponent.

Si noti che, se usato con un valore Double, l'identificatore di formato "G17" assicura che il valore Double originale esegua correttamente il round trip.Note that, when used with a Double value, the "G17" format specifier ensures that the original Double value successfully round-trips. Ciò è dovuto al fatto che Double è un numero in formato a virgola mobile a doppia precisione (binary64) conforme allo standard IEEE 754-2008, caratterizzato da una precisione con fino a 17 cifre significative.This is because Double is an IEEE 754-2008-compliant double-precision (binary64) floating point number that gives up to 17 significant digits of precision. Se ne consiglia l'uso al posto dell'identificatore di formato "R", dal momento che in alcuni casi "R" non esegue correttamente il round trip dei valori a virgola mobile e precisione doppia.We recommend its use instead of the "R" format specifier, since in some cases "R" fails to successfully round-trip double-precision floating point values. Nell'esempio riportato di seguito viene illustrato un caso di questo tipo.The following example illustrates one such case.

double original = 0.84551240822557006;
var rSpecifier = original.ToString("R");
var g17Specifier = original.ToString("G17");

var rValue = Double.Parse(rSpecifier);
var g17Value = Double.Parse(g17Specifier);

Console.WriteLine($"{original:G17} = {rSpecifier} (R): {original.Equals(rValue)}");
Console.WriteLine($"{original:G17} = {g17Specifier} (G17): {original.Equals(g17Value)}");
// The example displays the following output:
//     0.84551240822557006 = 0.84551240822557: False
//     0.84551240822557006 = 0.84551240822557006: True
Module Example
   Public Sub Main()
      Dim original As Double = 0.84551240822557006
      Dim rSpecifier = original.ToString("R")
      Dim g17Specifier = original.ToString("G17")
      
      Dim rValue = Double.Parse(rSpecifier)
      Dim g17Value = Double.Parse(g17Specifier)
      
      Console.WriteLine($"{original:G17} = {rSpecifier} (R): {original.Equals(rValue)}")
      Console.WriteLine($"{original:G17} = {g17Specifier} (G17): {original.Equals(g17Value)}")
   End Sub
End Module
' The example displays the following output:
'     0.84551240822557006 = 0.84551240822557 (R): False
'     0.84551240822557006 = 0.84551240822557006 (G17): True
  

Se usato con un valore Single, l'identificatore di formato "G9" assicura che il valore Single originale esegua correttamente il round trip.When used with a Single value, the "G9" format specifier ensures that the original Single value successfully round-trips. Ciò è dovuto al fatto che Single è un numero in formato a virgola mobile a precisione singola (binary32) conforme allo standard IEEE 754-2008, caratterizzato da una precisione con fino a nove cifre significative.This is because Single is an IEEE 754-2008-compliant single-precision (binary32) floating point number that gives up to nine significant digits of precision. Per motivi di prestazioni, è consigliabile usare questo anziché l'identificatore di formato "R".For performance reasons, we recommend its use instead of the "R" format specifier.

La stringa di risultato è influenzata dalle informazioni sulla formattazione dell'oggetto NumberFormatInfo corrente.The result string is affected by the formatting information of the current NumberFormatInfo object. Nella tabella seguente sono elencate le proprietà di NumberFormatInfo che consentono di controllare la formattazione della stringa di risultato.The following table lists the NumberFormatInfo properties that control the formatting of the result string.

Proprietà di NumberFormatInfoNumberFormatInfo property DescriptionDescription
NegativeSign Definisce la stringa che indica che un numero è negativo.Defines the string that indicates that a number is negative.
NumberDecimalSeparator Definisce la stringa che separa le cifre integrali da quelle decimali.Defines the string that separates integral digits from decimal digits.
PositiveSign Definisce la stringa che indica che un esponente è positivo.Defines the string that indicates that an exponent is positive.

Nell'esempio seguente vengono formattati diversi valori a virgola mobile con l'identificatore di formato generale.The following example formats assorted floating-point values with the general format specifier.

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    

Torna alla tabellaBack to table

Identificatore di formato numerico ("N")The Numeric ("N") Format Specifier

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.The numeric ("N") format specifier converts a number to a string of the form "-d,ddd,ddd.ddd…", where "-" indicates a negative number symbol if required, "d" indicates a digit (0-9), "," indicates a group separator, and "." indicates a decimal point symbol. L'identificatore di precisione indica il numero di cifre desiderato dopo il separatore decimale.The precision specifier indicates the desired number of digits after the decimal point. Se l'identificatore di precisione viene omesso, il numero di cifre decimali viene definito dalla proprietà NumberFormatInfo.NumberDecimalDigits corrente.If the precision specifier is omitted, the number of decimal places is defined by the current NumberFormatInfo.NumberDecimalDigits property.

La stringa di risultato è influenzata dalle informazioni sulla formattazione dell'oggetto NumberFormatInfo corrente.The result string is affected by the formatting information of the current NumberFormatInfo object. Nella tabella seguente sono elencate le proprietà di NumberFormatInfo che consentono di controllare la formattazione della stringa di risultato.The following table lists the NumberFormatInfo properties that control the formatting of the result string.

Proprietà di NumberFormatInfoNumberFormatInfo property DescriptionDescription
NegativeSign Definisce la stringa che indica che un numero è negativo.Defines the string that indicates that a number is negative.
NumberNegativePattern Definisce il formato dei valori negativi e specifica se il segno negativo è rappresentato da parentesi o dalla proprietà NegativeSign.Defines the format of negative values, and specifies whether the negative sign is represented by parentheses or the NegativeSign property.
NumberGroupSizes Definisce il numero di cifre integrali visualizzate tra i separatori di gruppi.Defines the number of integral digits that appear between group separators.
NumberGroupSeparator Definisce la stringa che separa i gruppi di numeri integrali.Defines the string that separates groups of integral numbers.
NumberDecimalSeparator Definisce la stringa che separa le cifre integrali da quelle decimali.Defines the string that separates integral and decimal digits.
NumberDecimalDigits Definisce il numero predefinito di cifre decimali.Defines the default number of decimal digits. È possibile eseguire l'override di questo valore usando un identificatore di precisione.This value can be overridden by using a precision specifier.

Nell'esempio seguente vengono formattati diversi valori a virgola mobile con l'identificatore di formato numerico.The following example formats assorted floating-point values with the number format specifier.

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 

Torna alla tabellaBack to table

Identificatore di formato percentuale ("P")The Percent ("P") Format Specifier

L'identificatore di formato percentuale ("P") moltiplica un numero per 100 e lo converte in una stringa che rappresenta una percentuale.The percent ("P") format specifier multiplies a number by 100 and converts it to a string that represents a percentage. L'identificatore di precisione indica il numero di posizioni decimali desiderato.The precision specifier indicates the desired number of decimal places. Se l'identificatore di precisione viene omesso, viene usata la precisione numerica predefinita fornita dalla proprietà PercentDecimalDigits corrente.If the precision specifier is omitted, the default numeric precision supplied by the current PercentDecimalDigits property is used.

Nella tabella seguente sono elencate le proprietà di NumberFormatInfo che consentono di controllare la formattazione della stringa restituita.The following table lists the NumberFormatInfo properties that control the formatting of the returned string.

Proprietà di NumberFormatInfoNumberFormatInfo property DescriptionDescription
PercentPositivePattern Definisce la posizione del simbolo di percentuale per i valori positivi.Defines the placement of the percent symbol for positive values.
PercentNegativePattern Definisce la posizione del simbolo di percentuale e del simbolo negativo per i valori negativi.Defines the placement of the percent symbol and the negative symbol for negative values.
NegativeSign Definisce la stringa che indica che un numero è negativo.Defines the string that indicates that a number is negative.
PercentSymbol Definisce il simbolo di percentuale.Defines the percent symbol.
PercentDecimalDigits Definisce il numero predefinito di cifre decimali in un valore percentuale.Defines the default number of decimal digits in a percentage value. È possibile eseguire l'override di questo valore usando l'identificatore di precisione.This value can be overridden by using the precision specifier.
PercentDecimalSeparator Definisce la stringa che separa le cifre integrali da quelle decimali.Defines the string that separates integral and decimal digits.
PercentGroupSeparator Definisce la stringa che separa i gruppi di numeri integrali.Defines the string that separates groups of integral numbers.
PercentGroupSizes Definisce il numero di cifre intere visualizzate in un gruppo.Defines the number of integer digits that appear in a group.

Nell'esempio seguente vengono formattati diversi valori a virgola mobile con l'identificatore di formato percentuale.The following example formats floating-point values with the percent format specifier.

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 %

Torna alla tabellaBack to table

Identificatore di formato di round trip ("R")The Round-trip ("R") Format Specifier

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.The round-trip ("R") format specifier attempts to ensure that a numeric value that is converted to a string is parsed back into the same numeric value. Questo formato è supportato solo per i tipi Single, Double e BigInteger.This format is supported only for the Single, Double, and BigInteger types.

Per i valori Double l'identificatore di formato "R" in alcuni casi non esegue correttamente il round trip del valore originale.For Double values, the "R" format specifier in some cases fails to successfully round-trip the original value. Per entrambi i valori Double e Single, garantisce poi prestazioni relativamente scarse.For both Double and Single values, it also offers relatively poor performance. È 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.Instead, we recommend that you use the "G17" format specifier for Double values and the "G9" format specifier to successfully round-trip Single values.

Quando un valore BigInteger viene formattato usando questo identificatore, la relativa rappresentazione di stringa contiene tutte le cifre significative nel valore BigInteger.When a BigInteger value is formatted using this specifier, its string representation contains all the significant digits in the BigInteger value.

Sebbene sia possibile includere un identificatore di precisione, questo viene ignorato.Although you can include a precision specifier, it is ignored. Quando si usa questo identificatore, infatti, il formato della riconversione ha la precedenza sulla precisione.Round trips are given precedence over precision when using this specifier.
La stringa di risultato è influenzata dalle informazioni sulla formattazione dell'oggetto NumberFormatInfo corrente.The result string is affected by the formatting information of the current NumberFormatInfo object. Nella tabella seguente sono elencate le proprietà di NumberFormatInfo che consentono di controllare la formattazione della stringa di risultato.The following table lists the NumberFormatInfo properties that control the formatting of the result string.

Proprietà di NumberFormatInfoNumberFormatInfo property DescriptionDescription
NegativeSign Definisce la stringa che indica che un numero è negativo.Defines the string that indicates that a number is negative.
NumberDecimalSeparator Definisce la stringa che separa le cifre integrali da quelle decimali.Defines the string that separates integral digits from decimal digits.
PositiveSign Definisce la stringa che indica che un esponente è positivo.Defines the string that indicates that an exponent is positive.

Nell'esempio seguente viene formattato un valore BigInteger con l'identificatore di formato round trip.The following example formats a BigInteger value with the round-trip format specifier.

#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.In some cases, Double values formatted with the "R" standard numeric format string do not successfully round-trip if compiled using the /platform:x64 or /platform:anycpu switches and run on 64-bit systems. Per altre informazioni, vedere il paragrafo seguente.See the following paragraph for more information.

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".To work around the problem of Double values formatted with the "R" standard numeric format string not successfully round-tripping if compiled using the /platform:x64 or /platform:anycpu switches and run on 64-bit systems., you can format Double values by using the "G17" standard numeric format string. 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.The following example uses the "R" format string with a Double value that does not round-trip successfully, and also uses the "G17" format string to successfully round-trip the original value.

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
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':
'       0.6822871999174 = 0.68228719991740006: False
'
'       Attempting to round-trip a Double with 'G17':
'       0.6822871999174 = 0.6822871999174: True

Torna alla tabellaBack to table

Identificatore di formato esadecimale ("X")The Hexadecimal ("X") Format Specifier

L'identificatore di formato esadecimale ("X") consente di convertire un numero in una stringa di cifre esadecimali.The hexadecimal ("X") format specifier converts a number to a string of hexadecimal digits. 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.The case of the format specifier indicates whether to use uppercase or lowercase characters for hexadecimal digits that are greater than 9. usare ad esempio "X" per produrre la stringa "ABCDEF" e "x" per produrre "abcdef".For example, use "X" to produce "ABCDEF", and "x" to produce "abcdef". Questo formato è supportato solo per i tipi integrali.This format is supported only for integral types.

L'identificatore di precisione indica il numero minimo di cifre che si vogliono visualizzare nella stringa risultante.The precision specifier indicates the minimum number of digits desired in the resulting string. Se necessario, alla sinistra del numero verranno aggiunti degli zeri in modo da raggiungere il numero di cifre specificato dall'identificatore di precisione.If required, the number is padded with zeros to its left to produce the number of digits given by the precision specifier.

La stringa di risultato non è influenzata dalle informazioni sulla formattazione dell'oggetto NumberFormatInfo corrente.The result string is not affected by the formatting information of the current NumberFormatInfo object.

Nell'esempio seguente vengono formattati valori Int32 con l'identificatore di formato esadecimale.The following example formats Int32 values with the hexadecimal format specifier.

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

Torna alla tabellaBack to table

NoteNotes

Impostazioni del Pannello di controlloControl Panel Settings

Le impostazioni di Opzioni internazionali e della lingua nel Pannello di controllo influiscono sulla stringa risultato prodotta da un'operazione di formattazione.The settings in the Regional and Language Options item in Control Panel influence the result string produced by a formatting operation. 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.Those settings are used to initialize the NumberFormatInfo object associated with the current thread culture, which provides values used to govern formatting. Computer con impostazioni diverse generano stringhe di risultato diverse.Computers that use different settings generate different result strings.

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.In addition, if the CultureInfo.CultureInfo(String) constructor is used to instantiate a new CultureInfo object that represents the same culture as the current system culture, any customizations established by the Regional and Language Options item in Control Panel will be applied to the new CultureInfo object. È possibile usare il costruttore di CultureInfo.CultureInfo(String, Boolean) per creare un oggetto CultureInfo che non rifletta le personalizzazioni di un sistema.You can use the CultureInfo.CultureInfo(String, Boolean) constructor to create a CultureInfo object that does not reflect a system's customizations.

Proprietà NumberFormatInfoNumberFormatInfo Properties

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.Formatting is influenced by the properties of the current NumberFormatInfo object, which is provided implicitly by the current thread culture or explicitly by the IFormatProvider parameter of the method that invokes formatting. Specificare un oggetto NumberFormatInfo o CultureInfo per questo parametro.Specify a NumberFormatInfo or CultureInfo object for that parameter.

Nota

Per informazioni sulla personalizzazione delle stringhe o dei modelli usati nella formattazione di valori numerici, vedere l'argomento relativo alla classe NumberFormatInfo.For information about customizing the patterns or strings used in formatting numeric values, see the NumberFormatInfo class topic.

Tipi numerici integrali e a virgola mobileIntegral and Floating-Point Numeric Types

Alcune descrizioni di identificatori di formato numerico standard fanno riferimento a tipi numerici integrali o a virgola mobile.Some descriptions of standard numeric format specifiers refer to integral or floating-point numeric types. I tipi numerici integrali sono Byte, SByte, Int16, Int32, Int64, UInt16, UInt32, UInt64 e BigInteger.The integral numeric types are Byte, SByte, Int16, Int32, Int64, UInt16, UInt32, UInt64, and BigInteger. I tipi numerici a virgola mobile sono Decimal, Single e Double.The floating-point numeric types are Decimal, Single, and Double.

Valori infiniti a virgola mobile e NaNFloating-Point Infinities and 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.Regardless of the format string, if the value of a Single or Double floating-point type is positive infinity, negative infinity, or not a number (NaN), the formatted string is the value of the respective PositiveInfinitySymbol, NegativeInfinitySymbol, or NaNSymbol property that is specified by the currently applicable NumberFormatInfo object.

EsempioExample

Nota

Alcuni degli esempi in C# in questo articolo vengono eseguiti nello strumento di esecuzione e playground per codice inline Try.NET.Some of the C# examples in this article run in the Try.NET inline code runner and playground. Selezionare il pulsante Esegui per eseguire un esempio in una finestra interattiva.Select the Run button to run an example in an interactive window. Dopo aver eseguito il codice, è possibile modificarlo ed eseguire il codice modificato selezionando di nuovo Esegui.Once you execute the code, you can modify it and run the modified code by selecting Run again. 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#.The modified code either runs in the interactive window or, if compilation fails, the interactive window displays all C# compiler error messages.

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.The following example formats an integral and a floating-point numeric value using the en-US culture and all the standard numeric format specifiers. 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).This example uses two particular numeric types (Double and Int32), but would yield similar results for any of the other numeric base types (Byte, SByte, Int16, Int32, Int64, UInt16, UInt32, UInt64, BigInteger, Decimal, and Single).

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

Vedere ancheSee also