Stringhe in formato numerico personalizzatoCustom numeric format strings

È possibile creare una stringa di formato numerico personalizzata costituita da uno o più identificatori numerici personalizzati, per definire la formattazione dei dati numerici.You can create a custom numeric format string, which consists of one or more custom numeric specifiers, to define how to format numeric data. Viene considerata stringa di formato numerico personalizzata qualsiasi stringa di formato che non rientri nella categoria di stringa di formato numerico standard.A custom numeric format string is any format string that is not a standard numeric format string.

Le stringhe di formato numerico personalizzate sono supportate da alcuni overload del metodo ToString di tutti i tipi numerici.Custom numeric format strings are supported by some overloads of the ToString method of all numeric types. È ad esempio possibile fornire una stringa di formato numerico ai metodi ToString(String) e ToString(String, IFormatProvider) del tipo Int32 .For example, you can supply a numeric format string to the ToString(String) and ToString(String, IFormatProvider) methods of the Int32 type. Le stringhe di formato numerico personalizzate sono supportate anche dalla funzionalità di formattazione composita di .NET usata da alcuni metodi Write e WriteLine delle classi Console e StreamWriter, dal metodo String.Format e dal metodo StringBuilder.AppendFormat.Custom numeric format strings are also supported by the .NET composite formatting feature, which is used by some Write and WriteLine methods of the Console and StreamWriter classes, the String.Format method, and the StringBuilder.AppendFormat method. La funzionalità di interpolazione di stringhe supporta anche le stringhe in formato numerico personalizzate.String interpolation feature also supports custom numeric format strings.

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.

Nella tabella seguente vengono descritti gli identificatori di formato numerico personalizzati e viene visualizzato l'output di esempio prodotto da ogni identificatore di formato.The following table describes the custom numeric format specifiers and displays sample output produced by each format specifier. Vedere la sezione Note per informazioni aggiuntive sull'utilizzo di stringhe di formato numerico personalizzate e la sezione Esempio per un'illustrazione completa dell'utilizzo.See the Notes section for additional information about using custom numeric format strings, and the Example section for a comprehensive illustration of their use.

Identificatore di formatoFormat specifier nomeName DescrizioneDescription EsempiExamples
"0""0" Segnaposto zeroZero placeholder Sostituisce lo zero con la cifra corrispondente, se disponibile; in caso contrario, lo zero viene visualizzato nella stringa di risultato.Replaces the zero with the corresponding digit if one is present; otherwise, zero appears in the result string.

Ulteriori informazioni: Identificatore personalizzato "0".More information: The "0" Custom Specifier.
1234.5678 ("00000") -> 012351234.5678 ("00000") -> 01235

0.45678 ("0.00", en-US) -> 0.460.45678 ("0.00", en-US) -> 0.46

0.45678 ("0.00", fr-FR) -> 0,460.45678 ("0.00", fr-FR) -> 0,46
"#""#" Segnaposto per cifreDigit placeholder Sostituisce il simbolo "#" con la cifra corrispondente, se disponibile; in caso contrario, nella stringa di risultato non viene visualizzata nessuna cifra.Replaces the "#" symbol with the corresponding digit if one is present; otherwise, no digit appears in the result string.

Si noti che nella stringa di risultato non viene visualizzata nessuna cifra se la cifra corrispondente nella stringa di input equivale a uno 0 non significativo.Note that no digit appears in the result string if the corresponding digit in the input string is a non-significant 0. Ad esempio, 0003 ("####") -> 3.For example, 0003 ("####") -> 3.

Ulteriori informazioni: Identificatore personalizzato "#".More information: The "#" Custom Specifier.
1234.5678 ("#####") -> 12351234.5678 ("#####") -> 1235

0.45678 ("#.##", en-US) -> .460.45678 ("#.##", en-US) -> .46

0.45678 ("#.##", fr-FR) -> ,460.45678 ("#.##", fr-FR) -> ,46
".""." Separatore decimaleDecimal point Determina la posizione del separatore decimale nella stringa di risultato.Determines the location of the decimal separator in the result string.

Ulteriori informazioni: Identificatore personalizzato ".".More information: The "." Custom Specifier.
0.45678 ("0.00", en-US) -> 0.460.45678 ("0.00", en-US) -> 0.46

0.45678 ("0.00", fr-FR) -> 0,460.45678 ("0.00", fr-FR) -> 0,46
",""," Separatore di gruppi e rappresentazione in scala dei numeriGroup separator and number scaling Viene usato sia come separatore di gruppi che come identificatore di rappresentazione in scala dei numeri.Serves as both a group separator and a number scaling specifier. Come separatore di gruppi, inserisce un carattere separatore di gruppi localizzato tra ogni gruppo.As a group separator, it inserts a localized group separator character between each group. Come identificatore di rappresentazione in scala dei numeri, divide un numero per 1000 per ogni virgola specificata.As a number scaling specifier, it divides a number by 1000 for each comma specified.

Ulteriori informazioni: Identificatore personalizzato ",".More information: The "," Custom Specifier.
Identificatore del separatore di gruppi:Group separator specifier:

2147483647 ("##,#", en-US) -> 2,147,483,6472147483647 ("##,#", en-US) -> 2,147,483,647

2147483647 ("##,#", es-ES) -> 2.147.483.6472147483647 ("##,#", es-ES) -> 2.147.483.647

Identificatore di rappresentazione in scala:Scaling specifier:

2147483647 ("#,#,,", en-US) -> 2,1472147483647 ("#,#,,", en-US) -> 2,147

2147483647 ("#,#,,", es-ES) -> 2.1472147483647 ("#,#,,", es-ES) -> 2.147
"%""%" Segnaposto percentualePercentage placeholder Moltiplica un numero per 100 e inserisce un simbolo di percentuale localizzato nella stringa di risultato.Multiplies a number by 100 and inserts a localized percentage symbol in the result string.

Ulteriori informazioni: Identificatore personalizzato "%".More information: The "%" Custom Specifier.
0.3697 ("%#0.00", en-US) -> %36.970.3697 ("%#0.00", en-US) -> %36.97

0.3697 ("%#0.00", el-GR) -> %36,970.3697 ("%#0.00", el-GR) -> %36,97

0.3697 ("##.0 %", en-US) -> 37.0 %0.3697 ("##.0 %", en-US) -> 37.0 %

0.3697 ("##.0 %", el-GR) -> 37,0 %0.3697 ("##.0 %", el-GR) -> 37,0 %
"‰""‰" Segnaposto per millePer mille placeholder Moltiplica un numero per 1000 e inserisce un simbolo di per mille localizzato nella stringa di risultato.Multiplies a number by 1000 and inserts a localized per mille symbol in the result string.

Ulteriori informazioni: Identificatore personalizzato "‰".More information: The "‰" Custom Specifier.
0.03697 ("#0.00‰", en-US) -> 36.97‰0.03697 ("#0.00‰", en-US) -> 36.97‰

0.03697 ("#0.00‰", ru-RU) -> 36,97‰0.03697 ("#0.00‰", ru-RU) -> 36,97‰
"E0""E0"

"E+0""E+0"

"E-0""E-0"

"E0""e0"

"E+0""e+0"

"E-0""e-0"
Notazione esponenzialeExponential notation Se è seguito da almeno uno 0 (zero), formatta il risultato usando la notazione esponenziale.If followed by at least one 0 (zero), formats the result using exponential notation. L'utilizzo di "E" o "e" indica se il simbolo dell'esponente nella stringa di risultato deve essere, rispettivamente, maiuscolo o minuscolo.The case of "E" or "e" indicates the case of the exponent symbol in the result string. Il numero di zeri che seguono il carattere "E" o "e" determina il numero minimo di cifre nell'esponente.The number of zeros following the "E" or "e" character determines the minimum number of digits in the exponent. Un segno più (+) indica che l'esponente è sempre preceduto da un carattere di segno.A plus sign (+) indicates that a sign character always precedes the exponent. Un segno meno (-) indica che solo gli esponenti negativi sono preceduti da un carattere di segno.A minus sign (-) indicates that a sign character precedes only negative exponents.

