Stringhe di formato numerico standard

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

• L'identificatore di formato è un singolo carattere alfabetico che specifica il tipo di formato numerico, ad esempio valuta o percentuale. Qualsiasi stringa di formato numerico contenente più caratteri alfabetici, inclusi gli spazi vuoti, viene interpretata come stringa di formato numerico personalizzata. Per altre informazioni, vedere Stringhe di formato numerico personalizzato.

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

  Quando l'identificatore di precisione controlla il numero di cifre frazionarie nella stringa di risultato, la stringa di risultato riflette un numero arrotondato a un risultato rappresentabile più vicino al risultato infinitamente preciso. Se sono presenti due risultati ugualmente vicini a rappresentabili:

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

  Nota

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

Le stringhe di formato numerico standard sono supportate da:

• Alcuni overload del ToString metodo di tutti i tipi numerici. Ad esempio, è possibile fornire una stringa di formato numerico ai Int32.ToString(String) metodi e Int32.ToString(String, IFormatProvider) .

• Metodo TryFormat di tutti i tipi numerici, Int32.TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider) ad esempio e Single.TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider).

• La funzionalità di formattazione composita .NET, usata da alcuni Write metodi e WriteLine delle Console classi e StreamWriter , il String.Format metodo e il StringBuilder.AppendFormat metodo . La funzionalità formato composito consente di includere la rappresentazione di stringa di più elementi di dati in una singola stringa, specificare la larghezza del campo e allineare i numeri in un campo. Per altre informazioni, vedere Formattazione composita.

• Stringhe interpolate in C# e Visual Basic, che forniscono una sintassi semplificata rispetto alle stringhe di formato composito.

Identificatori di formato standard

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

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

Usare stringhe di formato numerico standard

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

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

  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
  

• Può essere fornito come formatString argomento in un elemento di formato usato con metodi come String.Format, Console.WriteLinee StringBuilder.AppendFormat. Per altre informazioni, vedere Formattazione composita. Nell'esempio seguente viene utilizzato un elemento di formato per inserire un valore di valuta in una stringa.

  decimal value = 123.456m;
  Console.WriteLine($"Your account balance is {value:C2}.");
  // 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, è possibile specificare un alignment argomento per specificare la larghezza del campo numerico e se il relativo valore è allineato a destra o a sinistra. L'esempio seguente allinea a sinistra un valore di valuta in un campo di 28 caratteri e allinea a destra un valore di valuta in un campo di 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
  

  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 fornito come argomento in un elemento dell'espressione formatString interpolata di una stringa interpolata. Per altre informazioni, vedere l'articolo Interpolazione di stringhe nel riferimento per C# o nell'articolo Stringhe interpolate nella guida di riferimento a Visual Basic.

Le sezioni seguenti forniscono informazioni dettagliate su ognuna delle stringhe di formato numerico standard.

Identificatore di formato binario (B)

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

L'identificatore di precisione indica il numero minimo di cifre desiderate nella stringa risultante. Se necessario, il numero viene riempito con zeri a sinistra per produrre il numero di cifre specificate dall'identificatore di precisione.

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

Identificatore di formato valuta (C)

L'identificatore di formato "C" (o valuta) converte 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, la precisione predefinita viene definita dalla NumberFormatInfo.CurrencyDecimalDigits proprietà .

Se il valore da formattare ha più del numero specificato o predefinito di posizioni decimali, il valore frazionaria viene arrotondato nella stringa di risultato. Se il valore a destra del numero di posizioni decimali specificate è 5 o superiore, l'ultima cifra nella stringa di risultato viene arrotondata a distanza da zero.

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

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

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

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

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

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

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

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

Identificatore di formato decimale (D)

L'identificatore di formato "D" (o decimale) converte un numero in una stringa di cifre decimali (0-9), preceduto 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 desiderate nella stringa risultante. Se necessario, il numero viene riempito con zeri a sinistra per produrre il numero di cifre specificate dall'identificatore di precisione. Se non viene specificato alcun identificatore di precisione, il valore predefinito è il valore minimo necessario per rappresentare l'intero senza zeri iniziali.

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

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

Dim value As Integer

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

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

Identificatore di formato esponenziale (E)

L'identificatore di formato esponenziale ("E") converte un numero in una stringa del formato "-d.ddd... E+ddd" o "-d.ddd... e+ddd", dove ogni "d" indica una cifra (0-9). La stringa inizia con un segno meno se il numero è negativo. Esattamente una cifra precede sempre il separatore decimale.

L'identificatore di precisione indica il numero di cifre desiderato dopo il separatore decimale. Se l'identificatore di precisione viene omesso, viene utilizzato un valore predefinito di sei cifre dopo l'utilizzo del separatore decimale.

Il caso dell'identificatore di formato indica se anteporre all'esponente un "E" o un "e". L'esponente è sempre costituito da un segno più o meno e un minimo di tre cifre. L'esponente viene riempito con zeri per soddisfare questo valore minimo, se necessario.

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

L'esempio seguente formatta un Double valore con l'identificatore di formato esponenziale:

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

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

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

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

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

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

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

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

Identificatore di formato a virgola fissa (F)

L'identificatore di formato a virgola fissa ("F") converte un numero in una stringa del formato "-ddd.ddd..." dove ogni "d" indica una cifra (0-9). La stringa inizia con un segno meno se il numero è negativo.

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

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

L'esempio seguente formatta e Double un Int32 valore 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

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

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

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

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

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

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

Identificatore di formato generale (G)

L'identificatore di formato generale ("G") converte un numero nella più compatta della notazione a virgola fissa o scientifica, a seconda del tipo del numero e se è presente 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 zero, il tipo del numero determina la precisione predefinita, come indicato nella tabella seguente.

