Tipi di formato in .NETFormat types in .NET

La formattazione è il processo di conversione di un'istanza di una classe, una struttura o un valore di enumerazione nella relativa rappresentazione di stringa, eseguito spesso in modo che la stringa risultante possa essere visualizzata dagli utenti o deserializzata per ripristinare il tipo di dati originale.Formatting is the process of converting an instance of a class, structure, or enumeration value to its string representation, often so that the resulting string can be displayed to users or deserialized to restore the original data type. Questa conversione può comportare le difficoltà seguenti:This conversion can pose a number of challenges:

  • Il modo in cui i valori vengono archiviati internamente non riflette necessariamente il modo in cui gli utenti desiderano visualizzarli.The way that values are stored internally does not necessarily reflect the way that users want to view them. Un numero di telefono potrebbe ad esempio venire archiviato nel formato 8009999999, che non è di immediata comprensione.For example, a telephone number might be stored in the form 8009999999, which is not user-friendly. Potrebbe invece essere preferibile visualizzarlo come 02 123 456.It should instead be displayed as 800-999-9999. Vedere la sezione Stringhe di formato personalizzate per un esempio in cui un numero viene formattato in questo modo.See the Custom Format Strings section for an example that formats a number in this way.

  • La conversione di un oggetto nella relativa rappresentazione di stringa non è sempre intuitiva.Sometimes the conversion of an object to its string representation is not intuitive. Non è ad esempio chiaro come dovrebbe venire visualizzata la rappresentazione di stringa di un oggetto Temperature o di un oggetto Person.For example, it is not clear how the string representation of a Temperature object or a Person object should appear. Per un esempio in cui viene formattato un oggetto Temperature in modi diversi, vedere la sezione Stringhe di formato standard .For an example that formats a Temperature object in a variety of ways, see the Standard Format Strings section.

  • I valori richiedono spesso una formattazione dipendente dalle impostazioni cultura.Values often require culture-sensitive formatting. In un'applicazione in cui vengono usati i numeri per riflettere valori monetari, ad esempio, le stringhe numeriche devono includere il simbolo di valuta, il separatore di gruppi, che nella maggior parte delle impostazioni cultura corrisponde al separatore delle migliaia, e il separatore decimale delle impostazioni cultura correnti.For example, in an application that uses numbers to reflect monetary values, numeric strings should include the current culture’s currency symbol, group separator (which, in most cultures, is the thousands separator), and decimal symbol. Per un esempio, vedere la sezione formattazione dipendente dalle impostazioni cultura con provider di formato .For an example, see the Culture-sensitive formatting with format providers section.

  • È possibile che in un'applicazione lo stesso valore debba essere visualizzato in diversi modi.An application may have to display the same value in different ways. È ad esempio possibile che un membro di enumerazione venga rappresentato visualizzando una rappresentazione di stringa del relativo nome oppure visualizzando il relativo valore sottostante.For example, an application may represent an enumeration member by displaying a string representation of its name or by displaying its underlying value. Per un esempio in cui viene formattato un membro dell'enumerazione DayOfWeek in modi diversi, vedere la sezione Stringhe di formato standard .For an example that formats a member of the DayOfWeek enumeration in different ways, see the Standard Format Strings section.

Nota

La formattazione consente di convertire il valore di un tipo in una rappresentazione di stringa,Formatting converts the value of a type into a string representation. mentre l'analisi è l'operazione inversa.Parsing is the inverse of formatting. Un'operazione di analisi consente di creare un'istanza di un tipo di dati dalla relativa rappresentazione di stringa.A parsing operation creates an instance of a data type from its string representation. Per informazioni sulla conversione di stringhe in altri tipi di dati, vedere Parsing Strings.For information about converting strings to other data types, see Parsing Strings.

In .NET è disponibile un supporto avanzato della formattazione che consente agli sviluppatori di soddisfare questi requisiti..NET provides rich formatting support that enables developers to address these requirements.

Formattazione in .NETFormatting in .NET

Il meccanismo di base per la formattazione è costituito dall'implementazione predefinita del metodo Object.ToString, illustrato nella sezione Formattazione predefinita tramite il metodo ToString più avanti in questo argomento.The basic mechanism for formatting is the default implementation of the Object.ToString method, which is discussed in the Default Formatting Using the ToString Method section later in this topic. In .NET sono tuttavia disponibili diversi metodi per modificare ed estendere il supporto predefinito della formattazione,However, .NET provides several ways to modify and extend its default formatting support. tra cui:These include the following:

  • Override del metodo Object.ToString per definire una rappresentazione di stringa personalizzata del valore di un oggetto.Overriding the Object.ToString method to define a custom string representation of an object’s value. Per ulteriori informazioni, vedere la sezione override del metodo ToString più avanti in questo argomento.For more information, see the Override the ToString Method section later in this topic.

  • Definizione di identificatori di formato che consentono l'assunzione di più forme da parte della rappresentazione di stringa del valore di un oggetto.Defining format specifiers that enable the string representation of an object’s value to take multiple forms. L'identificatore di formato "X" nell'istruzione seguente consente, ad esempio, di convertire un valore intero nella rappresentazione di stringa di un valore esadecimale.For example, the "X" format specifier in the following statement converts an integer to the string representation of a hexadecimal value.

    int integerValue = 60312;
    Console.WriteLine(integerValue.ToString("X"));   // Displays EB98.
    
    Dim integerValue As Integer = 60312
    Console.WriteLine(integerValue.ToString("X"))   ' Displays EB98.
    

    Per altre informazioni sugli identificatori di formato, vedere la sezione Metodo ToString e stringhe di formato .For more information about format specifiers, see the ToString Method and Format Strings section.

  • Uso di provider di formato per sfruttare le convenzioni di formattazione di impostazioni cultura specifiche.Using format providers to take advantage of the formatting conventions of a specific culture. Nell'istruzione seguente, ad esempio, viene visualizzato un valore di valuta usando le convenzioni di formattazione delle impostazioni cultura en-US.For example, the following statement displays a currency value by using the formatting conventions of the en-US culture.

    double cost = 1632.54; 
    Console.WriteLine(cost.ToString("C", 
                      new System.Globalization.CultureInfo("en-US")));   
    // The example displays the following output:
    //       $1,632.54
    
    Dim cost As Double = 1632.54
    Console.WriteLine(cost.ToString("C", New System.Globalization.CultureInfo("en-US")))
    ' The example displays the following output:
    '       $1,632.54
    

    Per ulteriori informazioni sulla formattazione con i provider di formato, vedere la sezione provider di formato .For more information about formatting with format providers, see the Format Providers section.

  • Implementazione dell'interfaccia IFormattable per supportare sia la conversione di stringa con la classe Convert che la formattazione composita.Implementing the IFormattable interface to support both string conversion with the Convert class and composite formatting. Per altre informazioni, vedere la sezione Interfaccia IFormattable .For more information, see the IFormattable Interface section.

  • Uso della formattazione composita per incorporare la rappresentazione di stringa di un valore in una stringa di dimensioni maggiori.Using composite formatting to embed the string representation of a value in a larger string. Per altre informazioni, vedere la sezione Formattazione composita .For more information, see the Composite Formatting section.

  • Implementazione di ICustomFormatter e IFormatProvider per fornire una soluzione di formattazione personalizzata completa.Implementing ICustomFormatter and IFormatProvider to provide a complete custom formatting solution. Per altre informazioni, vedere la sezione Formattazione personalizzata con ICustomFormatter .For more information, see the Custom Formatting with ICustomFormatter section.

Nelle sezioni seguenti vengono esaminati questi metodi per la conversione di un oggetto nella relativa rappresentazione di stringa.The following sections examine these methods for converting an object to its string representation.

Formattazione predefinita tramite il metodo ToStringDefault formatting using the ToString method

Ogni tipo derivato da System.Object eredita automaticamente un metodo ToString senza parametri che, per impostazione predefinita, restituisce il nome del tipo.Every type that is derived from System.Object automatically inherits a parameterless ToString method, which returns the name of the type by default. Nell'esempio seguente viene illustrato il metodo ToString predefinito.The following example illustrates the default ToString method. Viene definita una classe denominata Automobile che non dispone di implementazione.It defines a class named Automobile that has no implementation. Quando viene creata un'istanza della classe e viene chiamato il relativo metodo ToString , viene visualizzato il nome del tipo relativo.When the class is instantiated and its ToString method is called, it displays its type name. Si noti che il metodo ToString non viene chiamato in modo esplicito nell'esempio.Note that the ToString method is not explicitly called in the example. Il metodo Console.WriteLine(Object) chiama in modo implicito il metodo ToString dell'oggetto passato come argomento.The Console.WriteLine(Object) method implicitly calls the ToString method of the object passed to it as an argument.

using System;

public class Automobile
{
   // No implementation. All members are inherited from Object.
}

public class Example
{
   public static void Main()
   {
      Automobile firstAuto = new Automobile();
      Console.WriteLine(firstAuto);
   }
}
// The example displays the following output:
//       Automobile
Public Class Automobile
   ' No implementation. All members are inherited from Object.
End Class

Module Example
   Public Sub Main()
      Dim firstAuto As New Automobile()
      Console.WriteLine(firstAuto)
   End Sub
End Module
' The example displays the following output:
'       Automobile

Avviso

A partire da Windows 8,1Windows 8.1, Windows Runtime include un'interfaccia IStringable con un singolo metodo, IStringable.ToString, che fornisce supporto per la formattazione predefinito.Starting with Windows 8,1Windows 8.1, the Windows Runtime includes an IStringable interface with a single method, IStringable.ToString, which provides default formatting support. È tuttavia consigliabile che i tipi gestiti non implementino l'interfaccia IStringable .However, we recommend that managed types do not implement the IStringable interface. Per altre informazioni, vedere la sezione "Windows Runtime e l'interfaccia IStringable" nella pagina di riferimento Object.ToString.For more information, see "The Windows Runtime and the IStringable Interface" section on the Object.ToString reference page.

Poiché tutti i tipi diversi dalle interfacce sono derivati da Object, questa funzionalità viene fornita automaticamente alle classi o alle strutture personalizzate.Because all types other than interfaces are derived from Object, this functionality is automatically provided to your custom classes or structures. La funzionalità offerta dal metodo ToString predefinito è tuttavia limitata poiché non fornisce informazioni su un'istanza del tipo sebbene consenta di identificarlo.However, the functionality offered by the default ToString method, is limited: Although it identifies the type, it fails to provide any information about an instance of the type. Per fornire una rappresentazione di stringa di un oggetto che fornisce informazioni su tale oggetto, è necessario eseguire l'override del metodo ToString .To provide a string representation of an object that provides information about that object, you must override the ToString method.