Ulteriori informazioni: Identificatori personalizzati "E" e "e".More information: The "E" and "e" Custom Specifiers.
987654 ("#0.0e0") -> 98.8e4987654 ("#0.0e0") -> 98.8e4

1503.92311 ("0.0##e+00") -> 1.504e+031503.92311 ("0.0##e+00") -> 1.504e+03

1.8901385E-16 ("0.0e+00") -> 1.9e-161.8901385E-16 ("0.0e+00") -> 1.9e-16
"\""\" Carattere di escapeEscape character Fa in modo che il carattere successivo venga interpretato come valore letterale anziché come identificatore di formato personalizzato.Causes the next character to be interpreted as a literal rather than as a custom format specifier.

Altre informazioni: Carattere di escape "\".More information: The "\" Escape Character.
987654 ("\###00\#") -> #987654#987654 ("\###00\#") -> #987654#
'string''string'

"string""string"
Delimitatore di stringa letteraleLiteral string delimiter Indica che i caratteri contenuti devono essere copiati nella stringa di risultato senza essere modificati.Indicates that the enclosed characters should be copied to the result string unchanged.

Altre informazioni: caratteri letterali.More information: Character literals.
68 ("# ' gradi'") -> 68 gradi68 ("# ' degrees'") -> 68 degrees

68 ("# ' gradi'") -> 68 gradi68 ("#' degrees'") -> 68 degrees
;; Separatore di sezioneSection separator Definisce le sezioni con stringhe di formato separate per numeri positivi, negativi e zero.Defines sections with separate format strings for positive, negative, and zero numbers.

Ulteriori informazioni: Separatore di sezione ";".More information: The ";" Section Separator.
12.345 ("#0.0#;(#0.0#);-\0-") -> 12.3512.345 ("#0.0#;(#0.0#);-\0-") -> 12.35

0 ("#0.0#;(#0.0#);-\0-") -> -0-0 ("#0.0#;(#0.0#);-\0-") -> -0-

-12.345 ("#0.0#;(#0.0#);-\0-") -> (12.35)-12.345 ("#0.0#;(#0.0#);-\0-") -> (12.35)

12.345 ("#0.0#;(#0.0#)") -> 12.3512.345 ("#0.0#;(#0.0#)") -> 12.35

0 ("#0.0#;(#0.0#)") -> 0.00 ("#0.0#;(#0.0#)") -> 0.0

-12.345 ("#0.0#;(#0.0#)") -> (12.35)-12.345 ("#0.0#;(#0.0#)") -> (12.35)
AltroOther Tutti gli altri caratteriAll other characters Il carattere viene copiato nella stringa di risultato senza alcuna modifica.The character is copied to the result string unchanged.

Altre informazioni: caratteri letterali.More information: Character literals.
68 ("# °") -> 68 °68 ("# °") -> 68 °

Nelle sezioni seguenti vengono fornite informazioni dettagliate su ognuno degli identificatori di formato numerico personalizzati.The following sections provide detailed information about each of the custom numeric format specifiers.

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.

Le impostazioni cultura correnti dello strumento di esecuzione e playground per codice inline Try.NET sono le impostazioni cultura inglese non dipendenti da paese/area geografica.The current culture of the Try.NET inline code runner and playground is the invariant culture. Di conseguenza, l'output prodotto dallo strumento di esecuzione per codice inline è diverso dall'output visualizzato dagli esempi che usano come impostazioni cultura correnti le impostazioni cultura predefinite.As a result, the output produced by the inline code runner differs from the output displayed by examples that use a default culture as the current culture.

È possibile ovviare a questa limitazione aggiungendo una riga di codice simile alla seguente per configurare le impostazioni cultura: System.Globalization.CultureInfo.CurrentCulture = new System.Globalization.CultureInfo("en-US"); È sufficiente sostituire en-US con il nome delle impostazioni cultura correnti desiderate.You can work around this limitation by adding a line of code like the following to set the culture: System.Globalization.CultureInfo.CurrentCulture = new System.Globalization.CultureInfo("en-US"); Just replace en-US with the name of the culture that you'd like to be the current culture.

Identificatore personalizzato "0"The "0" custom specifier

L'identificatore di formato personalizzato "0" serve come simbolo di segnaposto zero.The "0" custom format specifier serves as a zero-placeholder symbol. Se nel valore da formattare è presente una cifra nella posizione in cui nella stringa di formato si trova lo zero, tale cifra viene copiata nella stringa di risultato. In caso contrario, nella stringa di risultato viene visualizzato uno zero.If the value that is being formatted has a digit in the position where the zero appears in the format string, that digit is copied to the result string; otherwise, a zero appears in the result string. La posizione dello zero più a sinistra prima del separatore decimale e quella dello zero più a destra dopo il separatore decimale determinano l'intervallo di cifre sempre presenti nella stringa di risultato.The position of the leftmost zero before the decimal point and the rightmost zero after the decimal point determines the range of digits that are always present in the result string.

L'identificatore "00" determina l'arrotondamento del valore alla cifra più vicina prima del decimale, in cui viene sempre usato l'arrotondamento a un valore diverso da zero.The "00" specifier causes the value to be rounded to the nearest digit preceding the decimal, where rounding away from zero is always used. La formattazione di 34,5 con "00", ad esempio, restituisce come risultato il valore 35.For example, formatting 34.5 with "00" would result in the value 35.

Nell'esempio seguente vengono visualizzati diversi valori formattati usando stringhe di formato personalizzate che includono segnaposto zero.The following example displays several values that are formatted by using custom format strings that include zero placeholders.

double value;

value = 123;
Console::WriteLine(value.ToString("00000"));
Console::WriteLine(String::Format("{0:00000}", value));
// Displays 00123

value = 1.2;
Console::WriteLine(value.ToString("0.00", CultureInfo::InvariantCulture));
Console::WriteLine(String::Format(CultureInfo::InvariantCulture, 
                  "{0:0.00}", value));
// Displays 1.20

Console::WriteLine(value.ToString("00.00", CultureInfo::InvariantCulture));
Console::WriteLine(String::Format(CultureInfo::InvariantCulture, 
                                "{0:00.00}", value));
// Displays 01.20

CultureInfo^ daDK = CultureInfo::CreateSpecificCulture("da-DK");
Console::WriteLine(value.ToString("00.00", daDK)); 
Console::WriteLine(String::Format(daDK, "{0:00.00}", value));
// Displays 01,20

value = .56;
Console::WriteLine(value.ToString("0.0", CultureInfo::InvariantCulture));
Console::WriteLine(String::Format(CultureInfo::InvariantCulture, 
                                "{0:0.0}", value));
// Displays 0.6

value = 1234567890;
Console::WriteLine(value.ToString("0,0", CultureInfo::InvariantCulture));	
Console::WriteLine(String::Format(CultureInfo::InvariantCulture, 
                                "{0:0,0}", value));	
// Displays 1,234,567,890      

CultureInfo^ elGR = CultureInfo::CreateSpecificCulture("el-GR");
Console::WriteLine(value.ToString("0,0", elGR));	
Console::WriteLine(String::Format(elGR, "{0:0,0}", value));	
// Displays 1.234.567.890