La notazione a virgola fissa viene usata se l'esponente risultante dall'espressione del numero nella notazione scientifica è maggiore di -5 e minore dell'identificatore di precisione; in caso contrario, viene usata la notazione scientifica. Il risultato contiene un separatore decimale se necessario e zeri finali dopo l'omissione del separatore decimale. Se l'identificatore di precisione è presente e il numero di cifre significative nel risultato supera la precisione specificata, le cifre finali in eccesso vengono rimosse arrotondando.

Tuttavia, se il numero è un Decimal e l'identificatore di precisione viene omesso, viene sempre utilizzata la notazione a virgola fissa e gli zeri finali vengono mantenuti.

Se viene usata la notazione scientifica, l'esponente nel risultato è preceduto da "E" se l'identificatore di formato è "G" o "e" se l'identificatore di formato è "g". L'esponente contiene almeno due cifre. Ciò differisce dal formato per la notazione scientifica prodotta dall'identificatore di formato esponenziale, che include almeno tre cifre nell'esponente.

Se usato con un Double valore, l'identificatore di formato "G17" garantisce che il valore originale Double eserrotondamento. Ciò è dovuto al fatto che Double è un numero a virgola mobile conforme a IEEE 754-2008 con precisione doppia (binary64) conforme a IEEE 754-2008 che dà fino a 17 cifre significative di precisione. In .NET Framework è consigliabile usare anziché l'identificatore di formato "R", perché in alcuni casi "R" non riesce a eseguire correttamente il round trip dei valori a virgola mobile a precisione doppia.

Se usato con un Single valore, l'identificatore di formato "G9" garantisce che il valore originale Single eserrotondi correttamente. Questo perché Single è un numero a virgola mobile (precisione a precisionebinary32 singola) conforme a IEEE 754-2008 che dà fino a nove cifre significative di precisione. Per motivi di prestazioni, è consigliabile usarlo anziché l'identificatore di formato "R".

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

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

double number;

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

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

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

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

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

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

Dim number As Double

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

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

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

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

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

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

Identificatore di formato numerico (N)

L'identificatore di formato numerico ("N") converte un numero in una stringa del formato "-d,ddd,ddd.ddd...", dove "-" indica un simbolo di numero negativo, se necessario, "d" indica una cifra (0-9), "," indica un separatore di gruppo e "." indica un simbolo di virgola 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 posizioni decimali viene definito dalla proprietà corrente NumberFormatInfo.NumberDecimalDigits .

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

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

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

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

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

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

Identificatore di formato percentuale (P)

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

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

L'esempio seguente formatta i 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 %

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

Identificatore di formato round trip (R)

L'identificatore di formato round trip ("R") tenta di garantire che un valore numerico convertito in una stringa venga analizzato nuovamente nello stesso valore numerico. Questo formato è supportato solo per i Halftipi , SingleDouble, e BigInteger .

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

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

Sebbene sia possibile includere un identificatore di precisione, viene ignorato. I round trip hanno la precedenza sulla precisione quando si usa questo identificatore. La stringa di risultato è influenzata dalle informazioni di formattazione dell'oggetto corrente NumberFormatInfo . Nella tabella seguente sono elencate le NumberFormatInfo proprietà che controllano la formattazione della stringa di risultato.

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

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  

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

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

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($"{initialValue:R} = {roundTripped17:R}: {initialValue.Equals(roundTripped17)}\n");
// If compiled to an application that targets anycpu or x64 and run on an x64 system,
// the example displays the following output:
//       Attempting to round-trip a Double with 'R':
//       .NET Framework:
//       0.6822871999174 = 0.68228719991740006: False
//       .NET:
//       0.6822871999174 = 0.6822871999174: True
//
//       Attempting to round-trip a Double with 'G17':
//       0.6822871999174 = 0.6822871999174: True

Imports System.Globalization

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

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

Identificatore di formato esadecimale (X)

L'identificatore di formato esadecimale ("X") converte un numero in una stringa di cifre esadecimali. Il case dell'identificatore di formato indica se usare caratteri maiuscoli o minuscoli per le cifre esadecimali maggiori di 9. Ad esempio, usare "X" per produrre "ABCDEF" e "x" per produrre "abcdef". Questo formato è supportato solo per i tipi integrali.

L'identificatore di precisione indica il numero minimo di cifre desiderate nella stringa risultante. Se necessario, il numero viene riempito con zeri a sinistra per produrre il numero di cifre specificate dall'identificatore di precisione.

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

Nell'esempio seguente vengono formattati Int32 i valori 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

Dim value As Integer

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

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

Note

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

Impostazioni del Pannello di controllo

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

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

Proprietà NumberFormatInfo

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

Tipi numerici integrali e a virgola mobile

Alcune descrizioni degli identificatori di formato numerico standard fanno riferimento a tipi numerici integrali o a virgola mobile. I tipi numerici integrali sono Byte, SByte, Int16Int32, , Int64, UInt16UInt32, UInt64, e BigInteger. I tipi numerici a virgola mobile sono Decimal, Half, Singlee Double.

Infiniti a virgola mobile e NaN

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

Esempio di codice

Nell'esempio seguente viene formattato un valore numerico integrale e a virgola mobile usando le impostazioni cultura en-US e tutti gli identificatori di formato numerico standard. In questo esempio vengono usati due tipi numerici specifici (Double e ), ma si ottengono risultati simili per qualsiasi altro tipo di base numerico (Byte, SByte, UInt16Int16Int32Int64, UInt32BigIntegerUInt64DecimalHalfe ).SingleInt32

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

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

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

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