Nota

Le strutture ereditano dall'oggetto ValueType, che a sua volta viene derivato da Object.Structures inherit from ValueType, which in turn is derived from Object. Sebbene ValueType esegua l'override di Object.ToString, l'implementazione è identica.Although ValueType overrides Object.ToString, its implementation is identical.

Eseguire l'override del metodo ToStringOverride the ToString method

La visualizzazione del nome di un tipo ha spesso un uso limitato e non consente agli utenti dei tipi di distinguere tra le istanze.Displaying the name of a type is often of limited use and does not allow consumers of your types to differentiate one instance from another. È tuttavia possibile eseguire l'override del metodo ToString per fornire una rappresentazione più utile del valore di un oggetto.However, you can override the ToString method to provide a more useful representation of an object’s value. Nell'esempio seguente viene definito un oggetto Temperature e viene eseguito l'override del relativo metodo ToString per visualizzare la temperatura in gradi Celsius.The following example defines a Temperature object and overrides its ToString method to display the temperature in degrees Celsius.

using System;

public class Temperature
{
   private decimal temp;
   
   public Temperature(decimal temperature)
   {
      this.temp = temperature;   
   }

   public override string ToString()
   {
      return this.temp.ToString("N1") + "°C";
   }
}

public class Example
{
   public static void Main()
   {
      Temperature currentTemperature = new Temperature(23.6m);
      Console.WriteLine("The current temperature is " +
                        currentTemperature.ToString());
   }
}
// The example displays the following output:
//       The current temperature is 23.6°C.
Public Class Temperature
   Private temp As Decimal
   
   Public Sub New(temperature As Decimal)
      Me.temp = temperature
   End Sub
   
   Public Overrides Function ToString() As String
      Return Me.temp.ToString("N1") + "°C"   
   End Function
End Class

Module Example
   Public Sub Main()
      Dim currentTemperature As New Temperature(23.6d)
      Console.WriteLine("The current temperature is " +
                        currentTemperature.ToString())
   End Sub
End Module
' The example displays the following output:
'       The current temperature is 23.6°C.

In .NET è stato eseguito l'override del metodo ToString di ogni tipo di valore primitivo per visualizzare il valore dell'oggetto invece del nome.In .NET, the ToString method of each primitive value type has been overridden to display the object’s value instead of its name. Nella tabella seguente viene illustrato l'override per ogni tipo primitivo.The following table shows the override for each primitive type. Si noti che la maggior parte dei metodi sottoposti a override chiama un altro overload del metodo ToString e passa a esso l'identificatore di formato "G", che definisce il formato generale per il tipo, e un oggetto IFormatProvider , che rappresenta le impostazioni cultura correnti.Note that most of the overridden methods call another overload of the ToString method and pass it the "G" format specifier, which defines the general format for its type, and an IFormatProvider object that represents the current culture.

DigitareType Override di ToStringToString override
Boolean Restituisce Boolean.TrueString o Boolean.FalseString.Returns either Boolean.TrueString or Boolean.FalseString.
Byte Chiama Byte.ToString("G", NumberFormatInfo.CurrentInfo) per formattare il valore Byte per le impostazioni cultura correnti.Calls Byte.ToString("G", NumberFormatInfo.CurrentInfo) to format the Byte value for the current culture.
Char Restituisce il carattere come stringa.Returns the character as a string.
DateTime Chiama DateTime.ToString("G", DatetimeFormatInfo.CurrentInfo) per formattare il valore di data e ora per le impostazioni cultura correnti.Calls DateTime.ToString("G", DatetimeFormatInfo.CurrentInfo) to format the date and time value for the current culture.
Decimal Chiama Decimal.ToString("G", NumberFormatInfo.CurrentInfo) per formattare il valore Decimal per le impostazioni cultura correnti.Calls Decimal.ToString("G", NumberFormatInfo.CurrentInfo) to format the Decimal value for the current culture.
Double Chiama Double.ToString("G", NumberFormatInfo.CurrentInfo) per formattare il valore Double per le impostazioni cultura correnti.Calls Double.ToString("G", NumberFormatInfo.CurrentInfo) to format the Double value for the current culture.
Int16 Chiama Int16.ToString("G", NumberFormatInfo.CurrentInfo) per formattare il valore Int16 per le impostazioni cultura correnti.Calls Int16.ToString("G", NumberFormatInfo.CurrentInfo) to format the Int16 value for the current culture.
Int32 Chiama Int32.ToString("G", NumberFormatInfo.CurrentInfo) per formattare il valore Int32 per le impostazioni cultura correnti.Calls Int32.ToString("G", NumberFormatInfo.CurrentInfo) to format the Int32 value for the current culture.
Int64 Chiama Int64.ToString("G", NumberFormatInfo.CurrentInfo) per formattare il valore Int64 per le impostazioni cultura correnti.Calls Int64.ToString("G", NumberFormatInfo.CurrentInfo) to format the Int64 value for the current culture.
SByte Chiama SByte.ToString("G", NumberFormatInfo.CurrentInfo) per formattare il valore SByte per le impostazioni cultura correnti.Calls SByte.ToString("G", NumberFormatInfo.CurrentInfo) to format the SByte value for the current culture.
Single Chiama Single.ToString("G", NumberFormatInfo.CurrentInfo) per formattare il valore Single per le impostazioni cultura correnti.Calls Single.ToString("G", NumberFormatInfo.CurrentInfo) to format the Single value for the current culture.
UInt16 Chiama UInt16.ToString("G", NumberFormatInfo.CurrentInfo) per formattare il valore UInt16 per le impostazioni cultura correnti.Calls UInt16.ToString("G", NumberFormatInfo.CurrentInfo) to format the UInt16 value for the current culture.
UInt32 Chiama UInt32.ToString("G", NumberFormatInfo.CurrentInfo) per formattare il valore UInt32 per le impostazioni cultura correnti.Calls UInt32.ToString("G", NumberFormatInfo.CurrentInfo) to format the UInt32 value for the current culture.
UInt64 Chiama UInt64.ToString("G", NumberFormatInfo.CurrentInfo) per formattare il valore UInt64 per le impostazioni cultura correnti.Calls UInt64.ToString("G", NumberFormatInfo.CurrentInfo) to format the UInt64 value for the current culture.

Metodo ToString e stringhe di formatoThe ToString method and format strings

L'utilizzo del metodo ToString predefinito o l'esecuzione dell'override di ToString è un'operazione appropriata quando un oggetto dispone di una singola rappresentazione di stringa.Relying on the default ToString method or overriding ToString is appropriate when an object has a single string representation. Spesso, tuttavia, il valore di un oggetto dispone di più rappresentazioni.However, the value of an object often has multiple representations. È ad esempio possibile esprimere una temperatura in gradi Fahrenheit, gradi Celsius o gradi Kelvin.For example, a temperature can be expressed in degrees Fahrenheit, degrees Celsius, or kelvins. Analogamente, il valore intero 10 può essere rappresentato in diversi modi, tra cui 10, 10,0, 1.0e01 o €10,00.Similarly, the integer value 10 can be represented in numerous ways, including 10, 10.0, 1.0e01, or $10.00.

Per consentire a un singolo valore di disporre di più rappresentazioni di stringa, in .NET vengono usate le stringhe di formato.To enable a single value to have multiple string representations, .NET uses format strings. Una stringa di formato è una stringa che contiene uno o più identificatori di formato predefiniti costituiti da singoli caratteri o gruppi di caratteri che definiscono il modo in cui deve essere formattato l'output del metodo ToString .A format string is a string that contains one or more predefined format specifiers, which are single characters or groups of characters that define how the ToString method should format its output. La stringa di formato viene quindi passata come parametro al metodo ToString dell'oggetto per determinare come deve venire visualizzata la rappresentazione di stringa del valore di tale oggetto.The format string is then passed as a parameter to the object's ToString method and determines how the string representation of that object's value should appear.

Tutti i tipi numerici, di data e ora e di enumerazione in .NET supportano un set predefinito di identificatori di formato.All numeric types, date and time types, and enumeration types in .NET support a predefined set of format specifiers. È anche possibile usare le stringhe di formato per definire più rappresentazioni di stringa dei tipi di dati definiti dall'applicazione.You can also use format strings to define multiple string representations of your application-defined data types.

Stringhe di formato standardStandard format strings

Una stringa di formato standard contiene un singolo identificatore di formato, che è un carattere alfabetico che definisce la rappresentazione di stringa dell'oggetto a cui viene applicata, insieme a un identificatore di precisione facoltativo, che influisce sul numero di cifre visualizzate nella stringa di risultato.A standard format string contains a single format specifier, which is an alphabetic character that defines the string representation of the object to which it is applied, along with an optional precision specifier that affects how many digits are displayed in the result string. Se l'identificatore di precisione viene omesso o non è supportato, un identificatore di formato standard è equivalente a una stringa di formato standard.If the precision specifier is omitted or is not supported, a standard format specifier is equivalent to a standard format string.

In .NET viene definito un set di identificatori di formato standard per tutti i tipi numerici, di data e ora e di enumerazione..NET defines a set of standard format specifiers for all numeric types, all date and time types, and all enumeration types. Ognuna di queste categorie supporta, ad esempio, un identificatore di formato standard "G", che definisce una rappresentazione di stringa generale di un valore di tale tipo.For example, each of these categories supports a "G" standard format specifier, which defines a general string representation of a value of that type.

Le stringhe di formato standard per i tipi di enumerazione controllano direttamente la rappresentazione di stringa di un valore.Standard format strings for enumeration types directly control the string representation of a value. Le stringhe di formato passate al metodo ToString del valore di un'enumerazione determinano se il valore viene visualizzato tramite il relativo nome di stringa (identificatori di formato "G" e "F"), il relativo valore integrale sottostante (identificatore di formato "D") oppure il relativo valore esadecimale (identificatore di formato "X").The format strings passed to an enumeration value’s ToString method determine whether the value is displayed using its string name (the "G" and "F" format specifiers), its underlying integral value (the "D" format specifier), or its hexadecimal value (the "X" format specifier). Nell'esempio seguente viene illustrato l'uso delle stringhe di formato standard per formattare un valore dell'enumerazione DayOfWeek .The following example illustrates the use of standard format strings to format a DayOfWeek enumeration value.

DayOfWeek thisDay = DayOfWeek.Monday;
string[] formatStrings = {"G", "F", "D", "X"};