value = 1234567890.123456;
Console::WriteLine(value.ToString("0,0.0", CultureInfo::InvariantCulture));	
Console::WriteLine(String::Format(CultureInfo::InvariantCulture, 
                                "{0:0,0.0}", value));	
// Displays 1,234,567,890.1  

value = 1234.567890;
Console::WriteLine(value.ToString("0,0.00", CultureInfo::InvariantCulture));	
Console::WriteLine(String::Format(CultureInfo::InvariantCulture, 
                                "{0:0,0.00}", value));	
// Displays 1,234.57 
 double value;
 
 value = 123;
 Console.WriteLine(value.ToString("00000"));
 Console.WriteLine(String.Format("{0:00000}", value));
 // Displays 00123
 
 value = 1.2;
 Console.WriteLine(value.ToString("0.00", CultureInfo.InvariantCulture));
 Console.WriteLine(String.Format(CultureInfo.InvariantCulture, 
                   "{0:0.00}", value));
 // Displays 1.20

 Console.WriteLine(value.ToString("00.00", CultureInfo.InvariantCulture));
 Console.WriteLine(String.Format(CultureInfo.InvariantCulture, 
                                 "{0:00.00}", value));
 // Displays 01.20

 CultureInfo daDK = CultureInfo.CreateSpecificCulture("da-DK");
 Console.WriteLine(value.ToString("00.00", daDK)); 
 Console.WriteLine(String.Format(daDK, "{0:00.00}", value));
 // Displays 01,20
 
 value = .56;
 Console.WriteLine(value.ToString("0.0", CultureInfo.InvariantCulture));
 Console.WriteLine(String.Format(CultureInfo.InvariantCulture, 
                                 "{0:0.0}", value));
 // Displays 0.6

 value = 1234567890;
 Console.WriteLine(value.ToString("0,0", CultureInfo.InvariantCulture));	
 Console.WriteLine(String.Format(CultureInfo.InvariantCulture, 
                                 "{0:0,0}", value));	
 // Displays 1,234,567,890      
 
 CultureInfo elGR = CultureInfo.CreateSpecificCulture("el-GR");
 Console.WriteLine(value.ToString("0,0", elGR));	
Console.WriteLine(String.Format(elGR, "{0:0,0}", value));	
 // Displays 1.234.567.890
 
 value = 1234567890.123456;
 Console.WriteLine(value.ToString("0,0.0", CultureInfo.InvariantCulture));	
 Console.WriteLine(String.Format(CultureInfo.InvariantCulture, 
                                 "{0:0,0.0}", value));	
 // Displays 1,234,567,890.1  
 
 value = 1234.567890;
 Console.WriteLine(value.ToString("0,0.00", CultureInfo.InvariantCulture));	
 Console.WriteLine(String.Format(CultureInfo.InvariantCulture, 
                                 "{0:0,0.00}", value));	
 // Displays 1,234.57 
Dim value As Double

value = 123
Console.WriteLine(value.ToString("00000"))
Console.WriteLine(String.Format("{0:00000}", value))
' Displays 00123

value = 1.2
Console.Writeline(value.ToString("0.00", CultureInfo.InvariantCulture))
Console.Writeline(String.Format(CultureInfo.InvariantCulture, 
                  "{0:0.00}", value))
' Displays 1.20
Console.WriteLine(value.ToString("00.00", CultureInfo.InvariantCulture))
Console.WriteLine(String.Format(CultureInfo.InvariantCulture, 
                                "{0:00.00}", value))
' Displays 01.20
Dim daDK As CultureInfo = CultureInfo.CreateSpecificCulture("da-DK")
Console.WriteLine(value.ToString("00.00", daDK))
Console.WriteLine(String.Format(daDK, "{0:00.00}", value))
' Displays 01,20

value = .56
Console.WriteLine(value.ToString("0.0", CultureInfo.InvariantCulture))
Console.WriteLine(String.Format(CultureInfo.InvariantCulture, 
                                "{0:0.0}", value))
' Displays 0.6

value = 1234567890
Console.WriteLine(value.ToString("0,0", CultureInfo.InvariantCulture))	
Console.WriteLine(String.Format(CultureInfo.InvariantCulture, 
                                "{0:0,0}", value))	
' Displays 1,234,567,890      
Dim elGR As CultureInfo = CultureInfo.CreateSpecificCulture("el-GR")
Console.WriteLine(value.ToString("0,0", elGR))
Console.WriteLine(String.Format(elGR, "{0:0,0}", value))	
' Displays 1.234.567.890

value = 1234567890.123456
Console.WriteLine(value.ToString("0,0.0", CultureInfo.InvariantCulture))	
Console.WriteLine(String.Format(CultureInfo.InvariantCulture, 
                                "{0:0,0.0}", value))	
' Displays 1,234,567,890.1  

value = 1234.567890
Console.WriteLine(value.ToString("0,0.00", CultureInfo.InvariantCulture))	
Console.WriteLine(String.Format(CultureInfo.InvariantCulture, 
                                "{0:0,0.00}", value))	
' Displays 1,234.57 

Torna alla tabellaBack to table

Identificatore personalizzato "#"The "#" custom specifier

L'identificatore di formato personalizzato "#" serve come simbolo di segnaposto per cifre.The "#" custom format specifier serves as a digit-placeholder symbol. Se il valore da formattare ha una cifra nella posizione in cui si trova il simbolo "#" nella stringa di formato, tale cifra viene copiata nella stringa di risultato.If the value that is being formatted has a digit in the position where the "#" symbol appears in the format string, that digit is copied to the result string. In caso contrario, nella stringa di risultato non viene memorizzato alcun valore in tale posizione.Otherwise, nothing is stored in that position in the result string.

Si noti che questo identificatore non visualizza mai uno zero, che non è una cifra significativa, anche se lo zero è l'unica cifra della stringa.Note that this specifier never displays a zero that is not a significant digit, even if zero is the only digit in the string. Viene visualizzato zero solo se si tratta di una cifra significativa nel numero da visualizzare.It will display zero only if it is a significant digit in the number that is being displayed.

La stringa di formato "##" determina l'arrotondamento del valore alla cifra più vicina prima del decimale, in cui viene sempre usato l'arrotondamento a un valore diverso da zero.The "##" format string causes the value to be rounded to the nearest digit preceding the decimal, where rounding away from zero is always used. La formattazione di 34,5 con "##", ad esempio, restituisce come risultato il valore 35.For example, formatting 34.5 with "##" would result in the value 35.

Nell'esempio seguente vengono visualizzati diversi valori formattati usando stringhe di formato personalizzate che includono segnaposto per cifre.The following example displays several values that are formatted by using custom format strings that include digit placeholders.

 double value;
 
 value = 1.2;
 Console::WriteLine(value.ToString("#.##", CultureInfo::InvariantCulture));
 Console::WriteLine(String::Format(CultureInfo::InvariantCulture, 
                                 "{0:#.##}", value));
 // Displays 1.2
 
 value = 123;
 Console::WriteLine(value.ToString("#####"));
 Console::WriteLine(String::Format("{0:#####}", value));
 // Displays 123

 value = 123456;
 Console::WriteLine(value.ToString("[##-##-##]"));      
 Console::WriteLine(String::Format("{0:[##-##-##]}", value));      
// Displays [12-34-56]

 value = 1234567890;
 Console::WriteLine(value.ToString("#"));
 Console::WriteLine(String::Format("{0:#}", value));
 // Displays 1234567890
 
 Console::WriteLine(value.ToString("(###) ###-####"));
 Console::WriteLine(String::Format("{0:(###) ###-####}", value));
 // Displays (123) 456-7890
  double value;
  
  value = 1.2;
  Console.WriteLine(value.ToString("#.##", CultureInfo.InvariantCulture));
  Console.WriteLine(String.Format(CultureInfo.InvariantCulture, 
                                  "{0:#.##}", value));
  // Displays 1.2
  
  value = 123;
  Console.WriteLine(value.ToString("#####"));
  Console.WriteLine(String.Format("{0:#####}", value));
  // Displays 123

  value = 123456;
  Console.WriteLine(value.ToString("[##-##-##]"));      
  Console.WriteLine(String.Format("{0:[##-##-##]}", value));      
// Displays [12-34-56]

  value = 1234567890;
  Console.WriteLine(value.ToString("#"));
  Console.WriteLine(String.Format("{0:#}", value));
  // Displays 1234567890
  
  Console.WriteLine(value.ToString("(###) ###-####"));
  Console.WriteLine(String.Format("{0:(###) ###-####}", value));
  // Displays (123) 456-7890
  Dim value As Double
  
  value = 1.2
  Console.WriteLine(value.ToString("#.##", CultureInfo.InvariantCulture))
  Console.WriteLine(String.Format(CultureInfo.InvariantCulture, 
                                  "{0:#.##}", value))
  ' Displays 1.2
  
  value = 123
  Console.WriteLine(value.ToString("#####"))
  Console.WriteLine(String.Format("{0:#####}", value))
  ' Displays 123

  value = 123456
  Console.WriteLine(value.ToString("[##-##-##]"))      
  Console.WriteLine(String.Format("{0:[##-##-##]}", value))      
' Displays [12-34-56]

  value = 1234567890
  Console.WriteLine(value.ToString("#"))
  Console.WriteLine(String.Format("{0:#}", value))
  ' Displays 1234567890

  Console.WriteLine(value.ToString("(###) ###-####"))
  Console.WriteLine(String.Format("{0:(###) ###-####}", value))
  ' Displays (123) 456-7890

Per restituire una stringa di risultato in cui le cifre mancanti o gli zeri iniziali vengono sostituiti da spazi, usare la funzionalità di formattazione composita e specificare una lunghezza di campo, come illustrato nell'esempio seguente.To return a result string in which absent digits or leading zeroes are replaced by spaces, use the composite formatting feature and specify a field width, as the following example illustrates.

using namespace System;

void main()
{
    Double value = .324;
    Console::WriteLine("The value is: '{0,5:#.###}'", value);
}
// The example displays the following output if the current culture
// is en-US:
//      The value is: ' .324'
using System;

public class Example
{
   public static void Main()
   {
      Double value = .324;
      Console.WriteLine("The value is: '{0,5:#.###}'", value);
   }
}
// The example displays the following output if the current culture
// is en-US:
//      The value is: ' .324'
Module Example
   Public Sub Main()
      Dim value As Double = .324
      Console.WriteLine("The value is: '{0,5:#.###}'", value)
   End Sub
End Module
' The example displays the following output if the current culture
' is en-US:
'      The value is: ' .324'

Torna alla tabellaBack to table

Identificatore personalizzato "."The "." custom specifier

L'identificatore di formato personalizzato "." inserisce un separatore decimale localizzato nella stringa di risultato.The "." custom format specifier inserts a localized decimal separator into the result string. Il primo carattere punto nella stringa di formato determina la posizione del separatore decimale nel valore formattato. Eventuali punti aggiuntivi vengono ignorati.The first period in the format string determines the location of the decimal separator in the formatted value; any additional periods are ignored.

Il carattere effettivamente usato come separatore decimale nella stringa di risultato non è sempre un punto, ma viene determinato dalla proprietà NumberDecimalSeparator dell'oggetto NumberFormatInfo che controlla la formattazione.The character that is used as the decimal separator in the result string is not always a period; it is determined by the NumberDecimalSeparator property of the NumberFormatInfo object that controls formatting.

Nell'esempio seguente viene usato l'identificatore di formato "." per definire la posizione del separatore decimale in alcune stringhe di risultato.The following example uses the "." format specifier to define the location of the decimal point in several result strings.

 double value;
 
 value = 1.2;
 Console::WriteLine(value.ToString("0.00", CultureInfo::InvariantCulture));
 Console::WriteLine(String::Format(CultureInfo::InvariantCulture, 
                                 "{0:0.00}", value));
 // Displays 1.20

 Console::WriteLine(value.ToString("00.00", CultureInfo::InvariantCulture));
 Console::WriteLine(String::Format(CultureInfo::InvariantCulture, 
                                 "{0:00.00}", value));
 // Displays 01.20

 Console::WriteLine(value.ToString("00.00", 
                   CultureInfo::CreateSpecificCulture("da-DK")));
 Console::WriteLine(String::Format(CultureInfo::CreateSpecificCulture("da-DK"),
                   "{0:00.00}", value));
 // Displays 01,20

 value = .086;
 Console::WriteLine(value.ToString("#0.##%", CultureInfo::InvariantCulture)); 
 Console::WriteLine(String::Format(CultureInfo::InvariantCulture, 
                                 "{0:#0.##%}", value)); 
 // Displays 8.6%
  
 value = 86000;
 Console::WriteLine(value.ToString("0.###E+0", CultureInfo::InvariantCulture));
 Console::WriteLine(String::Format(CultureInfo::InvariantCulture, 
                   "{0:0.###E+0}", value));
// Displays 8.6E+4
  double value;
  
  value = 1.2;
  Console.WriteLine(value.ToString("0.00", CultureInfo.InvariantCulture));
  Console.WriteLine(String.Format(CultureInfo.InvariantCulture, 
                                  "{0:0.00}", value));
  // Displays 1.20

  Console.WriteLine(value.ToString("00.00", CultureInfo.InvariantCulture));
  Console.WriteLine(String.Format(CultureInfo.InvariantCulture, 
                                  "{0:00.00}", value));
  // Displays 01.20

  Console.WriteLine(value.ToString("00.00", 
                    CultureInfo.CreateSpecificCulture("da-DK")));
  Console.WriteLine(String.Format(CultureInfo.CreateSpecificCulture("da-DK"),
                    "{0:00.00}", value));
  // Displays 01,20

  value = .086;
  Console.WriteLine(value.ToString("#0.##%", CultureInfo.InvariantCulture)); 
  Console.WriteLine(String.Format(CultureInfo.InvariantCulture, 
                                  "{0:#0.##%}", value)); 
  // Displays 8.6%
   
  value = 86000;
  Console.WriteLine(value.ToString("0.###E+0", CultureInfo.InvariantCulture));
  Console.WriteLine(String.Format(CultureInfo.InvariantCulture, 
                    "{0:0.###E+0}", value));
// Displays 8.6E+4
  Dim value As Double
  
  value = 1.2
  Console.Writeline(value.ToString("0.00", CultureInfo.InvariantCulture))
  Console.Writeline(String.Format(CultureInfo.InvariantCulture, 
                                  "{0:0.00}", value))
  ' Displays 1.20
  
  Console.WriteLine(value.ToString("00.00", CultureInfo.InvariantCulture))
  Console.WriteLine(String.Format(CultureInfo.InvariantCulture, 
                                  "{0:00.00}", value))
  ' Displays 01.20

  Console.WriteLine(value.ToString("00.00", _
                    CultureInfo.CreateSpecificCulture("da-DK")))
  Console.WriteLine(String.Format(CultureInfo.CreateSpecificCulture("da-DK"),
                    "{0:00.00}", value))
  ' Displays 01,20

  value = .086
  Console.WriteLine(value.ToString("#0.##%", CultureInfo.InvariantCulture)) 
  Console.WriteLine(String.Format(CultureInfo.InvariantCulture, 
                                  "{0:#0.##%}", value)) 
  ' Displays 8.6%
   
  value = 86000
  Console.WriteLine(value.ToString("0.###E+0", CultureInfo.InvariantCulture))
  Console.WriteLine(String.Format(CultureInfo.InvariantCulture, 
                    "{0:0.###E+0}", value))