foreach (string formatString in formatStrings)
   Console.WriteLine(thisDay.ToString(formatString));
// The example displays the following output:
//       Monday
//       Monday
//       1
//       00000001
Dim thisDay As DayOfWeek = DayOfWeek.Monday
Dim formatStrings() As String = {"G", "F", "D", "X"}

For Each formatString As String In formatStrings
   Console.WriteLine(thisDay.ToString(formatString))
Next
' The example displays the following output:
'       Monday
'       Monday
'       1
'       00000001

Per informazioni sulle stringhe del formato di enumerazione, vedere Enumeration Format Strings.For information about enumeration format strings, see Enumeration Format Strings.

Le stringhe di formato standard per i tipi numerici definiscono in genere una stringa di risultato il cui aspetto preciso viene controllato da uno o più valori delle proprietà.Standard format strings for numeric types usually define a result string whose precise appearance is controlled by one or more property values. L'identificatore di formato "C", ad esempio, consente di formattare un numero come valore di valuta.For example, the "C" format specifier formats a number as a currency value. Quando si chiama il metodo ToString con l'identificatore di formato "C" come unico parametro, vengono usati i valori delle proprietà seguenti dell'oggetto NumberFormatInfo delle impostazioni cultura correnti per definire la rappresentazione di stringa del valore numerico:When you call the ToString method with the "C" format specifier as the only parameter, the following property values from the current culture’s NumberFormatInfo object are used to define the string representation of the numeric value:

  • Proprietà CurrencySymbol , che specifica il simbolo di valuta delle impostazioni cultura correnti.The CurrencySymbol property, which specifies the current culture’s currency symbol.

  • Proprietà CurrencyNegativePattern o CurrencyPositivePattern , che restituisce un valore intero che determina gli aspetti seguenti:The CurrencyNegativePattern or CurrencyPositivePattern property, which returns an integer that determines the following:

    • Posizione del simbolo di valuta.The placement of the currency symbol.

    • Utilizzo di un segno negativo iniziale, di un segno negativo finale o di parentesi per indicare i valori negativi.Whether negative values are indicated by a leading negative sign, a trailing negative sign, or parentheses.

    • Inserimento di uno spazio tra il valore numerico e il simbolo di valuta.Whether a space appears between the numeric value and the currency symbol.

  • Proprietà CurrencyDecimalDigits , che definisce il numero di cifre frazionarie nella stringa di risultato.The CurrencyDecimalDigits property, which defines the number of fractional digits in the result string.

  • Proprietà CurrencyDecimalSeparator , che definisce il simbolo del separatore decimale nella stringa di risultato.The CurrencyDecimalSeparator property, which defines the decimal separator symbol in the result string.

  • Proprietà CurrencyGroupSeparator , che definisce il simbolo del separatore di gruppi.The CurrencyGroupSeparator property, which defines the group separator symbol.

  • Proprietà CurrencyGroupSizes , che definisce il numero di cifre in ogni gruppo a sinistra del separatore decimale.The CurrencyGroupSizes property, which defines the number of digits in each group to the left of the decimal.

  • Proprietà NegativeSign , che determina il segno negativo usato nella stringa di risultato se non vengono usate parentesi per indicare i valori negativi.The NegativeSign property, which determines the negative sign used in the result string if parentheses are not used to indicate negative values.

Le stringhe di formato numerico possono inoltre includere un identificatore di precisione.In addition, numeric format strings may include a precision specifier. Il significato di questo identificatore dipende dalla stringa di formato con la quale viene usato, ma in genere esso indica il numero totale di cifre o il numero di cifre frazionarie che devono essere presenti nella stringa di risultato.The meaning of this specifier depends on the format string with which it is used, but it typically indicates either the total number of digits or the number of fractional digits that should appear in the result string. Nell'esempio seguente vengono usati, ad esempio, la stringa numerica standard "X4"e un identificatore di precisione per creare un valore stringa con quattro cifre esadecimali.For example, the following example uses the "X4" standard numeric string and a precision specifier to create a string value that has four hexadecimal digits.

byte[] byteValues = { 12, 163, 255 };
foreach (byte byteValue in byteValues)
   Console.WriteLine(byteValue.ToString("X4"));
// The example displays the following output:
//       000C
//       00A3
//       00FF
Dim byteValues() As Byte = { 12, 163, 255 }
For Each byteValue As Byte In byteValues
   Console.WriteLine(byteValue.ToString("X4"))
Next
' The example displays the following output:
'       000C
'       00A3
'       00FF

Per altre informazioni sulle stringhe di formattazione numerica standard, vedere Standard Numeric Format Strings.For more information about standard numeric formatting strings, see Standard Numeric Format Strings.

Le stringhe di formato standard per i valori di data e ora sono alias per stringhe di formato personalizzate archiviate da una proprietà DateTimeFormatInfo specifica.Standard format strings for date and time values are aliases for custom format strings stored by a particular DateTimeFormatInfo property. Se viene chiamato, ad esempio, il metodo ToString di un valore di data e ora con l'identificatore di formato "D", la data e l'ora vengono visualizzate usando la stringa di formato personalizzata archiviata nella proprietà DateTimeFormatInfo.LongDatePattern delle impostazioni cultura correnti.For example, calling the ToString method of a date and time value with the "D" format specifier displays the date and time by using the custom format string stored in the current culture’s DateTimeFormatInfo.LongDatePattern property. Per ulteriori informazioni sulle stringhe di formato personalizzate, vedere la sezione successiva. Nell'esempio seguente viene illustrata questa relazione.(For more information about custom format strings, see the next section.) The following example illustrates this relationship.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      DateTime date1 = new DateTime(2009, 6, 30);
      Console.WriteLine("D Format Specifier:     {0:D}", date1);
      string longPattern = CultureInfo.CurrentCulture.DateTimeFormat.LongDatePattern;
      Console.WriteLine("'{0}' custom format string:     {1}", 
                        longPattern, date1.ToString(longPattern));
   }
}
// The example displays the following output when run on a system whose
// current culture is en-US:
//    D Format Specifier:     Tuesday, June 30, 2009
//    'dddd, MMMM dd, yyyy' custom format string:     Tuesday, June 30, 2009
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim date1 As Date = #6/30/2009#
      Console.WriteLine("D Format Specifier:     {0:D}", date1)
      Dim longPattern As String = CultureInfo.CurrentCulture.DateTimeFormat.LongDatePattern
      Console.WriteLine("'{0}' custom format string:     {1}", _
                        longPattern, date1.ToString(longPattern))
   End Sub
End Module
' The example displays the following output when run on a system whose
' current culture is en-US:
'    D Format Specifier:     Tuesday, June 30, 2009
'    'dddd, MMMM dd, yyyy' custom format string:     Tuesday, June 30, 2009

Per altre informazioni sulle stringhe di formato di data e ora standard, vedere Standard Date and Time Format Strings.For more information about standard date and time format strings, see Standard Date and Time Format Strings.

È anche possibile usare le stringhe di formato standard per definire la rappresentazione di stringa di un oggetto definito dall'applicazione, prodotta dal metodo ToString(String) dell'oggetto.You can also use standard format strings to define the string representation of an application-defined object that is produced by the object’s ToString(String) method. È possibile definire gli identificatori di formato standard specifici supportati dall'oggetto, nonché determinare se per essi viene fatta o meno distinzione tra maiuscole e minuscole.You can define the specific standard format specifiers that your object supports, and you can determine whether they are case-sensitive or case-insensitive. L'implementazione del metodo ToString(String) deve supportare gli elementi seguenti:Your implementation of the ToString(String) method should support the following:

  • Un identificatore di formato "G" che rappresenta un formato abituale o comune dell'oggetto.A "G" format specifier that represents a customary or common format of the object. L'overload senza parametri del metodo ToString dell'oggetto deve chiamare il relativo overload di ToString(String) e passare a esso la stringa di formato standard "G".The parameterless overload of your object's ToString method should call its ToString(String) overload and pass it the "G" standard format string.

  • Supporto per un identificatore di formato equivalente a un riferimento Null (Nothing in Visual Basic).Support for a format specifier that is equal to a null reference (Nothing in Visual Basic). Un identificatore di formato equivalente a un riferimento Null deve essere considerato equivalente all'identificatore di formato "G".A format specifier that is equal to a null reference should be considered equivalent to the "G" format specifier.

Una classe Temperature può, ad esempio, archiviare internamente la temperatura in gradi Celsius e usare gli identificatori di formato per rappresentare il valore dell'oggetto Temperature in gradi Celsius, gradi Fahrenheit e gradi Kelvin.For example, a Temperature class can internally store the temperature in degrees Celsius and use format specifiers to represent the value of the Temperature object in degrees Celsius, degrees Fahrenheit, and kelvins. Nell'esempio seguente viene illustrato questo concetto.The following example provides an illustration.

using System;

public class Temperature
{
   private decimal m_Temp;
   
   public Temperature(decimal temperature)
   {
      this.m_Temp = temperature;
   }
   
   public decimal Celsius
   {
      get { return this.m_Temp; }
   }
   
   public decimal Kelvin
   {
      get { return this.m_Temp + 273.15m; }   
   }
   
   public decimal Fahrenheit
   {
      get { return Math.Round(((decimal) (this.m_Temp * 9 / 5 + 32)), 2); }
   }

   public override string ToString()
   {
      return this.ToString("C");
   }
   
   public string ToString(string format)
   {  
      // Handle null or empty string.
      if (String.IsNullOrEmpty(format)) format = "C";
      // Remove spaces and convert to uppercase.
      format = format.Trim().ToUpperInvariant();      
      
      // Convert temperature to Fahrenheit and return string.
      switch (format)
      {
         // Convert temperature to Fahrenheit and return string.
         case "F":
            return this.Fahrenheit.ToString("N2") + " °F";
         // Convert temperature to Kelvin and return string.
         case "K":
            return this.Kelvin.ToString("N2") + " K";
         // return temperature in Celsius.
         case "G":
         case "C":
            return this.Celsius.ToString("N2") + " °C";
         default:
            throw new FormatException(String.Format("The '{0}' format string is not supported.", format));
      }      
   }
}