' Displays 8.6E+4

Torna alla tabellaBack to table

Identificatore personalizzato ","The "," custom specifier

Il carattere "," viene usato sia come separatore di gruppi che come identificatore di rappresentazione in scala dei numeri.The "," character serves as both a group separator and a number scaling specifier.

  • Separatore di gruppi: se vengono specificate una o più virgole tra due segnaposto per cifre (0 o #) che formattano le cifre integrali di un numero, viene inserito un carattere di separazione di gruppi tra ogni gruppo di numeri nella parte integrale dell'output.Group separator: If one or more commas are specified between two digit placeholders (0 or #) that format the integral digits of a number, a group separator character is inserted between each number group in the integral part of the output.

    Le proprietà NumberGroupSeparator e NumberGroupSizes dell'oggetto NumberFormatInfo corrente determinano il carattere usato come separatore di gruppi di numeri e la dimensione di ogni gruppo di numeri.The NumberGroupSeparator and NumberGroupSizes properties of the current NumberFormatInfo object determine the character used as the number group separator and the size of each number group. Se ad esempio vengono usate la stringa "#, #" e le impostazioni cultura invarianti per formattare il numero 1000, l'output sarà "1,000".For example, if the string "#,#" and the invariant culture are used to format the number 1000, the output is "1,000".

  • Identificatore di rappresentazione in scala dei numeri: se vengono specificate una o più virgole immediatamente a sinistra del separatore decimale esplicito o implicito, il numero da formattare viene diviso per 1000 per ogni virgola presente.Number scaling specifier: If one or more commas are specified immediately to the left of the explicit or implicit decimal point, the number to be formatted is divided by 1000 for each comma. Se ad esempio viene usata la stringa "0" per formattare il numero 100 milioni, l'output sarà "100".For example, if the string "0,," is used to format the number 100 million, the output is "100".

È possibile usare gli identificatori del separatore di gruppi e di rappresentazione in scala dei numeri nella stessa stringa di formato.You can use group separator and number scaling specifiers in the same format string. Se ad esempio vengono usate la stringa "#,0,," e le impostazioni cultura invarianti per formattare il numero un miliardo, l'output sarà "1,000".For example, if the string "#,0,," and the invariant culture are used to format the number one billion, the output is "1,000".

Nell'esempio seguente viene illustrato l'utilizzo della virgola come separatore di gruppi.The following example illustrates the use of the comma as a group separator.

double value = 1234567890;
Console::WriteLine(value.ToString("#,#", CultureInfo::InvariantCulture));
Console::WriteLine(String::Format(CultureInfo::InvariantCulture, 
                                "{0:#,#}", value));
// Displays 1,234,567,890      

Console::WriteLine(value.ToString("#,##0,,", CultureInfo::InvariantCulture));
Console::WriteLine(String::Format(CultureInfo::InvariantCulture, 
                                "{0:#,##0,,}", value));
// Displays 1,235      	
double value = 1234567890;
Console.WriteLine(value.ToString("#,#", CultureInfo.InvariantCulture));
Console.WriteLine(String.Format(CultureInfo.InvariantCulture, 
                                "{0:#,#}", value));
// Displays 1,234,567,890      

Console.WriteLine(value.ToString("#,##0,,", CultureInfo.InvariantCulture));
Console.WriteLine(String.Format(CultureInfo.InvariantCulture, 
                                "{0:#,##0,,}", value));
// Displays 1,235      	
Dim value As Double = 1234567890
Console.WriteLine(value.ToString("#,#", CultureInfo.InvariantCulture))
Console.WriteLine(String.Format(CultureInfo.InvariantCulture, 
                                "{0:#,#}", value))
' Displays 1,234,567,890      

Console.WriteLine(value.ToString("#,##0,,", CultureInfo.InvariantCulture))
Console.WriteLine(String.Format(CultureInfo.InvariantCulture, 
                                "{0:#,##0,,}", value))
' Displays 1,235      	

Nell'esempio seguente viene illustrato l'utilizzo della virgola come identificatore di rappresentazione in scala.The following example illustrates the use of the comma as a specifier for number scaling.

  double value = 1234567890;
  Console::WriteLine(value.ToString("#,,", CultureInfo::InvariantCulture));	
  Console::WriteLine(String::Format(CultureInfo::InvariantCulture, 
                                  "{0:#,,}", value));	
  // Displays 1235   
  
  Console::WriteLine(value.ToString("#,,,", CultureInfo::InvariantCulture));
  Console::WriteLine(String::Format(CultureInfo::InvariantCulture, 
                                  "{0:#,,,}", value));
// Displays 1  
  
  Console::WriteLine(value.ToString("#,##0,,", CultureInfo::InvariantCulture));       
  Console::WriteLine(String::Format(CultureInfo::InvariantCulture, 
                                  "{0:#,##0,,}", value));       
// Displays 1,235
   double value = 1234567890;
   Console.WriteLine(value.ToString("#,,", CultureInfo.InvariantCulture));	
   Console.WriteLine(String.Format(CultureInfo.InvariantCulture, 
                                   "{0:#,,}", value));	
   // Displays 1235   
   
   Console.WriteLine(value.ToString("#,,,", CultureInfo.InvariantCulture));
   Console.WriteLine(String.Format(CultureInfo.InvariantCulture, 
                                   "{0:#,,,}", value));
// Displays 1  
   
   Console.WriteLine(value.ToString("#,##0,,", CultureInfo.InvariantCulture));       
   Console.WriteLine(String.Format(CultureInfo.InvariantCulture, 
                                   "{0:#,##0,,}", value));       
// Displays 1,235
  Dim value As Double = 1234567890
  Console.WriteLine(value.ToString("#,,", CultureInfo.InvariantCulture))	
  Console.WriteLine(String.Format(CultureInfo.InvariantCulture, "{0:#,,}", value))	
  ' Displays 1235   

  Console.WriteLine(value.ToString("#,,,", CultureInfo.InvariantCulture))
  Console.WriteLine(String.Format(CultureInfo.InvariantCulture, 
                                  "{0:#,,,}", value))
' Displays 1  

  Console.WriteLine(value.ToString("#,##0,,", CultureInfo.InvariantCulture))       
  Console.WriteLine(String.Format(CultureInfo.InvariantCulture, 
                                  "{0:#,##0,,}", value))       
' Displays 1,235

Torna alla tabellaBack to table

Identificatore personalizzato "%"The "%" custom specifier

La presenza di un segno di percentuale ("%") in una stringa di formato fa sì che un numero venga moltiplicato per 100 prima di essere formattato.A percent sign (%) in a format string causes a number to be multiplied by 100 before it is formatted. Il simbolo di percentuale localizzato viene inserito nel numero stesso nella posizione in cui è stato inserito il segno % nella stringa di formato.The localized percent symbol is inserted in the number at the location where the % appears in the format string. Il carattere percentuale usato è definito dalla proprietà PercentSymbol dell'oggetto NumberFormatInfo corrente.The percent character used is defined by the PercentSymbol property of the current NumberFormatInfo object.

Nell'esempio seguente vengono definite diverse stringhe di formato personalizzate che includono l'identificatore personalizzato "%".The following example defines several custom format strings that include the "%" custom specifier.

double value = .086;
Console::WriteLine(value.ToString("#0.##%", CultureInfo::InvariantCulture));
Console::WriteLine(String::Format(CultureInfo::InvariantCulture, 
                                "{0:#0.##%}", value));
// Displays 8.6%      
double value = .086;
Console.WriteLine(value.ToString("#0.##%", CultureInfo.InvariantCulture));
Console.WriteLine(String.Format(CultureInfo.InvariantCulture, 
                                "{0:#0.##%}", value));
// Displays 8.6%      
Dim value As Double = .086
Console.WriteLine(value.ToString("#0.##%", CultureInfo.InvariantCulture))
Console.WriteLine(String.Format(CultureInfo.InvariantCulture, 
                                "{0:#0.##%}", value))
' Displays 8.6%      

Torna alla tabellaBack to table

Identificatore personalizzato "‰"The "‰" custom specifier

Un carattere per mille (‰ or \u2030) in una stringa di formato fa sì che un numero venga moltiplicato per 1000 prima di essere formattato.A per mille character (‰ or \u2030) in a format string causes a number to be multiplied by 1000 before it is formatted. Il simbolo per mille appropriato viene inserito nella stringa restituita nella posizione in cui è stato inserito il simbolo ‰ nella stringa di formato.The appropriate per mille symbol is inserted in the returned string at the location where the ‰ symbol appears in the format string. Il carattere per mille usato viene definito dalla proprietà NumberFormatInfo.PerMilleSymbol dell'oggetto che fornisce informazioni di formattazione specifiche delle impostazioni cultura.The per mille character used is defined by the NumberFormatInfo.PerMilleSymbol property of the object that provides culture-specific formatting information.

Nell'esempio seguente viene definita una stringa di formato personalizzata che include l'identificatore personalizzato "‰".The following example defines a custom format string that includes the "‰" custom specifier.

double value = .00354;
String^ perMilleFmt = "#0.## " + '\u2030';
Console::WriteLine(value.ToString(perMilleFmt, CultureInfo::InvariantCulture));
Console::WriteLine(String::Format(CultureInfo::InvariantCulture, 
                                "{0:" + perMilleFmt + "}", value));
// Displays 3.54‰      
double value = .00354;
string perMilleFmt = "#0.## " + '\u2030';
Console.WriteLine(value.ToString(perMilleFmt, CultureInfo.InvariantCulture));
Console.WriteLine(String.Format(CultureInfo.InvariantCulture, 
                                "{0:" + perMilleFmt + "}", value));
// Displays 3.54‰      
Dim value As Double = .00354
Dim perMilleFmt As String = "#0.## " & ChrW(&h2030)
Console.WriteLine(value.ToString(perMilleFmt, CultureInfo.InvariantCulture))
Console.WriteLine(String.Format(CultureInfo.InvariantCulture, 
                                "{0:" + perMilleFmt + "}", value))
' Displays 3.54 ‰      

Torna alla tabellaBack to table

Identificatori personalizzati "E" ed "e"The "E" and "e" custom specifiers

Se nella stringa di formato è presente una delle stringhe "E", "E+", "E-", "e", "e+" o "e-" immediatamente seguita da almeno uno zero, il numero viene formattato usando la notazione scientifica con una "E" o "e" inserita tra il numero e l'esponente.If any of the strings "E", "E+", "E-", "e", "e+", or "e-" are present in the format string and are followed immediately by at least one zero, the number is formatted by using scientific notation with an "E" or "e" inserted between the number and the exponent. Il numero di zeri che seguono l'indicatore della notazione scientifica determina il numero minimo di cifre da visualizzare nell'output per l'esponente.The number of zeros following the scientific notation indicator determines the minimum number of digits to output for the exponent. I formati "E+" ed "e+" indicano che l'esponente deve essere sempre preceduto da un segno più o meno.The "E+" and "e+" formats indicate that a plus sign or minus sign should always precede the exponent. I formati "E", "E-", "e" ed "e-" indicano che solo gli esponenti negativi devono essere preceduti da un carattere di segno.The "E", "E-", "e", or "e-" formats indicate that a sign character should precede only negative exponents.

Nell'esempio seguente vengono formattati alcuni valori numerici usando gli identificatori per notazione scientifica.The following example formats several numeric values using the specifiers for scientific notation.

double value = 86000;
Console::WriteLine(value.ToString("0.###E+0", CultureInfo::InvariantCulture));
Console::WriteLine(String::Format(CultureInfo::InvariantCulture, 
                                "{0:0.###E+0}", value));
// Displays 8.6E+4

Console::WriteLine(value.ToString("0.###E+000", CultureInfo::InvariantCulture));
Console::WriteLine(String::Format(CultureInfo::InvariantCulture, 
                                "{0:0.###E+000}", value));
// Displays 8.6E+004

Console::WriteLine(value.ToString("0.###E-000", CultureInfo::InvariantCulture));
Console::WriteLine(String::Format(CultureInfo::InvariantCulture, 
                                "{0:0.###E-000}", value));
// Displays 8.6E004
double value = 86000;
Console.WriteLine(value.ToString("0.###E+0", CultureInfo.InvariantCulture));
Console.WriteLine(String.Format(CultureInfo.InvariantCulture, 
                                "{0:0.###E+0}", value));
// Displays 8.6E+4

Console.WriteLine(value.ToString("0.###E+000", CultureInfo.InvariantCulture));
Console.WriteLine(String.Format(CultureInfo.InvariantCulture, 
                                "{0:0.###E+000}", value));
// Displays 8.6E+004

Console.WriteLine(value.ToString("0.###E-000", CultureInfo.InvariantCulture));
Console.WriteLine(String.Format(CultureInfo.InvariantCulture, 
                                "{0:0.###E-000}", value));
// Displays 8.6E004
Dim value As Double = 86000
Console.WriteLine(value.ToString("0.###E+0", CultureInfo.InvariantCulture))
Console.WriteLine(String.Format(CultureInfo.InvariantCulture, 
                                "{0:0.###E+0}", value))
' Displays 8.6E+4

Console.WriteLine(value.ToString("0.###E+000", CultureInfo.InvariantCulture))
Console.WriteLine(String.Format(CultureInfo.InvariantCulture, 
                                "{0:0.###E+000}", value))
' Displays 8.6E+004

Console.WriteLine(value.ToString("0.###E-000", CultureInfo.InvariantCulture))
Console.WriteLine(String.Format(CultureInfo.InvariantCulture, 
                                "{0:0.###E-000}", value))
' Displays 8.6E004

Torna alla tabellaBack to table

Carattere di escape "\"The "\" escape character

I simboli "#", "0", ".", ",", "%" e "‰" in una stringa di formato vengono interpretati come identificatori di formato anziché come caratteri letterali.The "#", "0", ".", ",", "%", and "‰" symbols in a format string are interpreted as format specifiers rather than as literal characters. A seconda della posizione in una stringa di formato personalizzata, anche la "E" maiuscola e minuscola nonché i simboli + e - possono essere interpretati come identificatori di formato.Depending on their position in a custom format string, the uppercase and lowercase "E" as well as the + and - symbols may also be interpreted as format specifiers.

Per impedire che un carattere venga interpretato come un identificatore di formato, è possibile anteporvi una barra rovesciata (), che rappresenta il carattere di escape.To prevent a character from being interpreted as a format specifier, you can precede it with a backslash, which is the escape character. Il carattere di escape indica che il carattere seguente è un valore letterale carattere che deve essere incluso nella stringa di risultato senza modifiche.The escape character signifies that the following character is a character literal that should be included in the result string unchanged.

Per includere una barra rovesciata in una stringa dei risultati, è necessario aggiungere un carattere di escape facendolo quindi precedere da un'altra barra rovesciata (\\).To include a backslash in a result string, you must escape it with another backslash (\\).

Nota

Alcuni compilatori, ad esempio i compilatori C++ e C#, possono anche interpretare un singolo carattere barra rovesciata come carattere di escape.Some compilers, such as the C++ and C# compilers, may also interpret a single backslash character as an escape character. Per assicurarsi che una stringa venga interpretata correttamente quando viene eseguita la formattazione, è possibile usare il carattere del valore letterale stringa letterale (carattere @) prima della stringa in C# o aggiungere un altro carattere barra rovesciata prima di ogni barra rovesciata in C# e C++.To ensure that a string is interpreted correctly when formatting, you can use the verbatim string literal character (the @ character) before the string in C#, or add another backslash character before each backslash in C# and C++. Nell'esempio C# seguente vengono illustrati entrambi gli approcci.The following C# example illustrates both approaches.

Nell'esempio seguente viene usato il carattere di escape per evitare che durante l'operazione di formattazione i caratteri "#", "0" e "\" vengano interpretati come caratteri di escape o identificatori di formato.The following example uses the escape character to prevent the formatting operation from interpreting the "#", "0", and "\" characters as either escape characters or format specifiers. Negli esempi C# viene usata una barra rovesciata aggiuntiva per garantire che la barra rovesciata venga interpretata come carattere letterale.The C# examples uses an additional backslash to ensure that a backslash is interpreted as a literal character.

int value = 123;
Console::WriteLine(value.ToString("\\#\\#\\# ##0 dollars and \\0\\0 cents \\#\\#\\#"));
Console::WriteLine(String::Format("{0:\\#\\#\\# ##0 dollars and \\0\\0 cents \\#\\#\\#}",
                                  value));
// Displays ### 123 dollars and 00 cents ###

Console::WriteLine(value.ToString("\\#\\#\\# ##0 dollars and \0\0 cents \\#\\#\\#"));
Console::WriteLine(String::Format("{0:\\#\\#\\# ##0 dollars and \0\0 cents \\#\\#\\#}",
                                value));
// Displays ### 123 dollars and 00 cents ###

Console::WriteLine(value.ToString("\\\\\\\\\\\\ ##0 dollars and \\0\\0 cents \\\\\\\\\\\\"));
Console::WriteLine(String::Format("{0:\\\\\\\\\\\\ ##0 dollars and \\0\\0 cents \\\\\\\\\\\\}",
                                value));
// Displays \\\ 123 dollars and 00 cents \\\

Console::WriteLine(value.ToString("\\\\\\ ##0 dollars and \0\0 cents \\\\\\"));
Console::WriteLine(String::Format("{0:\\\\\\ ##0 dollars and \0\0 cents \\\\\\}",
                                value));
// Displays \\\ 123 dollars and 00 cents \\\
int value = 123;
Console.WriteLine(value.ToString("\\#\\#\\# ##0 dollars and \\0\\0 cents \\#\\#\\#"));
Console.WriteLine(String.Format("{0:\\#\\#\\# ##0 dollars and \\0\\0 cents \\#\\#\\#}",
                                value));
// Displays ### 123 dollars and 00 cents ###

Console.WriteLine(value.ToString(@"\#\#\# ##0 dollars and \0\0 cents \#\#\#"));
Console.WriteLine(String.Format(@"{0:\#\#\# ##0 dollars and \0\0 cents \#\#\#}",
                                value));
// Displays ### 123 dollars and 00 cents ###

Console.WriteLine(value.ToString("\\\\\\\\\\\\ ##0 dollars and \\0\\0 cents \\\\\\\\\\\\"));
Console.WriteLine(String.Format("{0:\\\\\\\\\\\\ ##0 dollars and \\0\\0 cents \\\\\\\\\\\\}",
                                value));
// Displays \\\ 123 dollars and 00 cents \\\

Console.WriteLine(value.ToString(@"\\\\\\ ##0 dollars and \0\0 cents \\\\\\"));
Console.WriteLine(String.Format(@"{0:\\\\\\ ##0 dollars and \0\0 cents \\\\\\}",
                                value));
// Displays \\\ 123 dollars and 00 cents \\\
Dim value As Integer = 123
Console.WriteLine(value.ToString("\#\#\# ##0 dollars and \0\0 cents \#\#\#"))
Console.WriteLine(String.Format("{0:\#\#\# ##0 dollars and \0\0 cents \#\#\#}", 
                                value))
' Displays ### 123 dollars and 00 cents ###

Console.WriteLine(value.ToString("\\\\\\ ##0 dollars and \0\0 cents \\\\\\"))
Console.WriteLine(String.Format("{0:\\\\\\ ##0 dollars and \0\0 cents \\\\\\}", 
                                value))
' Displays \\\ 123 dollars and 00 cents \\\

Torna alla tabellaBack to table

Separatore di sezione ";"The ";" section separator

Il punto e virgola (;) è un identificatore di formato condizionale che applica una formattazione diversa a un numero, a seconda del fatto che il suo valore sia positivo, negativo o zero.The semicolon (;) is a conditional format specifier that applies different formatting to a number depending on whether its value is positive, negative, or zero. A tale scopo, una stringa di formato personalizzata può contenere un massimo di tre sezioni separate da punti e virgola.To produce this behavior, a custom format string can contain up to three sections separated by semicolons. Queste sezioni sono descritte nella tabella seguente.These sections are described in the following table.

Numero di sezioniNumber of sections DescrizioneDescription
UnaOne section La stringa di formato viene applicata a tutti i valori.The format string applies to all values.
DueTwo sections La prima sezione viene applicata ai valori positivi e agli zeri, la seconda ai valori negativi.The first section applies to positive values and zeros, and the second section applies to negative values.

Se il numero da formattare è negativo, ma diventa zero dopo l'arrotondamento in base al formato della seconda sezione, lo zero risultante viene formattato in base alla prima sezione.If the number to be formatted is negative, but becomes zero after rounding according to the format in the second section, the resulting zero is formatted according to the first section.
TreThree sections La prima sezione viene applicata ai valori positivi, la seconda ai valori negativi e la terza agli zeri.The first section applies to positive values, the second section applies to negative values, and the third section applies to zeros.

È possibile che la seconda sezione venga lasciata vuota, ovvero senza alcun valore tra i punti e virgola. In questo caso la prima sezione viene applicata a tutti i valori diversi da zero.The second section can be left empty (by having nothing between the semicolons), in which case the first section applies to all nonzero values.

Se il numero da formattare è diverso da zero, ma diventa zero dopo l'arrotondamento in base al formato della prima o della seconda sezione, lo zero risultante viene formattato in base alla terza sezione.If the number to be formatted is nonzero, but becomes zero after rounding according to the format in the first or second section, the resulting zero is formatted according to the third section.

Con i separatori di sezione, quando viene formattato il valore finale viene ignorata qualsiasi formattazione preesistente associata a un numero.Section separators ignore any preexisting formatting associated with a number when the final value is formatted. Quando vengono usati separatori di sezione, ad esempio, i numeri negativi vengono sempre visualizzati senza segno meno.For example, negative values are always displayed without a minus sign when section separators are used. Se si desidera che il valore formattato finale disponga di un segno meno, è opportuno includere il segno meno in modo esplicito nell'ambito dell'identificatore di formato personalizzato.If you want the final formatted value to have a minus sign, you should explicitly include the minus sign as part of the custom format specifier.

Nell'esempio seguente viene usato l'identificatore di formato ";" per formattare numeri positivi, negativi e zero in modo diverso.The following example uses the ";" format specifier to format positive, negative, and zero numbers differently.

double posValue = 1234;
double negValue = -1234;
double zeroValue = 0;

String^ fmt2 = "##;(##)";
String^ fmt3 = "##;(##);**Zero**";

Console::WriteLine(posValue.ToString(fmt2));  
Console::WriteLine(String::Format("{0:" + fmt2 + "}", posValue));    
// Displays 1234

Console::WriteLine(negValue.ToString(fmt2));  
Console::WriteLine(String::Format("{0:" + fmt2 + "}", negValue));    
// Displays (1234)

Console::WriteLine(zeroValue.ToString(fmt3)); 
Console::WriteLine(String::Format("{0:" + fmt3 + "}", zeroValue));
// Displays **Zero**
double posValue = 1234;
double negValue = -1234;
double zeroValue = 0;

string fmt2 = "##;(##)";
string fmt3 = "##;(##);**Zero**";

Console.WriteLine(posValue.ToString(fmt2));  
Console.WriteLine(String.Format("{0:" + fmt2 + "}", posValue));    
// Displays 1234

Console.WriteLine(negValue.ToString(fmt2));  
Console.WriteLine(String.Format("{0:" + fmt2 + "}", negValue));    
// Displays (1234)

Console.WriteLine(zeroValue.ToString(fmt3)); 
Console.WriteLine(String.Format("{0:" + fmt3 + "}", zeroValue));
// Displays **Zero**
Dim posValue As Double = 1234
Dim negValue As Double = -1234
Dim zeroValue As Double = 0

Dim fmt2 As String = "##;(##)"
Dim fmt3 As String = "##;(##);**Zero**"

Console.WriteLine(posValue.ToString(fmt2))   
Console.WriteLine(String.Format("{0:" + fmt2 + "}", posValue))    
' Displays 1234

Console.WriteLine(negValue.ToString(fmt2))   
Console.WriteLine(String.Format("{0:" + fmt2 + "}", negValue))    
' Displays (1234)

Console.WriteLine(zeroValue.ToString(fmt3))  
Console.WriteLine(String.Format("{0:" + fmt3 + "}", zeroValue))
' Displays **Zero**

Torna alla tabellaBack to table

Valori letterali carattereCharacter literals

Gli identificatori di formato presenti in una stringa di formato numerico personalizzato vengono sempre interpretati come caratteri di formattazione e mai come caratteri letterali.Format specifiers that appear in a custom numeric format string are always interpreted as formatting characters and never as literal characters. Sono inclusi i caratteri seguenti:This includes the following characters:

  • 00
  • #
  • %
  • ''
  • \
  • ..
  • ,,
  • E o e, in base alla posizione nella stringa di formato.E or e, depending on its position in the format string.

Tutti gli altri caratteri vengono sempre interpretati come valori letterali carattere e in un'operazione di formattazione vengono inclusi senza modifiche nella stringa di risultato.All other characters are always interpreted as character literals and, in a formatting operation, are included in the result string unchanged. In un'operazione di analisi questi caratteri devono corrispondere esattamente ai caratteri nella stringa di input. Il confronto tiene conto di maiuscole e minuscole.In a parsing operation, they must match the characters in the input string exactly; the comparison is case-sensitive.

L'esempio seguente illustra un uso comune di unità di carattere letterale (in questo caso migliaia):The following example illustrates one common use of literal character units (in this case, thousands):

double n = 123.8;
Console.WriteLine($"{n:#,##0.0K}");
// The example displays the following output:
//      123.8K   
Dim n As Double = 123.8
Console.WriteLine($"{n:#,##0.0K}")
' The example displays the following output:
'       123.8K

Esistono due modi per indicare che determinati caratteri devono essere interpretati come caratteri letterali e non come caratteri di formattazione, in modo da includerli in una stringa di risultato o eseguirne l'analisi in una stringa di input:There are two ways to indicate that characters are to be interpreted as literal characters and not as formatting characters, so that they can be included in a result string or successfully parsed in an input string:

  • Usando un carattere di escape per un carattere di formattazione.By escaping a formatting character. Per altre informazioni, vedere Carattere di escape "\".For more information, see The "\" escape character.

  • Racchiudendo l'intera stringa letterale tra apostrofi.By enclosing the entire literal string in quotation apostrophes.

L'esempio seguente usa entrambi gli approcci per includere i caratteri riservati in una stringa di formato numerico personalizzato.The following example uses both approaches to include reserved characters in a custom numeric format string.

 [!code-csharp-interactive[including reserved characters](~/samples/snippets/csharp/VS_Snippets_CLR/formatting.numeric.custom/cs/literal1.cs#1)]
 [!code-vb[including reserved characters](~/samples/snippets/visualbasic/VS_Snippets_CLR/formatting.numeric.custom/vb/literal1.vb#1)]  

NoteNotes

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, NegativeInfinitySymbolo 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 specified by the currently applicable NumberFormatInfo object.

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, and the current thread culture provides values used to govern formatting. Computer con impostazioni diverse generano stringhe di risultato diverse.Computers that use different settings generate different result strings.

Se inoltre 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 tramite Opzioni internazionali e della lingua nel Pannello di controllo verranno applicate al nuovo oggetto CultureInfo.In addition, if you use the CultureInfo.CultureInfo(String) constructor 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.

Arrotondamento e stringhe di formato a virgola fissaRounding and fixed-point format strings

Per le stringhe di formato a virgola fissa, ovvero stringhe di formato non contenenti caratteri di formato in notazione scientifica, i numeri vengono arrotondati al numero di posizioni decimali corrispondente al numero di segnaposto per cifre a destra del separatore decimale.For fixed-point format strings (that is, format strings that do not contain scientific notation format characters), numbers are rounded to as many decimal places as there are digit placeholders to the right of the decimal point. Se la stringa di formato non contiene alcun separatore decimale, il numero viene arrotondato all'intero più vicino.If the format string does not contain a decimal point, the number is rounded to the nearest integer. Se le cifre del numero sono più numerose dei segnaposto per le cifre riportati a sinistra del separatore decimale, le cifre eccedenti vengono copiate nella stringa di risultato immediatamente prima del primo segnaposto per le cifre.If the number has more digits than there are digit placeholders to the left of the decimal point, the extra digits are copied to the result string immediately before the first digit placeholder.

Torna alla tabellaBack to table

EsempioExample

Nell'esempio seguente vengono illustrate due stringhe di formato numerico personalizzate.The following example demonstrates two custom numeric format strings. In entrambi i casi il segnaposto per le cifre (#) consente di visualizzare i dati numerici e tutti gli altri caratteri vengono copiati nella stringa di risultato.In both cases, the digit placeholder (#) displays the numeric data, and all other characters are copied to the result string.

double number1 = 1234567890;
String^ value1 = number1.ToString("(###) ###-####");
Console::WriteLine(value1);

int number2 = 42;
String^ value2 = number2.ToString("My Number = #");
Console::WriteLine(value2);
// The example displays the following output:
//       (123) 456-7890
//       My Number = 42
double number1 = 1234567890;
string value1 = number1.ToString("(###) ###-####");
Console.WriteLine(value1);

int number2 = 42;
string value2 = number2.ToString("My Number = #");
Console.WriteLine(value2);
// The example displays the following output:
//       (123) 456-7890
//       My Number = 42
Dim number1 As Double = 1234567890
Dim value1 As String = number1.ToString("(###) ###-####")
Console.WriteLine(value1)

Dim number2 As Integer = 42
Dim value2 As String = number2.ToString("My Number = #")
Console.WriteLine(value2)
' The example displays the following output:
'       (123) 456-7890
'       My Number = 42

Torna alla tabellaBack to table

Vedere ancheSee also

System.Globalization.NumberFormatInfo
Formattazione di tipiFormatting Types
Standard Numeric Format StringsStandard Numeric Format Strings
Procedura: Aggiungere zeri iniziali a un numeroHow to: Pad a Number with Leading Zeros
Esempio: Utilità di formattazione in .NET Framework 4Sample: .NET Framework 4 Formatting Utility