public class Example
{
   public static void Main()
   {
      Temperature temp1 = new Temperature(0m);
      Console.WriteLine(temp1.ToString());
      Console.WriteLine(temp1.ToString("G"));
      Console.WriteLine(temp1.ToString("C"));
      Console.WriteLine(temp1.ToString("F"));
      Console.WriteLine(temp1.ToString("K"));

      Temperature temp2 = new Temperature(-40m);
      Console.WriteLine(temp2.ToString());
      Console.WriteLine(temp2.ToString("G"));
      Console.WriteLine(temp2.ToString("C"));
      Console.WriteLine(temp2.ToString("F"));
      Console.WriteLine(temp2.ToString("K"));

      Temperature temp3 = new Temperature(16m);
      Console.WriteLine(temp3.ToString());
      Console.WriteLine(temp3.ToString("G"));
      Console.WriteLine(temp3.ToString("C"));
      Console.WriteLine(temp3.ToString("F"));
      Console.WriteLine(temp3.ToString("K"));
      
      Console.WriteLine(String.Format("The temperature is now {0:F}.", temp3));
   }
}
// The example displays the following output:
//       0.00 °C
//       0.00 °C
//       0.00 °C
//       32.00 °F
//       273.15 K
//       -40.00 °C
//       -40.00 °C
//       -40.00 °C
//       -40.00 °F
//       233.15 K
//       16.00 °C
//       16.00 °C
//       16.00 °C
//       60.80 °F
//       289.15 K
//       The temperature is now 16.00 °C.
Public Class Temperature
   Private m_Temp As Decimal
   
   Public Sub New(temperature As Decimal)
      Me.m_Temp = temperature
   End Sub
   
   Public ReadOnly Property Celsius() As Decimal
      Get
         Return Me.m_Temp
      End Get   
   End Property
   
   Public ReadOnly Property Kelvin() As Decimal
      Get
         Return Me.m_Temp + 273.15d   
      End Get
   End Property
   
   Public ReadOnly Property Fahrenheit() As Decimal
      Get
         Return Math.Round(CDec(Me.m_Temp * 9 / 5 + 32), 2)
      End Get      
   End Property

   Public Overrides Function ToString() As String
      Return Me.ToString("C")
   End Function
   
   Public Overloads Function ToString(format As String) As String  
      ' Handle null or empty string.
      If String.IsNullOrEmpty(format) Then format = "C"
      ' Remove spaces and convert to uppercase.
      format = format.Trim().ToUpperInvariant()      
      
      Select Case format
         Case "F"
           ' Convert temperature to Fahrenheit and return string.
            Return Me.Fahrenheit.ToString("N2") & " °F"
         Case "K"
            ' Convert temperature to Kelvin and return string.
            Return Me.Kelvin.ToString("N2") & " K"
         Case "C", "G"
            ' Return temperature in Celsius.
            Return Me.Celsius.ToString("N2") & " °C"
         Case Else
            Throw New FormatException(String.Format("The '{0}' format string is not supported.", format))
      End Select      
   End Function
End Class

Public Module Example
   Public Sub Main()
      Dim temp1 As New Temperature(0d)
      Console.WriteLine(temp1.ToString())
      Console.WriteLine(temp1.ToString("G"))
      Console.WriteLine(temp1.ToString("C"))
      Console.WriteLine(temp1.ToString("F"))
      Console.WriteLine(temp1.ToString("K"))

      Dim temp2 As New Temperature(-40d)
      Console.WriteLine(temp2.ToString())
      Console.WriteLine(temp2.ToString("G"))
      Console.WriteLine(temp2.ToString("C"))
      Console.WriteLine(temp2.ToString("F"))
      Console.WriteLine(temp2.ToString("K"))

      Dim temp3 As New Temperature(16d)
      Console.WriteLine(temp3.ToString())
      Console.WriteLine(temp3.ToString("G"))
      Console.WriteLine(temp3.ToString("C"))
      Console.WriteLine(temp3.ToString("F"))
      Console.WriteLine(temp3.ToString("K"))
      
      Console.WriteLine(String.Format("The temperature is now {0:F}.", temp3))
   End Sub
End Module
' The example displays the following output:
'       0.00 °C
'       0.00 °C
'       0.00 °C
'       32.00 °F
'       273.15 K
'       -40.00 °C
'       -40.00 °C
'       -40.00 °C
'       -40.00 °F
'       233.15 K
'       16.00 °C
'       16.00 °C
'       16.00 °C
'       60.80 °F
'       289.15 K
'       The temperature is now 16.00 °C.

Stringhe di formato personalizzateCustom format strings

Oltre alle stringhe di formato standard, in .NET sono definite stringhe di formato personalizzate sia per valori numerici che per valori di data e ora.In addition to the standard format strings, .NET defines custom format strings for both numeric values and date and time values. Una stringa di formato personalizzata è costituita da uno o più identificatori di formato personalizzati che definiscono la rappresentazione di stringa di un valore.A custom format string consists of one or more custom format specifiers that define the string representation of a value. La stringa di formato di data e ora personalizzata "yyyy/mm/dd hh:mm:ss.ffff t zzz" consente, ad esempio, di convertire una data nella relativa rappresentazione di stringa nel formato "2008/11/15 07:45:00.0000 P -08:00" per le impostazioni cultura en-US.For example, the custom date and time format string "yyyy/mm/dd hh:mm:ss.ffff t zzz" converts a date to its string representation in the form "2008/11/15 07:45:00.0000 P -08:00" for the en-US culture. Analogamente, la stringa di formato personalizzata "0000" consente di convertire il valore intero 12 in "0012".Similarly, the custom format string "0000" converts the integer value 12 to "0012". Per un elenco completo di stringhe di formato personalizzate, vedere Custom Date and Time Format Strings e Custom Numeric Format Strings.For a complete list of custom format strings, see Custom Date and Time Format Strings and Custom Numeric Format Strings.

Se una stringa di formato è costituita da un solo identificatore di formato personalizzato, l'identificatore di formato deve essere preceduto dal simbolo di percentuale (%) per evitare confusione con un identificatore di formato standard.If a format string consists of a single custom format specifier, the format specifier should be preceded by the percent (%) symbol to avoid confusion with a standard format specifier. Nell'esempio seguente viene usato l'identificatore di formato personalizzato "M" per visualizzare un numero a una cifra o a due cifre del mese di una data specifica.The following example uses the "M" custom format specifier to display a one-digit or two-digit number of the month of a particular date.

DateTime date1 = new DateTime(2009, 9, 8);
Console.WriteLine(date1.ToString("%M"));       // Displays 9
Dim date1 As Date = #09/08/2009#
Console.WriteLine(date1.ToString("%M"))      ' Displays 9

Numerose stringhe di formato standard per i valori di data e ora sono alias per stringhe di formato personalizzate definite dalle proprietà dell'oggetto DateTimeFormatInfo .Many standard format strings for date and time values are aliases for custom format strings that are defined by properties of the DateTimeFormatInfo object. Le stringhe di formato personalizzate offrono inoltre una notevole flessibilità in quanto consentono una formattazione definita dall'applicazione per valori numerici o di data e ora.Custom format strings also offer considerable flexibility in providing application-defined formatting for numeric values or date and time values. È possibile definire stringhe di risultato personalizzate sia per valori numerici che per valori di data e ora combinando più identificatori di formato personalizzati in una singola stringa di formato personalizzata.You can define your own custom result strings for both numeric values and date and time values by combining multiple custom format specifiers into a single custom format string. Nell'esempio seguente viene definita una stringa di formato personalizzata che consente di visualizzare il giorno della settimana tra parentesi dopo il nome del mese, il giorno e l'anno.The following example defines a custom format string that displays the day of the week in parentheses after the month name, day, and year.

string customFormat = "MMMM dd, yyyy (dddd)";
DateTime date1 = new DateTime(2009, 8, 28);
Console.WriteLine(date1.ToString(customFormat));   
// The example displays the following output if run on a system
// whose language is English:
//       August 28, 2009 (Friday)      
Dim customFormat As String = "MMMM dd, yyyy (dddd)"
Dim date1 As Date = #8/28/2009#
Console.WriteLine(date1.ToString(customFormat))   
' The example displays the following output if run on a system
' whose language is English:
'       August 28, 2009 (Friday)      

L'esempio seguente definisce una stringa di formato personalizzata che visualizza un valore Int64 come numero di telefono degli Stati Uniti standard di sette cifre con il relativo prefisso.The following example defines a custom format string that displays an Int64 value as a standard, seven-digit U.S. telephone number along with its area code.

using System;

public class Example
{
   public static void Main()
   {
      long number = 8009999999;
      string fmt = "000-000-0000";
      Console.WriteLine(number.ToString(fmt));
   }
}
// The example displays the following output:
//        800-999-9999
Module Example
   Public Sub Main()
      Dim number As Long = 8009999999
      Dim fmt As String = "000-000-0000"
      Console.WriteLine(number.ToString(fmt))
   End Sub
End Module
' The example displays the following output:

' The example displays the following output:
'       800-999-9999

Sebbene le stringhe di formato standard consentano in genere di gestire la maggior parte delle necessità relative alla formattazione per i tipi definiti dall'applicazione, è anche possibile definire identificatori di formato personalizzati per formattare i tipi.Although standard format strings can generally handle most of the formatting needs for your application-defined types, you may also define custom format specifiers to format your types.

Stringhe di formato e tipi .NETFormat strings and .NET types

Tutti i tipi numerici (ovvero i tipi Byte, Decimal, Double, Int16, Int32, Int64, SByte, Single, UInt16, UInt32, UInt64 e BigInteger), nonché DateTime, DateTimeOffset, TimeSpan, Guid e tutti i tipi di enumerazione supportano la formattazione con stringhe di formato.All numeric types (that is, the Byte, Decimal, Double, Int16, Int32, Int64, SByte, Single, UInt16, UInt32, UInt64, and BigInteger types), as well as the DateTime, DateTimeOffset, TimeSpan, Guid, and all enumeration types, support formatting with format strings. Per informazioni sulle stringhe di formato specifiche supportate da ogni tipo, vedere gli argomenti seguenti:For information on the specific format strings supported by each type, see the following topics:

TitoloTitle DefinizioneDefinition
Stringhe di formato numerico standardStandard Numeric Format Strings Vengono descritte le stringhe di formato standard che consentono di creare rappresentazioni di stringa usate comunemente di valori numerici.Describes standard format strings that create commonly used string representations of numeric values.
Stringhe di formato numerico personalizzatoCustom Numeric Format Strings Vengono descritte le stringhe di formato personalizzate che consentono di creare formati specifici dell'applicazione per valori numerici.Describes custom format strings that create application-specific formats for numeric values.
Stringhe di formato di data e ora standardStandard Date and Time Format Strings Vengono descritte le stringhe di formato standard che consentono di creare rappresentazioni di stringa usate comunemente di valori DateTime e DateTimeOffset.Describes standard format strings that create commonly used string representations of DateTime and DateTimeOffset values.
Stringhe di formato di data e ora personalizzatoCustom Date and Time Format Strings Vengono descritte le stringhe di formato personalizzate che consentono di creare formati specifici dell'applicazione per valori DateTime e DateTimeOffset.Describes custom format strings that create application-specific formats for DateTime and DateTimeOffset values.
Stringhe di formato TimeSpan standardStandard TimeSpan Format Strings Vengono descritte le stringhe di formato standard che consentono di creare rappresentazioni di stringa usate comunemente di intervalli di tempo.Describes standard format strings that create commonly used string representations of time intervals.
Stringhe di formato TimeSpan personalizzateCustom TimeSpan Format Strings Vengono descritte le stringhe di formato personalizzate che consentono di creare formati specifici dell'applicazione per intervalli di tempo.Describes custom format strings that create application-specific formats for time intervals.
Enumeration Format StringsEnumeration Format Strings Vengono descritte le stringhe di formato standard che consentono di creare rappresentazioni di stringa di valori di enumerazione.Describes standard format strings that are used to create string representations of enumeration values.
Guid.ToString(String) Descrive le stringhe di formato standard per i valori Guid .Describes standard format strings for Guid values.

Formattazione dipendente dalle impostazioni cultura con provider di formatoCulture-sensitive formatting with format providers

Sebbene gli identificatori di formato consentano di personalizzare la formattazione degli oggetti, la creazione di una rappresentazione di stringa significativa degli oggetti richiede spesso informazioni aggiuntive sulla formattazione.Although format specifiers let you customize the formatting of objects, producing a meaningful string representation of objects often requires additional formatting information. La formattazione, ad esempio, di un numero come valore di valuta tramite la stringa di formato standard "C" o una stringa di formato personalizzata, come ad esempio "$ #,#.00", richiede almeno la possibilità di includere nella stringa formattata le informazioni relative al simbolo di valuta, al separatore di gruppi e al separatore decimale corretti.For example, formatting a number as a currency value by using either the "C" standard format string or a custom format string such as "$ #,#.00" requires, at a minimum, information about the correct currency symbol, group separator, and decimal separator to be available to include in the formatted string. In .NET queste informazioni aggiuntive sulla formattazione vengono rese disponibili tramite l'interfaccia IFormatProvider, fornita come parametro di uno o più overload del metodo ToString di tipi numerici e di data e ora.In .NET, this additional formatting information is made available through the IFormatProvider interface, which is provided as a parameter to one or more overloads of the ToString method of numeric types and date and time types. Le implementazioni di IFormatProvider vengono usate in .NET per supportare la formattazione specifica delle impostazioni cultura.IFormatProvider implementations are used in .NET to support culture-specific formatting. Nell'esempio seguente viene illustrato come cambia la rappresentazione di stringa di un oggetto quando viene formattata con tre oggetti IFormatProvider che rappresentano impostazioni cultura diverse.The following example illustrates how the string representation of an object changes when it is formatted with three IFormatProvider objects that represent different cultures.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      decimal value = 1603.42m;
      Console.WriteLine(value.ToString("C3", new CultureInfo("en-US")));
      Console.WriteLine(value.ToString("C3", new CultureInfo("fr-FR")));
      Console.WriteLine(value.ToString("C3", new CultureInfo("de-DE")));
   }
}
// The example displays the following output:
//       $1,603.420
//       1 603,420 €
//       1.603,420 €
Imports System.Globalization

Public Module Example
   Public Sub Main()
      Dim value As Decimal = 1603.42d
      Console.WriteLine(value.ToString("C3", New CultureInfo("en-US")))
      Console.WriteLine(value.ToString("C3", New CultureInfo("fr-FR")))
      Console.WriteLine(value.ToString("C3", New CultureInfo("de-DE")))
   End Sub
End Module
' The example displays the following output:
'       $1,603.420
'       1 603,420 €
'       1.603,420 €

L'interfaccia IFormatProvider include un metodo, GetFormat(Type), che dispone di un singolo parametro che specifica il tipo di oggetto che fornisce informazioni sulla formattazione.The IFormatProvider interface includes one method, GetFormat(Type), which has a single parameter that specifies the type of object that provides formatting information. Se il metodo può fornire un oggetto di tale tipo, lo restituisce.If the method can provide an object of that type, it returns it. In caso contrario, restituisce un riferimento Null (Nothing in Visual Basic).Otherwise, it returns a null reference (Nothing in Visual Basic).

IFormatProvider.GetFormat è un metodo di callback.IFormatProvider.GetFormat is a callback method. Quando si chiama un overload del metodo ToString che include un parametro IFormatProvider , viene chiamato il metodo GetFormat di tale oggetto IFormatProvider .When you call a ToString method overload that includes an IFormatProvider parameter, it calls the GetFormat method of that IFormatProvider object. Il metodo GetFormat è responsabile della restituzione di un oggetto che fornisce le informazioni sulla formattazione necessarie, specificate dal relativo parametro formatType , al metodo ToString .The GetFormat method is responsible for returning an object that provides the necessary formatting information, as specified by its formatType parameter, to the ToString method.

Diversi metodi di conversione di stringhe o di formattazione includono un parametro di tipo IFormatProvider, ma in molti casi il valore del parametro viene ignorato quando il metodo viene chiamato.A number of formatting or string conversion methods include a parameter of type IFormatProvider, but in many cases the value of the parameter is ignored when the method is called. Nella tabella seguente sono elencati alcuni dei metodi di formattazione che usano il parametro e il tipo dell'oggetto Type che passano al metodo IFormatProvider.GetFormat .The following table lists some of the formatting methods that use the parameter and the type of the Type object that they pass to the IFormatProvider.GetFormat method.

MetodoMethod Tipo di parametro formatTypeType of formatType parameter
Metodo ToString di tipi numericiToString method of numeric types System.Globalization.NumberFormatInfo
Metodo ToString di tipi di data e oraToString method of date and time types System.Globalization.DateTimeFormatInfo
String.Format System.ICustomFormatter
StringBuilder.AppendFormat System.ICustomFormatter

Nota

I metodi ToString dei tipi numerici e di data e ora sono sottoposti a overload e solo alcuni degli overload includono un parametro IFormatProvider .The ToString methods of the numeric types and date and time types are overloaded, and only some of the overloads include an IFormatProvider parameter. Se un metodo non dispone di un parametro di tipo IFormatProvider, al suo posto viene passato l'oggetto restituito dalla proprietà CultureInfo.CurrentCulture .If a method does not have a parameter of type IFormatProvider, the object that is returned by the CultureInfo.CurrentCulture property is passed instead. Una chiamata al metodo Int32.ToString() predefinito comporta, ad esempio, in definitiva, una chiamata al metodo come la seguente: Int32.ToString("G", System.Globalization.CultureInfo.CurrentCulture).For example, a call to the default Int32.ToString() method ultimately results in a method call such as the following: Int32.ToString("G", System.Globalization.CultureInfo.CurrentCulture).

In .NET sono disponibili tre classi che implementano IFormatProvider:.NET provides three classes that implement IFormatProvider:

È anche possibile implementare un provider di formato personalizzato per sostituire una di queste classi.You can also implement your own format provider to replace any one of these classes. Il metodo GetFormat dell'implementazione, tuttavia, deve restituire un oggetto del tipo elencato nella tabella precedente, se deve fornire informazioni sulla formattazione al metodo ToString.However, your implementation’s GetFormat method must return an object of the type listed in the previous table if it has to provide formatting information to the ToString method.

Formattazione dipendente dalle impostazioni cultura di valori numericiCulture-sensitive formatting of numeric values

Per impostazione predefinita, la formattazione di valori numerici è dipendente dalle impostazioni cultura.By default, the formatting of numeric values is culture-sensitive. Se non si specificano impostazioni cultura quando si chiama un metodo di formattazione, vengono usate le convenzioni di formattazione delle impostazioni cultura del thread corrente.If you do not specify a culture when you call a formatting method, the formatting conventions of the current thread culture are used. Questa situazione viene illustrata nell'esempio seguente in cui le impostazioni cultura del thread corrente vengono modificate quattro volte e viene chiamato il metodo Decimal.ToString(String) .This is illustrated in the following example, which changes the current thread culture four times and then calls the Decimal.ToString(String) method. In ogni caso, la stringa risultante riflette le convenzioni di formattazione delle impostazioni cultura correnti.In each case, the result string reflects the formatting conventions of the current culture. Questo accade perché i metodi ToString e ToString(String) eseguono il wrapping di chiamate al metodo ToString(String, IFormatProvider) di ogni tipo numerico.This is because the ToString and ToString(String) methods wrap calls to each numeric type's ToString(String, IFormatProvider) method.

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

public class Example
{
   public static void Main()
   {
      string[] cultureNames = { "en-US", "fr-FR", "es-MX", "de-DE" };
      Decimal value = 1043.17m;
      
      foreach (var cultureName in cultureNames) {
         // Change the current thread culture.
         Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture(cultureName);
         Console.WriteLine("The current culture is {0}", 
                           Thread.CurrentThread.CurrentCulture.Name);
         Console.WriteLine(value.ToString("C2"));
         Console.WriteLine();
      }   
   }
}
// The example displays the following output:
//       The current culture is en-US
//       $1,043.17
//       
//       The current culture is fr-FR
//       1 043,17 €
//       
//       The current culture is es-MX
//       $1,043.17
//       
//       The current culture is de-DE
//       1.043,17 €
Imports System.Globalization
Imports System.Threading 

Module Example
   Public Sub Main()
      Dim cultureNames() As String = { "en-US", "fr-FR", "es-MX", "de-DE" }
      Dim value As Decimal = 1043.17d 
      
      For Each cultureName In cultureNames
         ' Change the current thread culture.
         Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture(cultureName)
         Console.WriteLine("The current culture is {0}", 
                           Thread.CurrentThread.CurrentCulture.Name)
         Console.WriteLine(value.ToString("C2"))
         Console.WriteLine()
      Next                  
   End Sub
End Module
' The example displays the following output:
'       The current culture is en-US
'       $1,043.17
'       
'       The current culture is fr-FR
'       1 043,17 €
'       
'       The current culture is es-MX
'       $1,043.17
'       
'       The current culture is de-DE
'       1.043,17 €

È anche possibile formattare un valore numerico per impostazioni cultura specifiche chiamando un overload di ToString con un parametro provider e passando uno degli elementi seguenti:You can also format a numeric value for a specific culture by calling a ToString overload that has a provider parameter and passing it either of the following:

  • Oggetto CultureInfo che rappresenta le impostazioni cultura, di cui verranno usate le convenzioni di formattazione.A CultureInfo object that represents the culture whose formatting conventions are to be used. Il metodo CultureInfo.GetFormat relativo restituisce il valore della proprietà CultureInfo.NumberFormat , che rappresenta l'oggetto NumberFormatInfo che fornisce informazioni di formattazione specifiche delle impostazioni cultura per i valori numerici.Its CultureInfo.GetFormat method returns the value of the CultureInfo.NumberFormat property, which is the NumberFormatInfo object that provides culture-specific formatting information for numeric values.

  • Oggetto NumberFormatInfo che definisce le convenzioni di formattazione specifiche delle impostazioni cultura da usare.A NumberFormatInfo object that defines the culture-specific formatting conventions to be used. Il metodo GetFormat relativo restituisce un'istanza di se stesso.Its GetFormat method returns an instance of itself.

Nell'esempio seguente vengono usati gli oggetti NumberFormatInfo che rappresentano le impostazioni cultura della lingua inglese di Stati Uniti e di Gran Bretagna, nonché le impostazioni cultura non associate alle lingue francese e russa per formattare un numero a virgola mobile.The following example uses NumberFormatInfo objects that represent the English (United States) and English (Great Britain) cultures and the French and Russian neutral cultures to format a floating-point number.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {                                                                                                    
      Double value = 1043.62957;
      string[] cultureNames = { "en-US", "en-GB", "ru", "fr" };
      
      foreach (var name in cultureNames) {
         NumberFormatInfo nfi = CultureInfo.CreateSpecificCulture(name).NumberFormat;
         Console.WriteLine("{0,-6} {1}", name + ":", value.ToString("N3", nfi));
      }   
   }
}
// The example displays the following output:
//       en-US: 1,043.630
//       en-GB: 1,043.630
//       ru:    1 043,630
//       fr:    1 043,630
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim value As Double = 1043.62957
      Dim cultureNames() As String = { "en-US", "en-GB", "ru", "fr" }
      
      For Each name In cultureNames
         Dim nfi As NumberFormatInfo = CultureInfo.CreateSpecificCulture(name).NumberFormat
         Console.WriteLine("{0,-6} {1}", name + ":", value.ToString("N3", nfi))
      Next   
   End Sub
End Module
' The example displays the following output:
'       en-US: 1,043.630
'       en-GB: 1,043.630
'       ru:    1 043,630
'       fr:    1 043,630

Formattazione dipendente dalle impostazioni cultura di valori data e oraCulture-sensitive formatting of date and time values

Per impostazione predefinita, la formattazione dei valori data e ora è dipendente dalle impostazioni cultura.By default, the formatting of date and time values is culture-sensitive. Se non si specificano impostazioni cultura quando si chiama un metodo di formattazione, vengono usate le convenzioni di formattazione delle impostazioni cultura del thread corrente.If you do not specify a culture when you call a formatting method, the formatting conventions of the current thread culture are used. Questa situazione viene illustrata nell'esempio seguente in cui le impostazioni cultura del thread corrente vengono modificate quattro volte e viene chiamato il metodo DateTime.ToString(String) .This is illustrated in the following example, which changes the current thread culture four times and then calls the DateTime.ToString(String) method. In ogni caso, la stringa risultante riflette le convenzioni di formattazione delle impostazioni cultura correnti.In each case, the result string reflects the formatting conventions of the current culture. Questo si verifica perché i metodi DateTime.ToString(), DateTime.ToString(String), DateTimeOffset.ToString()e DateTimeOffset.ToString(String) eseguono il wrapping di chiamate ai metodi DateTime.ToString(String, IFormatProvider) e DateTimeOffset.ToString(String, IFormatProvider) .This is because the DateTime.ToString(), DateTime.ToString(String), DateTimeOffset.ToString(), and DateTimeOffset.ToString(String) methods wrap calls to the DateTime.ToString(String, IFormatProvider) and DateTimeOffset.ToString(String, IFormatProvider) methods.

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

public class Example
{
   public static void Main()
   {
      string[] cultureNames = { "en-US", "fr-FR", "es-MX", "de-DE" };
      DateTime dateToFormat = new DateTime(2012, 5, 28, 11, 30, 0);
      
      foreach (var cultureName in cultureNames) {
         // Change the current thread culture.
         Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture(cultureName);
         Console.WriteLine("The current culture is {0}", 
                           Thread.CurrentThread.CurrentCulture.Name);
         Console.WriteLine(dateToFormat.ToString("F"));
         Console.WriteLine();
      }   
   }
}
// The example displays the following output:
//       The current culture is en-US
//       Monday, May 28, 2012 11:30:00 AM
//       
//       The current culture is fr-FR
//       lundi 28 mai 2012 11:30:00
//       
//       The current culture is es-MX
//       lunes, 28 de mayo de 2012 11:30:00 a.m.
//       
//       The current culture is de-DE
//       Montag, 28. Mai 2012 11:30:00
Imports System.Globalization
Imports System.Threading 

Module Example
   Public Sub Main()
      Dim cultureNames() As String = { "en-US", "fr-FR", "es-MX", "de-DE" }
      Dim dateToFormat As Date = #5/28/2012 11:30AM#
      
      For Each cultureName In cultureNames
         ' Change the current thread culture.
         Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture(cultureName)
         Console.WriteLine("The current culture is {0}", 
                           Thread.CurrentThread.CurrentCulture.Name)
         Console.WriteLine(dateToFormat.ToString("F"))
         Console.WriteLine()
      Next                  
   End Sub
End Module
' The example displays the following output:
'       The current culture is en-US
'       Monday, May 28, 2012 11:30:00 AM
'       
'       The current culture is fr-FR
'       lundi 28 mai 2012 11:30:00
'       
'       The current culture is es-MX
'       lunes, 28 de mayo de 2012 11:30:00 a.m.
'       
'       The current culture is de-DE
'       Montag, 28. Mai 2012 11:30:00 

È anche possibile formattare un valore data e ora per impostazioni cultura specifiche chiamando un overload DateTime.ToString o DateTimeOffset.ToString contenente un parametro provider e passandolo agli elementi seguenti:You can also format a date and time value for a specific culture by calling a DateTime.ToString or DateTimeOffset.ToString overload that has a provider parameter and passing it either of the following:

Nell'esempio seguente vengono usati gli oggetti DateTimeFormatInfo che rappresentano le impostazioni cultura della lingua inglese di Stati Uniti e Gran Bretagna e le impostazioni cultura non associate alle lingue francese e russa per formattare una data.The following example uses DateTimeFormatInfo objects that represent the English (United States) and English (Great Britain) cultures and the French and Russian neutral cultures to format a date.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {                                                                                                    
      DateTime dat1 = new DateTime(2012, 5, 28, 11, 30, 0);
      string[] cultureNames = { "en-US", "en-GB", "ru", "fr" };
      
      foreach (var name in cultureNames) {
         DateTimeFormatInfo dtfi = CultureInfo.CreateSpecificCulture(name).DateTimeFormat;
         Console.WriteLine("{0}: {1}", name, dat1.ToString(dtfi));
      }   
   }
}
// The example displays the following output:
//       en-US: 5/28/2012 11:30:00 AM
//       en-GB: 28/05/2012 11:30:00
//       ru: 28.05.2012 11:30:00
//       fr: 28/05/2012 11:30:00
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim dat1 As Date = #5/28/2012 11:30AM#
      Dim cultureNames() As String = { "en-US", "en-GB", "ru", "fr" }
      
      For Each name In cultureNames
         Dim dtfi As DateTimeFormatInfo = CultureInfo.CreateSpecificCulture(name).DateTimeFormat
         Console.WriteLine("{0}: {1}", name, dat1.ToString(dtfi))
      Next   
   End Sub
End Module
' The example displays the following output:
'       en-US: 5/28/2012 11:30:00 AM
'       en-GB: 28/05/2012 11:30:00
'       ru: 28.05.2012 11:30:00
'       fr: 28/05/2012 11:30:00

Interfaccia IFormattableThe IFormattable interface

In genere, i tipi che eseguono l'overload del metodo ToString con una stringa di formato e un parametro IFormatProvider implementano anche l'interfaccia IFormattable .Typically, types that overload the ToString method with a format string and an IFormatProvider parameter also implement the IFormattable interface. Questa interfaccia dispone di un singolo membro, IFormattable.ToString(String, IFormatProvider), che include sia una stringa di formato che un provider di formato come parametri.This interface has a single member, IFormattable.ToString(String, IFormatProvider), that includes both a format string and a format provider as parameters.

L'implementazione dell'interfaccia IFormattable per la classe definita dall'applicazione offre due vantaggi:Implementing the IFormattable interface for your application-defined class offers two advantages:

Nell'esempio seguente viene definita una classe Temperature che implementa l'interfaccia IFormattable .The following example defines a Temperature class that implements the IFormattable interface. Sono supportati gli identificatori di formato "C" e "G" per visualizzare la temperatura in Celsius, l'identificatore di formato "F" per visualizzare la temperatura in Fahrenheit e l'identificatore di formato "K" per visualizzare la temperatura in Kelvin.It supports the "C" or "G" format specifiers to display the temperature in Celsius, the "F" format specifier to display the temperature in Fahrenheit, and the "K" format specifier to display the temperature in Kelvin.

using System;
using System.Globalization;

public class Temperature : IFormattable
{
   private decimal m_Temp;

   public Temperature(decimal temperature)
   {
      this.m_Temp = temperature;
   }
   
   public decimal Celsius
   {
      get { return this.m_Temp; }
   }
   
   public decimal Kelvin
   {
      get { return this.m_Temp + 273.15m; }   
   }
   
   public decimal Fahrenheit
   {
      get { return Math.Round((decimal) this.m_Temp * 9 / 5 + 32, 2); }
   }

   public override string ToString()
   {
      return this.ToString("G", null);
   }
   
   public string ToString(string format)
   {
      return this.ToString(format, null);
   }
   
   public string ToString(string format, IFormatProvider provider)  
   {
      // Handle null or empty arguments.
      if (String.IsNullOrEmpty(format))
         format = "G";
      // Remove any white space and covert to uppercase.
      format = format.Trim().ToUpperInvariant();

      if (provider == null)
         provider = NumberFormatInfo.CurrentInfo;
            
      switch (format)
      {
         // Convert temperature to Fahrenheit and return string.
         case "F":
            return this.Fahrenheit.ToString("N2", provider) + "°F";
         // Convert temperature to Kelvin and return string.
         case "K":
            return this.Kelvin.ToString("N2", provider) + "K";
         // Return temperature in Celsius.
         case "C":
         case "G":
            return this.Celsius.ToString("N2", provider) + "°C";
         default:
            throw new FormatException(String.Format("The '{0}' format string is not supported.", format));
      }      
   }
}
Imports System.Globalization

Public Class Temperature : Implements IFormattable
   Private m_Temp As Decimal

   Public Sub New(temperature As Decimal)
      Me.m_Temp = temperature
   End Sub
   
   Public ReadOnly Property Celsius() As Decimal
      Get
         Return Me.m_Temp
      End Get   
   End Property
   
   Public ReadOnly Property Kelvin() As Decimal
      Get
         Return Me.m_Temp + 273.15d   
      End Get
   End Property
   
   Public ReadOnly Property Fahrenheit() As Decimal
      Get
         Return Math.Round(CDec(Me.m_Temp * 9 / 5 + 32), 2)
      End Get      
   End Property

   Public Overrides Function ToString() As String
      Return Me.ToString("G", Nothing)
   End Function
   
   Public Overloads Function ToString(format As String) As String
      Return Me.ToString(format, Nothing)
   End Function
   
   Public Overloads Function ToString(format As String, provider As IFormatProvider) As String _  
      Implements IFormattable.ToString

      ' Handle null or empty arguments.
      If String.IsNullOrEmpty(format) Then format = "G"
      ' Remove any white space and convert to uppercase.
      format = format.Trim().ToUpperInvariant()

      If provider Is Nothing Then provider = NumberFormatInfo.CurrentInfo
            
      Select Case format
         ' Convert temperature to Fahrenheit and return string.
         Case "F"
            Return Me.Fahrenheit.ToString("N2", provider) & "°F"
         ' Convert temperature to Kelvin and return string.
         Case "K"
            Return Me.Kelvin.ToString("N2", provider) & "K"
         ' Return temperature in Celsius.
         Case "C", "G"
            Return Me.Celsius.ToString("N2", provider) & "°C"
         Case Else
            Throw New FormatException(String.Format("The '{0}' format string is not supported.", format))
      End Select      
   End Function
End Class

Nell'esempio seguente viene creata un'istanza di un oggetto Temperature.The following example instantiates a Temperature object. Viene quindi chiamato il metodo ToString e vengono usate diverse stringhe di formato composite per ottenere diverse rappresentazioni di stringa di un oggetto Temperature .It then calls the ToString method and uses several composite format strings to obtain different string representations of a Temperature object. Ognuna di queste chiamate al metodo chiama, a sua volta, l'implementazione di IFormattable della classe Temperature .Each of these method calls, in turn, calls the IFormattable implementation of the Temperature class.

public class Example
{
   public static void Main()
   {
      CultureInfo.CurrentCulture = CultureInfo.GetCultureInfo("en-US");
      Temperature temp = new Temperature(22m);
      Console.WriteLine(Convert.ToString(temp, new CultureInfo("ja-JP")));
      Console.WriteLine("Temperature: {0:K}", temp);
      Console.WriteLine("Temperature: {0:F}", temp);
      Console.WriteLine(String.Format(new CultureInfo("fr-FR"), "Temperature: {0:F}", temp));
   }
}
// The example displays the following output:
//       22.00°C
//       Temperature: 295.15K
//       Temperature: 71.60°F
//       Temperature: 71,60°F
Public Module Example
   Public Sub Main()
      Dim temp As New Temperature(22d)
      CultureInfo.CurrentCulture = CultureInfo.GetCultureInfo("en-US")
      Console.WriteLine(Convert.ToString(temp1, New CultureInfo("ja-JP")))
      Console.WriteLine("Temperature: {0:K}", temp)
      Console.WriteLine("Temperature: {0:F}", temp)
      Console.WriteLine(String.Format(New CultureInfo("fr-FR"), "Temperature: {0:F}", temp)) 
   End Sub
End Module
' The example displays the following output:
'       22.00°C
'       Temperature: 295.15K
'       Temperature: 71.60°F
'       Temperature: 71,60°F

Formattazione compositaComposite formatting

Alcuni metodi, ad esempio String.Format e StringBuilder.AppendFormat, supportano la formattazione composita.Some methods, such as String.Format and StringBuilder.AppendFormat, support composite formatting. Una stringa di formato composita è un tipo di modello che restituisce una singola stringa che incorpora la rappresentazione di stringa di zero, uno o più oggetti.A composite format string is a kind of template that returns a single string that incorporates the string representation of zero, one, or more objects. Ogni oggetto è rappresentato nella stringa di formato composita da un elemento di formato indicizzato.Each object is represented in the composite format string by an indexed format item. L'indice dell'elemento di formato corrisponde alla posizione dell'oggetto che esso rappresenta nell'elenco di parametri del metodo.The index of the format item corresponds to the position of the object that it represents in the method's parameter list. Gli indici sono a base zero.Indexes are zero-based. Nella chiamata seguente al metodo String.Format, ad esempio, il primo elemento di formato, {0:D}, viene sostituito dalla rappresentazione di stringa thatDate, il secondo elemento di formato, {1}, viene sostituito dalla rappresentazione di stringa item1 e il terzo elemento di formato, {2:C2}, viene sostituito dalla rappresentazione di stringa item1.Value.For example, in the following call to the String.Format method, the first format item, {0:D}, is replaced by the string representation of thatDate; the second format item, {1}, is replaced by the string representation of item1; and the third format item, {2:C2}, is replaced by the string representation of item1.Value.

result = String.Format("On {0:d}, the inventory of {1} was worth {2:C2}.", 
                       thatDate, item1, item1.Value);
Console.WriteLine(result);                            
// The example displays output like the following if run on a system
// whose current culture is en-US:
//       On 5/1/2009, the inventory of WidgetA was worth $107.44.
result = String.Format("On {0:d}, the inventory of {1} was worth {2:C2}.", _
                       thatDate, item1, item1.Value)
Console.WriteLine(result)                            
' The example displays output like the following if run on a system
' whose current culture is en-US:
'       On 5/1/2009, the inventory of WidgetA was worth $107.44.

Oltre a sostituire un elemento di formato con la rappresentazione di stringa dell'oggetto corrispondente, gli elementi di formato consentono anche di controllare gli aspetti seguenti:In addition to replacing a format item with the string representation of its corresponding object, format items also let you control the following:

  • Il modo specifico in cui un oggetto è rappresentato come stringa, se l'oggetto implementa l'interfaccia IFormattable e supporta le stringhe di formato.The specific way in which an object is represented as a string, if the object implements the IFormattable interface and supports format strings. A tale scopo, dopo l'indice dell'elemento di formato è necessario aggiungere un simbolo : (due punti) seguito da una stringa di formato valida.You do this by following the format item's index with a : (colon) followed by a valid format string. Nell'esempio precedente viene eseguita questa operazione formattando un valore di data con la stringa di formato "d" (modello di data breve) (ad esempio, {0:d}) e formattando un valore numerico con la stringa di formato "C2" (ad esempio, {2:C2} ) per rappresentare il numero come valore di valuta con due cifre decimali frazionarie.The previous example did this by formatting a date value with the "d" (short date pattern) format string (e.g., {0:d}) and by formatting a numeric value with the "C2" format string (e.g., {2:C2} to represent the number as a currency value with two fractional decimal digits.

  • La larghezza del campo che contiene la rappresentazione di stringa dell'oggetto e l'allineamento della rappresentazione di stringa in tale campo.The width of the field that contains the object's string representation, and the alignment of the string representation in that field. A tale scopo, dopo l'indice dell'elemento di formato è necessario aggiungere un simbolo , (virgola) seguito dalla larghezza del campo.You do this by following the format item's index with a , (comma) followed the field width. La stringa viene allineata a destra nel campo se la larghezza del campo è un valore positivo e viene allineata a sinistra se la larghezza del campo è un valore negativo.The string is right-aligned in the field if the field width is a positive value, and it is left-aligned if the field width is a negative value. L'esempio seguente consente di allineare a sinistra i valori di data in un campo di 20 caratteri e di allineare a destra i valori decimali con una cifra frazionaria in un campo di 11 caratteri.The following example left-aligns date values in a 20-character field, and it right-aligns decimal values with one fractional digit in an 11-character field.

    DateTime startDate = new DateTime(2015, 8, 28, 6, 0, 0);
    decimal[] temps = { 73.452m, 68.98m, 72.6m, 69.24563m,
                       74.1m, 72.156m, 72.228m };
    Console.WriteLine("{0,-20} {1,11}\n", "Date", "Temperature");
    for (int ctr = 0; ctr < temps.Length; ctr++)
       Console.WriteLine("{0,-20:g} {1,11:N1}", startDate.AddDays(ctr), temps[ctr]);
    
    // The example displays the following output:
    //       Date                 Temperature
    //
    //       8/28/2015 6:00 AM           73.5
    //       8/29/2015 6:00 AM           69.0
    //       8/30/2015 6:00 AM           72.6
    //       8/31/2015 6:00 AM           69.2
    //       9/1/2015 6:00 AM            74.1
    //       9/2/2015 6:00 AM            72.2
    //       9/3/2015 6:00 AM            72.2
    
    Dim startDate As New Date(2015, 8, 28, 6, 0, 0)
    Dim temps() As Decimal = { 73.452, 68.98, 72.6, 69.24563,
                               74.1, 72.156, 72.228 }
    Console.WriteLine("{0,-20} {1,11}", "Date", "Temperature")
    Console.WriteLine()
    For ctr As Integer = 0 To temps.Length - 1
       Console.WriteLine("{0,-20:g} {1,11:N1}", startDate.AddDays(ctr), temps(ctr))
    Next
    ' The example displays the following output:
    '       Date                 Temperature
    '
    '       8/28/2015 6:00 AM           73.5
    '       8/29/2015 6:00 AM           69.0
    '       8/30/2015 6:00 AM           72.6
    '       8/31/2015 6:00 AM           69.2
    '       9/1/2015 6:00 AM            74.1
    '       9/2/2015 6:00 AM            72.2
    '       9/3/2015 6:00 AM            72.2
    

    Si noti che, se il componente stringa di allineamento e il componente stringa di formato sono entrambi presenti, il primo precede il secondo, ad esempio {0,-20:g}.Note that, if both the alignment string component and the format string component are present, the former precedes the latter (for example, {0,-20:g}.

Per altre informazioni sulla formattazione composita, vedere Composite Formatting.For more information about composite formatting, see Composite Formatting.

Formattazione personalizzata con ICustomFormatterCustom formatting with ICustomFormatter

Due metodi di formattazione compositi, String.Format(IFormatProvider, String, Object[]) e StringBuilder.AppendFormat(IFormatProvider, String, Object[]), includono un parametro del provider di formato che supporta la formattazione personalizzata.Two composite formatting methods, String.Format(IFormatProvider, String, Object[]) and StringBuilder.AppendFormat(IFormatProvider, String, Object[]), include a format provider parameter that supports custom formatting. Quando viene chiamato uno di questi metodi di formattazione, viene passato un oggetto Type che rappresenta un'interfaccia ICustomFormatter al metodo GetFormat del provider di formato.When either of these formatting methods is called, it passes a Type object that represents an ICustomFormatter interface to the format provider’s GetFormat method. Il metodo GetFormat è quindi responsabile della restituzione dell'implementazione di ICustomFormatter che fornisce formattazione personalizzata.The GetFormat method is then responsible for returning the ICustomFormatter implementation that provides custom formatting.

L'interfaccia ICustomFormatter dispone di un singolo metodo, Format(String, Object, IFormatProvider), chiamato automaticamente da un metodo di formattazione composita una volta per ogni elemento di formato in una stringa di formato composita.The ICustomFormatter interface has a single method, Format(String, Object, IFormatProvider), that is called automatically by a composite formatting method, once for each format item in a composite format string. Il metodo Format(String, Object, IFormatProvider) dispone di tre parametri: una stringa di formato, che rappresenta l'argomento formatString in un elemento di formato, un oggetto da formattare e un oggetto IFormatProvider che fornisce i servizi di formattazione.The Format(String, Object, IFormatProvider) method has three parameters: a format string, which represents the formatString argument in a format item, an object to format, and an IFormatProvider object that provides formatting services. In genere, la classe che implementa ICustomFormatter implementa anche IFormatProvider, pertanto quest'ultimo parametro è un riferimento alla classe di formattazione personalizzata stessa.Typically, the class that implements ICustomFormatter also implements IFormatProvider, so this last parameter is a reference to the custom formatting class itself. Questo metodo restituisce una rappresentazione di stringa formattata personalizzata dell'oggetto da formattare.The method returns a custom formatted string representation of the object to be formatted. Se il metodo non è in grado di formattare l'oggetto, deve restituire un riferimento Null (Nothing in Visual Basic).If the method cannot format the object, it should return a null reference (Nothing in Visual Basic).

Nell'esempio seguente viene fornita un'implementazione di ICustomFormatter denominata ByteByByteFormatter che consente di visualizzare i valori interi come sequenza di valori esadecimali a due cifre seguiti da uno spazio.The following example provides an ICustomFormatter implementation named ByteByByteFormatter that displays integer values as a sequence of two-digit hexadecimal values followed by a space.

public class ByteByByteFormatter : IFormatProvider, ICustomFormatter
{
   public object GetFormat(Type formatType)
   { 
      if (formatType == typeof(ICustomFormatter))
         return this;
      else
         return null;
   }
   
   public string Format(string format, object arg, 
                          IFormatProvider formatProvider)
   {   
      if (! formatProvider.Equals(this)) return null;
      
      // Handle only hexadecimal format string.
      if (! format.StartsWith("X")) return null;
      
      byte[] bytes;
      string output = null;
      
      // Handle only integral types.
      if (arg is Byte) 
         bytes = BitConverter.GetBytes((Byte) arg);
      else if (arg is Int16)
         bytes = BitConverter.GetBytes((Int16) arg);
      else if (arg is Int32)
         bytes = BitConverter.GetBytes((Int32) arg);
      else if (arg is Int64)   
         bytes = BitConverter.GetBytes((Int64) arg);
      else if (arg is SByte)
         bytes = BitConverter.GetBytes((SByte) arg);
      else if (arg is UInt16)
         bytes = BitConverter.GetBytes((UInt16) arg);
      else if (arg is UInt32)
         bytes = BitConverter.GetBytes((UInt32) arg);
      else if (arg is UInt64)
         bytes = BitConverter.GetBytes((UInt64) arg);
      else
         return null;

      for (int ctr = bytes.Length - 1; ctr >= 0; ctr--)
         output += String.Format("{0:X2} ", bytes[ctr]);   
      
      return output.Trim();
   }
}
Public Class ByteByByteFormatter : Implements IFormatProvider, ICustomFormatter
   Public Function GetFormat(formatType As Type) As Object _
                   Implements IFormatProvider.GetFormat
      If formatType Is GetType(ICustomFormatter) Then
         Return Me
      Else
         Return Nothing
      End If
   End Function
   
   Public Function Format(fmt As String, arg As Object, 
                          formatProvider As IFormatProvider) As String _
                          Implements ICustomFormatter.Format

      If Not formatProvider.Equals(Me) Then Return Nothing

      ' Handle only hexadecimal format string.
      If Not fmt.StartsWith("X") Then 
            Return Nothing
      End If

      ' Handle only integral types.
      If Not typeof arg Is Byte AndAlso
         Not typeof arg Is Int16 AndAlso
         Not typeof arg Is Int32 AndAlso
         Not typeof arg Is Int64 AndAlso
         Not typeof arg Is SByte AndAlso
         Not typeof arg Is UInt16 AndAlso
         Not typeof arg Is UInt32 AndAlso
         Not typeof arg Is UInt64 Then _
            Return Nothing

      Dim bytes() As Byte = BitConverter.GetBytes(arg)
      Dim output As String = Nothing
         
      For ctr As Integer = bytes.Length - 1 To 0 Step -1
         output += String.Format("{0:X2} ", bytes(ctr))   
      Next
      
      Return output.Trim()
   End Function
End Class

Nell'esempio seguente viene usata la classe ByteByByteFormatter per formattare valori interi.The following example uses the ByteByByteFormatter class to format integer values. Si noti che il metodo ICustomFormatter.Format viene chiamato più di una volta nella seconda chiamata al metodo String.Format(IFormatProvider, String, Object[]) e che il provider NumberFormatInfo predefinito viene usato nella terza chiamata al metodo, perché il metodo ByteByByteFormatter.FormatNote that the ICustomFormatter.Format method is called more than once in the second String.Format(IFormatProvider, String, Object[]) method call, and that the default NumberFormatInfo provider is used in the third method call because the .ByteByByteFormatter.Format non riconosce la stringa di formato "N0" e restituisce un riferimento Null (Nothing in Visual Basic).method does not recognize the "N0" format string and returns a null reference (Nothing in Visual Basic).

public class Example
{
   public static void Main()
   {
      long value = 3210662321; 
      byte value1 = 214;
      byte value2 = 19;
      
      Console.WriteLine(String.Format(new ByteByByteFormatter(), "{0:X}", value));
      Console.WriteLine(String.Format(new ByteByByteFormatter(), "{0:X} And {1:X} = {2:X} ({2:000})", 
                                      value1, value2, value1 & value2));                                
      Console.WriteLine(String.Format(new ByteByByteFormatter(), "{0,10:N0}", value));
   }
}
// The example displays the following output:
//       00 00 00 00 BF 5E D1 B1
//       00 D6 And 00 13 = 00 12 (018)
//       3,210,662,321
Public Module Example
   Public Sub Main()
      Dim value As Long = 3210662321 
      Dim value1 As Byte = 214
      Dim value2 As Byte = 19
      
      Console.WriteLine((String.Format(New ByteByByteFormatter(), "{0:X}", value)))
      Console.WriteLine((String.Format(New ByteByByteFormatter(), "{0:X} And {1:X} = {2:X} ({2:000})", 
                                      value1, value2, value1 And value2)))                                
      Console.WriteLine(String.Format(New ByteByByteFormatter(), "{0,10:N0}", value))
   End Sub
End Module
' The example displays the following output:
'       00 00 00 00 BF 5E D1 B1
'       00 D6 And 00 13 = 00 12 (018)
'       3,210,662,321
TitoloTitle DefinizioneDefinition
Stringhe di formato numerico standardStandard Numeric Format Strings Vengono descritte le stringhe di formato standard che consentono di creare rappresentazioni di stringa usate comunemente di valori numerici.Describes standard format strings that create commonly used string representations of numeric values.
Stringhe di formato numerico personalizzatoCustom Numeric Format Strings Vengono descritte le stringhe di formato personalizzate che consentono di creare formati specifici dell'applicazione per valori numerici.Describes custom format strings that create application-specific formats for numeric values.
Stringhe di formato di data e ora standardStandard Date and Time Format Strings Vengono descritte le stringhe di formato standard che consentono di creare rappresentazioni di stringa usate comunemente di valori DateTime .Describes standard format strings that create commonly used string representations of DateTime values.
Stringhe di formato di data e ora personalizzatoCustom Date and Time Format Strings Vengono descritte le stringhe di formato personalizzate che consentono di creare formati specifici dell'applicazione per valori DateTime .Describes custom format strings that create application-specific formats for DateTime values.
Stringhe di formato TimeSpan standardStandard TimeSpan Format Strings Vengono descritte le stringhe di formato standard che consentono di creare rappresentazioni di stringa usate comunemente di intervalli di tempo.Describes standard format strings that create commonly used string representations of time intervals.
Stringhe di formato TimeSpan personalizzateCustom TimeSpan Format Strings Vengono descritte le stringhe di formato personalizzate che consentono di creare formati specifici dell'applicazione per intervalli di tempo.Describes custom format strings that create application-specific formats for time intervals.
Enumeration Format StringsEnumeration Format Strings Vengono descritte le stringhe di formato standard che consentono di creare rappresentazioni di stringa di valori di enumerazione.Describes standard format strings that are used to create string representations of enumeration values.
Formattazione compositaComposite Formatting Viene descritto come incorporare uno o più valori formattati in una stringa,Describes how to embed one or more formatted values in a string. che successivamente può essere visualizzata nella console oppure scritta in un flusso.The string can subsequently be displayed on the console or written to a stream.
Esecuzione di operazioni di formattazionePerforming Formatting Operations Sono elencati gli argomenti contenenti istruzioni dettagliate per l'esecuzione di operazioni di formattazione specifiche.Lists topics that provide step-by-step instructions for performing specific formatting operations.
Analisi di stringheParsing Strings Viene descritta l'inizializzazione di oggetti sui valori descritti dalle rappresentazioni in forma di stringa di tali oggetti.Describes how to initialize objects to the values described by string representations of those objects. L'analisi è l'operazione contraria alla formattazione.Parsing is the inverse operation of formatting.

ReferenceReference