String.Format Metodo

Definizione

Converte il valore degli oggetti in stringhe in base ai formati specificati e le inserisce in un'altra stringa.

Se non si ha familiarità con il metodo String.Format, vedere la sezione Iniziare a utilizzare il metodo String. Format per una rapida panoramica.

Vedere la sezione Osservazioni per la documentazione generale per il metodo String.Format.

Overload

Format(String, Object)

Sostituisce uno o più elementi di formato in una stringa con la rappresentazione di stringa di un oggetto specificato.

Format(String, Object[])

Sostituisce l'elemento di formato presente in una stringa specificata con la rappresentazione di stringa di un oggetto corrispondente in una matrice specificata.

Format(IFormatProvider, String, Object)

Sostituisce uno o più elementi di formato presenti in una stringa specificata con la rappresentazione di stringa dell'oggetto corrispondente. Un parametro fornisce le informazioni di formattazione specifiche delle impostazioni cultura.

Format(IFormatProvider, String, Object[])

Sostituisce gli elementi di formato presenti in una stringa con le rappresentazioni di stringa degli oggetti corrispondenti in una matrice specificata. Un parametro fornisce le informazioni di formattazione specifiche delle impostazioni cultura.

Format(String, Object, Object)

Sostituisce gli elementi di formato presenti in una stringa con la rappresentazione di stringa di due oggetti specificati.

Format(IFormatProvider, String, Object, Object)

Sostituisce gli elementi di formato presenti in una stringa con la rappresentazione di stringa di due oggetti specificati. Un parametro fornisce le informazioni di formattazione specifiche delle impostazioni cultura.

Format(String, Object, Object, Object)

Sostituisce gli elementi di formato in una stringa con le rappresentazioni di stringa di tre oggetti specificati.

Format(IFormatProvider, String, Object, Object, Object)

Sostituisce gli elementi di formato in una stringa con le rappresentazioni di stringa di tre oggetti specificati. Un parametro fornisce le informazioni di formattazione specifiche delle impostazioni cultura.

Esempio

Numerosi esempi che chiamano Format il metodo sono intercambiati nella sezione Osservazioni di questo articolo.

È anche possibile scaricare un set completo di String.Format esempi, inclusi un progetto .NET Core per C#.

Di seguito sono riportati alcuni esempi inclusi nell'articolo:

Creare una stringa di formato

Inserimento di una stringa
Elemento di formato
Formattare gli elementi con lo stesso indice

Controllare l'output formattato

Controllo della formattazione
Controllo della spaziatura
Controllo dell'allineamento
Controllo del numero di cifre integrali
Controllo del numero di cifre dopo il separatore decimale
Inclusione di parentesi graffe letterali in una stringa di risultato

Rendere le stringhe di formato con distinzione delle impostazioni cultura

Formattazione con distinzione delle impostazioni cultura

Personalizzare l'operazione di formattazione

Operazione di formattazione personalizzata
Un provider di intercettazione e un formattatore numerico romano

Commenti

Importante

Anziché chiamare il metodo String.Format o usare stringhe di formato composite, è possibile usare stringhe interpolate se supportate dal linguaggio. Una stringa interpolata è una stringa che contiene espressioni interpolate. Ogni espressione interpolata viene risolta con il valore dell'espressione e inclusa nella stringa di risultato al momento dell'assegnazione della stringa. Per altre informazioni, vedere Interpolazione di stringhe (Riferimenti per C#) e Stringhe interpolate (Riferimenti per Visual Basic).

Contenuto della sezione:

Introduzione al metodo String.Format
Quale metodo si chiama?
Brevemente, il metodo Format
Elemento Format
Formattazione degli argomenti
Formattare gli elementi con lo stesso indice
Formattazione e impostazioni cultura
Operazioni di formattazione personalizzate
String.Format Q & A

Introduzione al metodo String.Format

Usare se è necessario inserire il valore di un oggetto, una String.Format variabile o un'espressione in un'altra stringa. Ad esempio, è possibile inserire il valore di un valore in una stringa per Decimal visualizzarlo all'utente come singola stringa:

Decimal pricePerOunce = (Decimal)17.36;
String^ s = String::Format("The current price is {0} per ounce.",
                           pricePerOunce);
// Result: The current price is 17.36 per ounce.
Decimal pricePerOunce = 17.36m;
String s = String.Format("The current price is {0} per ounce.",
                         pricePerOunce);
Console.WriteLine(s);
// Result: The current price is 17.36 per ounce.
Dim pricePerOunce As Decimal = 17.36d
Dim s As String = String.Format("The current price is {0} per ounce.",
                                pricePerOunce)
' Result: The current price is 17.36 per ounce.

È anche possibile controllare la formattazione del valore:

Decimal pricePerOunce = (Decimal)17.36;
String^ s = String::Format("The current price is {0:C2} per ounce.",
                           pricePerOunce);
// Result if current culture is en-US:
//      The current price is $17.36 per ounce.
Decimal pricePerOunce = 17.36m;
String s = String.Format("The current price is {0:C2} per ounce.",
                         pricePerOunce);
Console.WriteLine(s);
// Result if current culture is en-US:
//      The current price is $17.36 per ounce.
Dim pricePerOunce As Decimal = 17.36d
Dim s As String = String.Format("The current price is {0:C2} per ounce.",
                                pricePerOunce)
' Result if current culture is en-US:
'      The current price is $17.36 per ounce.

Oltre alla formattazione, è anche possibile controllare l'allineamento e la spaziatura.

Inserire una stringa

String.Format inizia con una stringa di formato, seguita da uno o più oggetti o espressioni che verranno convertiti in stringhe e inseriti in una posizione specificata nella stringa di formato. Ad esempio:

Decimal temp = (Decimal)20.4;
String^ s = String::Format("The temperature is {0}°C.", temp);
Console::WriteLine(s);
// Displays 'The temperature is 20.4°C.'
decimal temp = 20.4m;
string s = String.Format("The temperature is {0}°C.", temp);
Console.WriteLine(s);
// Displays 'The temperature is 20.4°C.'
Dim temp As Decimal = 20.4d
Dim s As String = String.Format("The temperature is {0}°C.", temp)
Console.WriteLine(s)
' Displays 'The temperature is 20.4°C.'

nella {0} stringa di formato è un elemento di formato. 0 è l'indice dell'oggetto il cui valore stringa verrà inserito in tale posizione. Gli indici iniziano da 0. Se l'oggetto da inserire non è una stringa, viene chiamato il relativo metodo per convertirlo in uno prima di ToString inserirlo nella stringa di risultato.

Ecco un altro esempio che usa due elementi di formato e due oggetti nell'elenco di oggetti:

String^ s = String::Format("At {0}, the temperature is {1}°C.",
                           DateTime::Now, 20.4);
// Output similar to: 'At 4/10/2015 9:29:41 AM, the temperature is 20.4°C.'
string s = String.Format("At {0}, the temperature is {1}°C.",
                         DateTime.Now, 20.4);
Console.WriteLine(s);
// Output similar to: 'At 4/10/2015 9:29:41 AM, the temperature is 20.4°C.'
Dim s As String = String.Format("At {0}, the temperature is {1}°C.",
                                Date.Now, 20.4)
' Output similar to: 'At 4/10/2015 9:29:41 AM, the temperature is 20.4°C.'

È possibile avere tutti gli elementi di formato e il numero desiderato di oggetti nell'elenco di oggetti, purché l'indice di ogni elemento di formato abbia un oggetto corrispondente nell'elenco di oggetti. Non è inoltre necessario preoccuparsi dell'overload chiamato. il compilatore selezionerà quello appropriato.

Formattazione dei controlli

È possibile seguire l'indice in un elemento di formato con una stringa di formato per controllare la modalità di formattazione di un oggetto. Ad esempio, {0:d} applica la stringa di formato "d" al primo oggetto nell'elenco di oggetti. Di seguito è riportato un esempio con un singolo oggetto e due elementi di formato:

String^ s = String::Format("It is now {0:d} at {0:t}",
                           DateTime::Now);
// Output similar to: 'It is now 4/10/2015 at 10:04 AM'
string s = String.Format("It is now {0:d} at {0:t}", DateTime.Now);
Console.WriteLine(s);
// Output similar to: 'It is now 4/10/2015 at 10:04 AM'
Dim s As String = String.Format("It is now {0:d} at {0:t}",
                                Date.Now)
' Output similar to: 'It is now 4/10/2015 at 10:04 AM'

Diversi tipi supportano stringhe di formato, inclusi tutti i tipi numerici (stringhe di formato standard e personalizzato), tutte le date e le ore (stringhe di formato standard e personalizzato) e gli intervalli di tempo (stringhe di formato standard e personalizzate), tutti i tipi di enumerazione dei tipi di enumerazione e GUID. È anche possibile aggiungere il supporto per le stringhe di formato ai propri tipi.

Spaziatura dei controlli

È possibile definire la larghezza della stringa inserita nella stringa di risultato usando la sintassi , ad esempio , che inserisce una stringa {0,12} di 12 caratteri. In questo caso, la rappresentazione di stringa del primo oggetto è allineata a destra nel campo a 12 caratteri. Se la rappresentazione di stringa del primo oggetto ha una lunghezza superiore a 12 caratteri, tuttavia, la larghezza del campo preferita viene ignorata e l'intera stringa viene inserita nella stringa di risultato.

L'esempio seguente definisce un campo di 6 caratteri per contenere la stringa "Year" e alcune stringhe year, nonché un campo di 15 caratteri per contenere la stringa "Population" e alcuni dati sulla popolazione. Si noti che i caratteri sono allineati a destra nel campo .

array<int>^ years = { 2013, 2014, 2015 };
array<int>^ population = { 1025632, 1105967, 1148203 };
StringBuiler^ sb = gcnew StringBuilder();
sb->Append(String::Format("{0,6} {1,15}\n\n", "Year", "Population"));
for(int index = 0; index < years->Length; index++)
   sb->AppendFormat("{0,6} {1,15:N0}\n",
                    years[index], population[index]);
// Result:
//      Year      Population
//
//      2013       1,025,632
//      2014       1,105,967
//      2015       1,148,203
     int[] years = { 2013, 2014, 2015 };
     int[] population = { 1025632, 1105967, 1148203 };
     var sb = new System.Text.StringBuilder();
     sb.Append(String.Format("{0,6} {1,15}\n\n", "Year", "Population"));
     for (int index = 0; index < years.Length; index++)
        sb.Append(String.Format("{0,6} {1,15:N0}\n", years[index], population[index]));

     Console.WriteLine(sb);

     // Result:
     //      Year      Population
     //
     //      2013       1,025,632
     //      2014       1,105,967
     //      2015       1,148,203
Dim years() As Integer = { 2013, 2014, 2015 }
Dim population() As Integer  = { 1025632, 1105967, 1148203 }
Dim sb As New StringBuilder()
sb.Append(String.Format("{0,6} {1,15}{2}{2}",
                        "Year", "Population", vbCrLf))
For index As Integer = 0 To years.Length - 1
   sb.AppendFormat("{0,6} {1,15:N0}{2}",
                   years(index), population(index), vbCrLf)
Next
' Result:
'      Year      Population
'
'      2013       1,025,632
'      2014       1,105,967
'      2015       1,148,203

Allineamento dei controlli

Per impostazione predefinita, le stringhe vengono allineate a destra all'interno del campo se si specifica la larghezza del campo. Per allineare a sinistra le stringhe in un campo, è necessario antefare alla larghezza del campo un segno negativo, ad esempio per definire un campo allineato a sinistra di {0,-12} 12 caratteri.

L'esempio seguente è simile a quello precedente, ad eccezione del fatto che allinea a sinistra sia le etichette che i dati.

array<int>^ years = { 2013, 2014, 2015 };
array<int>^ population = { 1025632, 1105967, 1148203 };
String^ s = String::Format("{0,-10} {1,-10}\n\n", "Year", "Population");
for(int index = 0; index < years->Length; index++)
   s += String::Format("{0,-10} {1,-10:N0}\n",
                      years[index], population[index]);
// Result:
//    Year       Population
//
//    2013       1,025,632
//    2014       1,105,967
//    2015       1,148,203
int[] years = { 2013, 2014, 2015 };
int[] population = { 1025632, 1105967, 1148203 };
String s = String.Format("{0,-10} {1,-10}\n\n", "Year", "Population");
for(int index = 0; index < years.Length; index++)
   s += String.Format("{0,-10} {1,-10:N0}\n",
                      years[index], population[index]);
Console.WriteLine($"\n{s}");
// Result:
//    Year       Population
//
//    2013       1,025,632
//    2014       1,105,967
//    2015       1,148,203
Dim years() As Integer = { 2013, 2014, 2015 }
Dim population() As Integer  = { 1025632, 1105967, 1148203 }
Dim s As String = String.Format("{0,-10} {1,-10}{2}{2}",
                                "Year", "Population", vbCrLf)
For index As Integer = 0 To years.Length - 1
   s += String.Format("{0,-10} {1,-10:N0}{2}",
                      years(index), population(index), vbCrLf)
Next
' Result:
'    Year       Population
'
'    2013       1,025,632
'    2014       1,105,967
'    2015       1,148,203

String.Format usa la funzionalità di formattazione composita. Per altre informazioni, vedere Formattazione composita.

Quale metodo si chiama?

A Call
Formattare uno o più oggetti usando le convenzioni delle impostazioni cultura correnti. Ad eccezione degli overload che includono un parametro, gli overload rimanenti includono un parametro provider seguito da uno o più parametri di Format String oggetto. Per questo scopo, non è necessario determinare quale Format overload si intende chiamare. Il compilatore di linguaggio seleziona l'overload appropriato tra gli overload che non hanno un parametro, in provider base all'elenco di argomenti. Ad esempio, se l'elenco di argomenti include cinque argomenti, il compilatore chiama il Format(String, Object[]) metodo .
Formattare uno o più oggetti usando le convenzioni di impostazioni cultura specifiche. Ogni Format overload che inizia con un parametro è seguito da un parametro e da uno o più parametri provider di String oggetto. Per questo scopo, non è necessario determinare quale Format overload specifico si intende chiamare. Il compilatore di linguaggio seleziona l'overload appropriato tra gli overload che dispongono di un provider parametro, in base all'elenco di argomenti. Ad esempio, se l'elenco di argomenti include cinque argomenti, il compilatore chiama il Format(IFormatProvider, String, Object[]) metodo .
Eseguire un'operazione di formattazione personalizzata con ICustomFormatter un'implementazione o IFormattable un'implementazione . Uno dei quattro overload con un provider parametro . Il compilatore seleziona l'overload appropriato tra gli overload che dispongono di un provider parametro, in base all'elenco di argomenti.

Brevemente, il metodo Format

Ogni overload del metodo usa la funzionalità di formattazione composita per includere segnaposto indicizzati in base zero, denominati elementi di formato Format , in una stringa di formato composito. In fase di esecuzione, ogni elemento di formato viene sostituito con la rappresentazione di stringa dell'argomento corrispondente in un elenco di parametri. Se il valore dell'argomento è null , l'elemento di formato viene sostituito con String.Empty . Ad esempio, la chiamata seguente al metodo include una stringa di formato con tre elementi di formato, , e , e un elenco di argomenti Format(String, Object, Object, Object) {0} con tre {1} {2} elementi.

using namespace System;

void main()
{
   DateTime^ dat = gcnew DateTime(2012, 1, 17, 9, 30, 0); 
   String^ city = "Chicago";
   int temp = -16;
   String^ output = String::Format("At {0} in {1}, the temperature was {2} degrees.",
                                   dat, city, temp);
   Console::WriteLine(output);
}
// The example displays the following output: 
//    At 1/17/2012 9:30:00 AM in Chicago, the temperature was -16 degrees.
DateTime dat = new DateTime(2012, 1, 17, 9, 30, 0); 
string city = "Chicago";
int temp = -16;
string output = String.Format("At {0} in {1}, the temperature was {2} degrees.",
                              dat, city, temp);
Console.WriteLine(output);
// The example displays output like the following:
//    At 1/17/2012 9:30:00 AM in Chicago, the temperature was -16 degrees.
Dim dat As Date = #1/17/2012 9:30AM# 
Dim city As String = "Chicago"
Dim temp As Integer = -16
Dim output As String = String.Format("At {0} in {1}, the temperature was {2} degrees.",
                                     dat, city, temp)
Console.WriteLine(output)
' The example displays the following output:
'    At 1/17/2012 9:30:00 AM in Chicago, the temperature was -16 degrees.

Elemento di formato

Un elemento di formato ha la sintassi seguente:

{index[,alignment][:formatString]}

Le parentesi quadre indicano elementi facoltativi. Le parentesi graffe di apertura e chiusura sono obbligatorie. Per includere una parentesi graffa di apertura o chiusura letterale nella stringa di formato, vedere la sezione Parentesi graffe di escape nell'articolo Formattazione composita.

Ad esempio, un elemento di formato per formattare un valore di valuta potrebbe essere simile al seguente:

String::Format("{0,-10:C}", (Decimal) 126347.89);
var value = String.Format("{0,-10:C}", 126347.89m);         
Console.WriteLine(value);
String.Format("{0,-10:C}", 126347.89d)

Un elemento di formato ha gli elementi seguenti:

Indice
Indice in base zero dell'argomento la cui rappresentazione di stringa deve essere inclusa in questa posizione nella stringa. Se questo argomento è , nella stringa verrà inclusa una null stringa vuota in questa posizione.

Allineamento
facoltativo. Intero con segno che indica la lunghezza totale del campo in cui viene inserito l'argomento e se è allineato a destra (un numero intero positivo) o a sinistra (intero negativo). Se si omette l'allineamento, la rappresentazione di stringa dell'argomento corrispondente viene inserita in un campo senza spazi iniziali o finali.

Se il valore dell'allineamento è minore della lunghezza dell'argomento da inserire, l'allineamento viene ignorato e la lunghezza della rappresentazione di stringa dell'argomento viene usata come larghezza del campo.

Formatstring
facoltativo. Stringa che specifica il formato della stringa di risultato dell'argomento corrispondente. Se si omette formatString, viene chiamato il metodo senza parametri dell'argomento corrispondente ToString per produrre la relativa rappresentazione di stringa. Se si specifica formatString, l'argomento a cui fa riferimento l'elemento di formato deve implementare IFormattable l'interfaccia . I tipi che supportano le stringhe di formato includono:

Si noti tuttavia che qualsiasi tipo personalizzato può implementare IFormattable o estendere l'implementazione di un tipo IFormattable esistente.

Nell'esempio seguente vengono utilizzati alignment gli argomenti e per produrre output formatString formattato.

using namespace System;

void main()
{
   // Create array of 5-tuples with population data for three U.S. cities, 1940-1950.
   array<Tuple<String^, DateTime, int, DateTime, int>^>^ cities = gcnew array<Tuple<String^, DateTime, int, DateTime, int>^> 
         { gcnew Tuple<String^, DateTime, int, DateTime, int>("Los Angeles", DateTime(1940, 1, 1), 1504277, 
                        DateTime(1950, 1, 1), 1970358),
         gcnew Tuple<String^, DateTime, int, DateTime, int>("New York", DateTime(1940, 1, 1), 7454995, 
                        DateTime(1950, 1, 1), 7891957),  
         gcnew Tuple<String^, DateTime, int, DateTime, int>("Chicago", DateTime(1940, 1, 1), 3396808, 
                        DateTime(1950, 1, 1), 3620962),  
         gcnew Tuple<String^, DateTime, int, DateTime, int>("Detroit", DateTime(1940, 1, 1), 1623452, 
                        DateTime(1950, 1, 1), 1849568) };

   // Display header
   String^ header = String::Format("{0,-12}{1,8}{2,12}{1,8}{2,12}{3,14}\n",
                                   "City", "Year", "Population", "Change (%)");
   Console::WriteLine(header);
   String^ output;      
   for each (Tuple<String^, DateTime, int, DateTime, int>^ city in cities) {
      output = String::Format("{0,-12}{1,8:yyyy}{2,12:N0}{3,8:yyyy}{4,12:N0}{5,14:P1}",
                              city->Item1, city->Item2, city->Item3, city->Item4, city->Item5,
                              (city->Item5 - city->Item3)/ (double)city->Item3);
      Console::WriteLine(output);
   }
}
// The example displays the following output:
//    City            Year  Population    Year  Population    Change (%)
//    
//    Los Angeles     1940   1,504,277    1950   1,970,358        31.0 %
//    New York        1940   7,454,995    1950   7,891,957         5.9 %
//    Chicago         1940   3,396,808    1950   3,620,962         6.6 %
//    Detroit         1940   1,623,452    1950   1,849,568        13.9 %
// Create array of 5-tuples with population data for three U.S. cities, 1940-1950.
Tuple<string, DateTime, int, DateTime, int>[] cities = 
    { Tuple.Create("Los Angeles", new DateTime(1940, 1, 1), 1504277, 
                   new DateTime(1950, 1, 1), 1970358),
      Tuple.Create("New York", new DateTime(1940, 1, 1), 7454995, 
                   new DateTime(1950, 1, 1), 7891957),  
      Tuple.Create("Chicago", new DateTime(1940, 1, 1), 3396808, 
                   new DateTime(1950, 1, 1), 3620962),  
      Tuple.Create("Detroit", new DateTime(1940, 1, 1), 1623452, 
                   new DateTime(1950, 1, 1), 1849568) };

// Display header
var header = String.Format("{0,-12}{1,8}{2,12}{1,8}{2,12}{3,14}\n",
                              "City", "Year", "Population", "Change (%)");
Console.WriteLine(header);
foreach (var city in cities) {
   var output = String.Format("{0,-12}{1,8:yyyy}{2,12:N0}{3,8:yyyy}{4,12:N0}{5,14:P1}",
                          city.Item1, city.Item2, city.Item3, city.Item4, city.Item5,
                          (city.Item5 - city.Item3)/ (double)city.Item3);
   Console.WriteLine(output);
}
// The example displays the following output:
//    City            Year  Population    Year  Population    Change (%)
//  
//    Los Angeles     1940   1,504,277    1950   1,970,358        31.0 %
//    New York        1940   7,454,995    1950   7,891,957         5.9 %
//    Chicago         1940   3,396,808    1950   3,620,962         6.6 %
//    Detroit         1940   1,623,452    1950   1,849,568        13.9 %
Module Example
   Public Sub Main()
      ' Create array of 5-tuples with population data for three U.S. cities, 1940-1950.
      Dim cities()  = _
          { Tuple.Create("Los Angeles", #1/1/1940#, 1504277, #1/1/1950#, 1970358),
            Tuple.Create("New York", #1/1/1940#, 7454995, #1/1/1950#, 7891957),  
            Tuple.Create("Chicago", #1/1/1940#, 3396808, #1/1/1950#, 3620962),  
            Tuple.Create("Detroit", #1/1/1940#, 1623452, #1/1/1950#, 1849568) }

      ' Display header
      Dim header As String = String.Format("{0,-12}{1,8}{2,12}{1,8}{2,12}{3,14}",
                                           "City", "Year", "Population", "Change (%)")
      Console.WriteLine(header)
      Console.WriteLine()
      For Each city In cities
         Dim output = String.Format("{0,-12}{1,8:yyyy}{2,12:N0}{3,8:yyyy}{4,12:N0}{5,14:P1}",
                                city.Item1, city.Item2, city.Item3, city.Item4, city.Item5,
                                (city.Item5 - city.Item3)/city.Item3)
         Console.WriteLine(output)
      Next
   End Sub
End Module
' The example displays the following output:
'    City            Year  Population    Year  Population    Change (%)
'    
'    Los Angeles     1940   1,504,277    1950   1,970,358        31.0 %
'    New York        1940   7,454,995    1950   7,891,957         5.9 %
'    Chicago         1940   3,396,808    1950   3,620,962         6.6 %
'    Detroit         1940   1,623,452    1950   1,849,568        13.9 %

Formattazione degli argomenti

Gli elementi di formato vengono elaborati in sequenza dall'inizio della stringa. Ogni elemento di formato ha un indice che corrisponde a un oggetto nell'elenco di argomenti del metodo. Il Format metodo recupera l'argomento e ne deriva la rappresentazione di stringa come segue:

Per un esempio che intercetta le chiamate al metodo e consente di visualizzare le informazioni passate dal metodo a un metodo di formattazione per ogni elemento di formato in una stringa di formato composito, vedere Esempio: provider di intercettazioni e formattatore ICustomFormatter.Format Format numerico romano.

Per altre informazioni, vedere la sezione Ordine di elaborazione nell'articolo Formattazione composita.

Formattare gli elementi con lo stesso indice

Il metodo genera un'eccezione se l'indice di un elemento dell'indice è maggiore o uguale al numero di Format FormatException argomenti nell'elenco di argomenti. Tuttavia, format può includere più elementi di formato rispetto agli argomenti, purché più elementi di formato presentino lo stesso indice. Nella chiamata al metodo nell'esempio seguente l'elenco di argomenti ha un solo argomento, ma la stringa di formato include due elementi di formato: uno visualizza il valore decimale di un numero e l'altro ne visualizza il valore Format(String, Object) esadecimale.

short[] values= { Int16.MinValue, -27, 0, 1042, Int16.MaxValue };
Console.WriteLine("{0,10}  {1,10}\n", "Decimal", "Hex");
foreach (short value in values)
{
   string formatString = String.Format("{0,10:G}: {0,10:X}", value);
   Console.WriteLine(formatString);
}   
// The example displays the following output:
//       Decimal         Hex
//    
//        -32768:       8000
//           -27:       FFE5
//             0:          0
//          1042:        412
//         32767:       7FFF
Module Example
   Public Sub Main()
      Dim values() As Short = { Int16.MinValue, -27, 0, 1042, Int16.MaxValue }
      Console.WriteLine("{0,10}  {1,10}", "Decimal", "Hex")
      Console.WriteLine()
      For Each value As Short In values
         Dim formatString As String = String.Format("{0,10:G}: {0,10:X}", value)
         Console.WriteLine(formatString)
      Next        
   End Sub
End Module
' The example displays the following output:
'       Decimal         Hex
'    
'        -32768:       8000
'           -27:       FFE5
'             0:          0
'          1042:        412
'         32767:       7FFF

Formato e impostazioni cultura

In genere, gli oggetti nell'elenco di argomenti vengono convertiti nelle relative rappresentazioni di stringa usando le convenzioni delle impostazioni cultura correnti, restituite dalla CultureInfo.CurrentCulture proprietà . È possibile controllare questo comportamento chiamando uno degli overload di Format che include un parametro provider . Il parametro è un'implementazione che fornisce informazioni di formattazione personalizzate e specifiche delle impostazioni cultura utilizzate provider IFormatProvider per moderare il processo di formattazione.

L'interfaccia ha un singolo membro, , responsabile della IFormatProvider restituzione GetFormat dell'oggetto che fornisce informazioni di formattazione. .NET include tre IFormatProvider implementazioni che forniscono formattazione specifica delle impostazioni cultura:

  • CultureInfo. Il metodo restituisce un oggetto specifico delle impostazioni cultura per la formattazione di valori numerici e un oggetto specifico delle impostazioni cultura per GetFormat NumberFormatInfo la DateTimeFormatInfo formattazione dei valori di data e ora.

  • DateTimeFormatInfo, usato per la formattazione specifica delle impostazioni cultura dei valori di data e ora. Il GetFormat metodo restituisce se stesso.

  • NumberFormatInfo, usato per la formattazione specifica delle impostazioni cultura dei valori numerici. La GetFormat proprietà restituisce se stessa.

Operazioni di formattazione personalizzate

È anche possibile chiamare qualsiasi overload del metodo che dispone di un parametro Format di tipo per eseguire operazioni di provider IFormatProvider formattazione personalizzate. Ad esempio, è possibile formattare un numero intero come numero di identificazione o come numero di telefono. Per eseguire la formattazione personalizzata, provider l'argomento deve implementare IFormatProvider entrambe le ICustomFormatter interfacce e . Quando al Format metodo viene passata un'implementazione come argomento, il metodo chiama la ICustomFormatter provider relativa Format IFormatProvider.GetFormat implementazione e richiede un oggetto di tipo ICustomFormatter . Chiama quindi il metodo ICustomFormatter dell'oggetto restituito per formattare ogni elemento Format di formato nella stringa composita passata.

Per altre informazioni su come fornire soluzioni di formattazione personalizzate, vedere Procedura: Definire e usare provider di formati numerici personalizzati e ICustomFormatter . Per un esempio di conversione di numeri interi in numeri personalizzati formattati, vedere Esempio: operazione di formattazione personalizzata. Per un esempio di conversione di byte senza segno in numeri romani, vedere Esempio: provider di intercettazioni e formattatore numerico romano.

Esempio: operazione di formattazione personalizzata

Questo esempio definisce un provider di formato che formatta un valore intero come numero di conto cliente nel formato x-xxxxx-xx.

using namespace System;

ref class CustomerFormatter : IFormatProvider, ICustomFormatter
{
public:
   virtual Object^ GetFormat(Type^ formatType) 
   {
      if (formatType == ICustomFormatter::typeid)        
         return this; 
      else 
         return nullptr; 
   }
   
   virtual String^ Format(String^ format, 
                   Object^ arg, 
                   IFormatProvider^ formatProvider) 
   {                       
      if (! this->Equals(formatProvider))
      {
         return nullptr;
      }
      else
      {
         if (String::IsNullOrEmpty(format)) 
            format = "G";
         
         String^ customerString = arg->ToString();
         if (customerString->Length < 8)
            customerString = customerString->PadLeft(8, '0');
         
         format = format->ToUpper();
         if (format == L"G") 
               return customerString->Substring(0, 1) + "-" +
                                     customerString->Substring(1, 5) + "-" +
                                     customerString->Substring(6);
         else if (format == L"S")                          
               return customerString->Substring(0, 1) + "/" +
                                     customerString->Substring(1, 5) + "/" +
                                     customerString->Substring(6);
         else if (format == L"P")
               return customerString->Substring(0, 1) + "." +
                                     customerString->Substring(1, 5) + "." +
                                     customerString->Substring(6);
         else
               throw gcnew FormatException( 
                         String::Format("The '{0}' format specifier is not supported.", format));
         }
    }   
};

void main()
{
   int acctNumber = 79203159;
   Console::WriteLine(String::Format(gcnew CustomerFormatter, "{0}", acctNumber));
   Console::WriteLine(String::Format(gcnew CustomerFormatter, "{0:G}", acctNumber));
   Console::WriteLine(String::Format(gcnew CustomerFormatter, "{0:S}", acctNumber));
   Console::WriteLine(String::Format(gcnew CustomerFormatter, "{0:P}", acctNumber));
   try {
      Console::WriteLine(String::Format(gcnew CustomerFormatter, "{0:X}", acctNumber));
   }
   catch (FormatException^ e) {
      Console::WriteLine(e->Message);
   }
}
// The example displays the following output:
//       7-92031-59
//       7-92031-59
//       7/92031/59
//       7.92031.59
//       The 'X' format specifier is not supported.
using System;

public class TestFormatter
{
   public static void Main()
   {
      int acctNumber = 79203159;
      Console.WriteLine(String.Format(new CustomerFormatter(), "{0}", acctNumber));
      Console.WriteLine(String.Format(new CustomerFormatter(), "{0:G}", acctNumber));
      Console.WriteLine(String.Format(new CustomerFormatter(), "{0:S}", acctNumber));
      Console.WriteLine(String.Format(new CustomerFormatter(), "{0:P}", acctNumber));
      try {
         Console.WriteLine(String.Format(new CustomerFormatter(), "{0:X}", acctNumber));
      }
      catch (FormatException e) {
         Console.WriteLine(e.Message);
      }
   }
}

public class CustomerFormatter : 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 (! this.Equals(formatProvider))
      {
         return null;
      }
      else
      {
         if (String.IsNullOrEmpty(format)) 
            format = "G";
         
         string customerString = arg.ToString();
         if (customerString.Length < 8)
            customerString = customerString.PadLeft(8, '0');
         
         format = format.ToUpper();
         switch (format)
         {
            case "G":
               return customerString.Substring(0, 1) + "-" +
                                     customerString.Substring(1, 5) + "-" +
                                     customerString.Substring(6);
            case "S":                          
               return customerString.Substring(0, 1) + "/" +
                                     customerString.Substring(1, 5) + "/" +
                                     customerString.Substring(6);
            case "P":                          
               return customerString.Substring(0, 1) + "." +
                                     customerString.Substring(1, 5) + "." +
                                     customerString.Substring(6);
            default:
               throw new FormatException( 
                         String.Format("The '{0}' format specifier is not supported.", format));
         }
      }   
   }
}
// The example displays the following output:
//       7-92031-59
//       7-92031-59
//       7/92031/59
//       7.92031.59
//       The 'X' format specifier is not supported.
Module TestFormatter
   Public Sub Main()
      Dim acctNumber As Integer = 79203159
      Console.WriteLine(String.Format(New CustomerFormatter, "{0}", acctNumber))
      Console.WriteLine(String.Format(New CustomerFormatter, "{0:G}", acctNumber))
      Console.WriteLine(String.Format(New CustomerFormatter, "{0:S}", acctNumber))
      Console.WriteLine(String.Format(New CustomerFormatter, "{0:P}", acctNumber))
      Try
         Console.WriteLine(String.Format(New CustomerFormatter, "{0:X}", acctNumber))
      Catch e As FormatException
         Console.WriteLine(e.Message)
      End Try   
   End Sub
End Module

Public Class CustomerFormatter : Implements IFormatProvider, ICustomFormatter
   Public Function GetFormat(type As Type) As Object  _
                   Implements IFormatProvider.GetFormat
      If type 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 Me.Equals(formatProvider) Then
         Return Nothing
      Else
         If String.IsNullOrEmpty(fmt) Then fmt = "G"
         
         Dim customerString As String = arg.ToString()
         if customerString.Length < 8 Then _
            customerString = customerString.PadLeft(8, "0"c)
         
         Select Case fmt
            Case "G"
               Return customerString.Substring(0, 1) & "-" & _
                                     customerString.Substring(1, 5) & "-" & _
                                     customerString.Substring(6)
            Case "S"                         
               Return customerString.Substring(0, 1) & "/" & _
                                     customerString.Substring(1, 5) & "/" & _
                                     customerString.Substring(6)
            Case "P"
               Return customerString.Substring(0, 1) & "." & _
                                     customerString.Substring(1, 5) & "." & _
                                     customerString.Substring(6)
            Case Else
               Throw New FormatException( _
                         String.Format("The '{0}' format specifier is not supported.", fmt))
         End Select                                                     
      End If   
   End Function
End Class
' The example displays the following output:
'       7-92031-59
'       7-92031-59
'       7/92031/59
'       7.92031.59
'       The 'X' format specifier is not supported.

Esempio: provider di intercettazione e formattatore numerico romano

Questo esempio definisce un provider di formato personalizzato che implementa le ICustomFormatter interfacce e per eseguire due IFormatProvider operazioni:

  • Visualizza i parametri passati alla relativa ICustomFormatter.Format implementazione. In questo modo è possibile visualizzare i parametri passati dal metodo all'implementazione della formattazione Format(IFormatProvider, String, Object[]) personalizzata per ogni oggetto che tenta di formattare. Ciò può essere utile quando si esegue il debug dell'applicazione.

  • Se l'oggetto da formattare è un valore di byte senza segno che deve essere formattato usando la stringa di formato standard "R", il formattatore personalizzato formatta il valore numerico come numero romano.

using namespace System;
using namespace System::Globalization;

ref class InterceptProvider : IFormatProvider, ICustomFormatter
{
public:
   virtual Object^ GetFormat(Type^ formatType)
   {
      if (formatType == ICustomFormatter::typeid)   
         return this;
      else
         return nullptr;
   }
   
   virtual String^ Format(String^ format, Object^ obj, IFormatProvider^ provider) 
   {
      // Display information about method call.
      String^ formatString = format != nullptr ? format : "<null>";
      Console::WriteLine("Provider: {0}, Object: {1}, Format String: {2}",
                        provider, obj != nullptr ? obj : "<null>", formatString);
                        
      if (obj == nullptr) return String::Empty;
            
      // If this is a byte and the "R" format string, format it with Roman numerals.
      if (obj->GetType() == Byte::typeid && formatString->ToUpper()->Equals("R")) {
         Byte value = (Byte) obj;
         int remainder;
         int result;
         String^ returnString = String::Empty;

         // Get the hundreds digit(s)
         result = Math::DivRem(value, 100, remainder);
         if (result > 0)  
            returnString = gcnew String('C', result);
         value = (Byte) remainder;
         // Get the 50s digit
         result = Math::DivRem(value, 50, remainder);
         if (result == 1)
            returnString += "L";
         value = (Byte) remainder;
         // Get the tens digit.
         result = Math::DivRem(value, 10, remainder);
         if (result > 0)
            returnString += gcnew String('X', result);
         value = (Byte) remainder; 
         // Get the fives digit.
         result = Math::DivRem(value, 5, remainder);
         if (result > 0)
            returnString += "V";
         value = (Byte) remainder;
         // Add the ones digit.
         if (remainder > 0) 
            returnString += gcnew String('I', remainder);
         
         // Check whether we have too many X characters.
         int pos = returnString->IndexOf("XXXX");
         if (pos >= 0) {
            int xPos = returnString->IndexOf("L"); 
            if ((xPos >= 0) & (xPos == pos - 1))
               returnString = returnString->Replace("LXXXX", "XC");
            else
               returnString = returnString->Replace("XXXX", "XL");   
         }
         // Check whether we have too many I characters
         pos = returnString->IndexOf("IIII");
         if (pos >= 0)
            if (returnString->IndexOf("V") >= 0)
               returnString = returnString->Replace("VIIII", "IX");
            else
               returnString = returnString->Replace("IIII", "IV");    

         return returnString; 
      }   

      // Use default for all other formatting.
      if (obj->GetType() == IFormattable::typeid)
         return ((IFormattable^) obj)->ToString(format, CultureInfo::CurrentCulture);
      else
         return obj->ToString();
   }
};

void main()
{
   int n = 10;
   double value = 16.935;
   DateTime day = DateTime::Now;
   InterceptProvider^ provider = gcnew InterceptProvider();
   Console::WriteLine(String::Format(provider, "{0:N0}: {1:C2} on {2:d}\n", n, value, day));
   Console::WriteLine(String::Format(provider, "{0}: {1:F}\n", "Today: ", 
                                    (DayOfWeek) DateTime::Now.DayOfWeek));
   Console::WriteLine(String::Format(provider, "{0:X}, {1}, {2}\n", 
                                    (Byte) 2, (Byte) 12, (Byte) 199));
   Console::WriteLine(String::Format(provider, "{0:R}, {1:R}, {2:R}\n", 
                                    (Byte) 2, (Byte) 12, (Byte) 199));
}
// The example displays the following output:
//    Provider: InterceptProvider, Object: 10, Format String: N0
//    Provider: InterceptProvider, Object: 16.935, Format String: C2
//    Provider: InterceptProvider, Object: 1/31/2013 6:10:28 PM, Format String: d
//    10: $16.94 on 1/31/2013
//    
//    Provider: InterceptProvider, Object: Today: , Format String: <null>
//    Provider: InterceptProvider, Object: Thursday, Format String: F
//    Today: : Thursday
//    
//    Provider: InterceptProvider, Object: 2, Format String: X
//    Provider: InterceptProvider, Object: 12, Format String: <null>
//    Provider: InterceptProvider, Object: 199, Format String: <null>
//    2, 12, 199
//    
//    Provider: InterceptProvider, Object: 2, Format String: R
//    Provider: InterceptProvider, Object: 12, Format String: R
//    Provider: InterceptProvider, Object: 199, Format String: R
//    II, XII, CXCIX
using System;
using System.Globalization;

public class InterceptProvider : IFormatProvider, ICustomFormatter
{
   public object GetFormat(Type formatType)
   {
      if (formatType == typeof(ICustomFormatter))
         return this;
      else
         return null;
   }
   
   public string Format(String format, Object obj, IFormatProvider provider) 
   {
      // Display information about method call.
      string formatString = format ?? "<null>";
      Console.WriteLine("Provider: {0}, Object: {1}, Format String: {2}",
                        provider.GetType().Name, obj ?? "<null>", formatString);
                        
      if (obj == null) return String.Empty;
            
      // If this is a byte and the "R" format string, format it with Roman numerals.
      if (obj is Byte && formatString.ToUpper().Equals("R")) {
         Byte value = (Byte) obj;
         int remainder;
         int result;
         String returnString = String.Empty;

         // Get the hundreds digit(s)
         result = Math.DivRem(value, 100, out remainder);
         if (result > 0)  
            returnString = new String('C', result);
         value = (Byte) remainder;
         // Get the 50s digit
         result = Math.DivRem(value, 50, out remainder);
         if (result == 1)
            returnString += "L";
         value = (Byte) remainder;
         // Get the tens digit.
         result = Math.DivRem(value, 10, out remainder);
         if (result > 0)
            returnString += new String('X', result);
         value = (Byte) remainder; 
         // Get the fives digit.
         result = Math.DivRem(value, 5, out remainder);
         if (result > 0)
            returnString += "V";
         value = (Byte) remainder;
         // Add the ones digit.
         if (remainder > 0) 
            returnString += new String('I', remainder);
         
         // Check whether we have too many X characters.
         int pos = returnString.IndexOf("XXXX");
         if (pos >= 0) {
            int xPos = returnString.IndexOf("L"); 
            if (xPos >= 0 & xPos == pos - 1)
               returnString = returnString.Replace("LXXXX", "XC");
            else
               returnString = returnString.Replace("XXXX", "XL");   
         }
         // Check whether we have too many I characters
         pos = returnString.IndexOf("IIII");
         if (pos >= 0)
            if (returnString.IndexOf("V") >= 0)
               returnString = returnString.Replace("VIIII", "IX");
            else
               returnString = returnString.Replace("IIII", "IV");    

         return returnString; 
      }   

      // Use default for all other formatting.
      if (obj is IFormattable)
         return ((IFormattable) obj).ToString(format, CultureInfo.CurrentCulture);
      else
         return obj.ToString();
   }
}

public class Example
{
   public static void Main()
   {
      int n = 10;
      double value = 16.935;
      DateTime day = DateTime.Now;
      InterceptProvider provider = new InterceptProvider();
      Console.WriteLine(String.Format(provider, "{0:N0}: {1:C2} on {2:d}\n", n, value, day));
      Console.WriteLine(String.Format(provider, "{0}: {1:F}\n", "Today: ", 
                                      (DayOfWeek) DateTime.Now.DayOfWeek));
      Console.WriteLine(String.Format(provider, "{0:X}, {1}, {2}\n", 
                                      (Byte) 2, (Byte) 12, (Byte) 199));
      Console.WriteLine(String.Format(provider, "{0:R}, {1:R}, {2:R}\n", 
                                      (Byte) 2, (Byte) 12, (Byte) 199));
   }
}
// The example displays the following output:
//    Provider: InterceptProvider, Object: 10, Format String: N0
//    Provider: InterceptProvider, Object: 16.935, Format String: C2
//    Provider: InterceptProvider, Object: 1/31/2013 6:10:28 PM, Format String: d
//    10: $16.94 on 1/31/2013
//    
//    Provider: InterceptProvider, Object: Today: , Format String: <null>
//    Provider: InterceptProvider, Object: Thursday, Format String: F
//    Today: : Thursday
//    
//    Provider: InterceptProvider, Object: 2, Format String: X
//    Provider: InterceptProvider, Object: 12, Format String: <null>
//    Provider: InterceptProvider, Object: 199, Format String: <null>
//    2, 12, 199
//    
//    Provider: InterceptProvider, Object: 2, Format String: R
//    Provider: InterceptProvider, Object: 12, Format String: R
//    Provider: InterceptProvider, Object: 199, Format String: R
//    II, XII, CXCIX
Imports System.Globalization

Public Class InterceptProvider : 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, obj As Object, provider As IFormatProvider) As String _
         Implements ICustomFormatter.Format

      Dim formatString As String = If(fmt IsNot Nothing, fmt, "<null>")
      Console.WriteLine("Provider: {0}, Object: {1}, Format String: {2}",
                        provider, If(obj IsNot Nothing, obj, "<null>"), formatString)

      If obj Is Nothing Then Return String.Empty
            
      ' If this is a byte and the "R" format string, format it with Roman numerals.
      If TypeOf(obj) Is Byte AndAlso formatString.ToUpper.Equals("R") Then
         Dim value As Byte = CByte(obj)
         Dim remainder As Integer
         Dim result As Integer
         Dim returnString As String = String.Empty

         ' Get the hundreds digit(s)
         result = Math.DivRem(value, 100, remainder)
         If result > 0 Then returnString = New String("C"c, result)
         value = CByte(remainder)
         ' Get the 50s digit
         result = Math.DivRem(value, 50, remainder)
         If result = 1 Then returnString += "L"
         value = CByte(remainder)
         ' Get the tens digit.
         result = Math.DivRem(value, 10, remainder)
         If result > 0 Then returnString += New String("X"c, result)
         value = CByte(remainder) 
         ' Get the fives digit.
         result = Math.DivRem(value, 5, remainder)
         If result > 0 Then returnString += "V"
         value = CByte(remainder)
         ' Add the ones digit.
         If remainder > 0 Then returnString += New String("I"c, remainder)
         
         ' Check whether we have too many X characters.
         Dim pos As Integer = returnString.IndexOf("XXXX")
         If pos >= 0 Then
            Dim xPos As Integer = returnString.IndexOf("L") 
            If xPos >= 0 And xPos = pos - 1 Then
               returnString = returnString.Replace("LXXXX", "XC")
            Else
               returnString = returnString.Replace("XXXX", "XL")   
            End If         
         End If
         ' Check whether we have too many I characters
         pos = returnString.IndexOf("IIII")
         If pos >= 0 Then
            If returnString.IndexOf("V") >= 0 Then
               returnString = returnString.Replace("VIIII", "IX")
            Else
               returnString = returnString.Replace("IIII", "IV")    
            End If
         End If
         Return returnString 
      End If   

      ' Use default for all other formatting.
      If obj Is GetType(IFormattable)
         Return CType(obj, IFormattable).ToString(fmt, CultureInfo.CurrentCulture)
      Else
         Return obj.ToString()
      End If
   End Function
End Class

Module Example
   Public Sub Main()
      Dim n As Integer = 10
      Dim value As Double = 16.935
      Dim day As DateTime = Date.Now
      Dim provider As New InterceptProvider()
      Console.WriteLine(String.Format(provider, "{0:N0}: {1:C2} on {2:d}", n, value, day))
      Console.WriteLine()
      Console.WriteLine(String.Format(provider, "{0}: {1:F}", "Today", 
                                      CType(Date.Now.DayOfWeek, DayOfWeek)))
      Console.WriteLine()
      Console.WriteLine(String.Format(provider, "{0:X}, {1}, {2}\n", 
                                      CByte(2), CByte(12), CByte(199)))
      Console.WriteLine()
      Console.WriteLine(String.Format(provider, "{0:R}, {1:R}, {2:R}", 
                                      CByte(2), CByte(12), CByte(199)))
   End Sub
End Module
' The example displays the following output:
'    Provider: InterceptProvider, Object: 10, Format String: N0
'    Provider: InterceptProvider, Object: 16.935, Format String: C2
'    Provider: InterceptProvider, Object: 1/31/2013 6:10:28 PM, Format String: d
'    10: $16.94 on 1/31/2013
'    
'    Provider: InterceptProvider, Object: Today: , Format String: <null>
'    Provider: InterceptProvider, Object: Thursday, Format String: F
'    Today: : Thursday
'    
'    Provider: InterceptProvider, Object: 2, Format String: X
'    Provider: InterceptProvider, Object: 12, Format String: <null>
'    Provider: InterceptProvider, Object: 199, Format String: <null>
'    2, 12, 199
'    
'    Provider: InterceptProvider, Object: 2, Format String: R
'    Provider: InterceptProvider, Object: 12, Format String: R
'    Provider: InterceptProvider, Object: 199, Format String: R
'    II, XII, CXCIX

String.Format Q & A

Perché è consigliabile l'interpolazione di stringhe su chiamate al String.Format metodo ?

L'interpolazione di stringhe è:

  • Più flessibile. Può essere usato in qualsiasi stringa senza richiedere una chiamata a un metodo che supporta la formattazione composita. In caso contrario, è necessario chiamare il Format metodo o un altro metodo che supporta la formattazione composita, ad esempio o Console.WriteLine StringBuilder.AppendFormat .

  • Più leggibile. Poiché l'espressione da inserire in una stringa viene visualizzata nell'espressione interpolata anziché in un elenco di argomenti, le stringhe interpolate sono molto più facili da codificare e leggere. Grazie alla maggiore leggibilità, le stringhe interpolate possono sostituire non solo le chiamate ai metodi di formato composito, ma anche nelle operazioni di concatenazione di stringhe per produrre codice più conciso e chiaro.

Un confronto dei due esempi di codice seguenti illustra la superiorità delle stringhe interpolate sulla concatenazione di stringhe e le chiamate ai metodi di formattazione composita. L'uso di più operazioni di concatenazione di stringhe nell'esempio seguente produce codice dettagliato e difficile da leggere.

  string[] names = { "Balto", "Vanya", "Dakota", "Samuel", "Koani", "Yiska", "Yuma" };
  string output = names[0] + ", " + names[1] + ", " + names[2] + ", " + 
                  names[3] + ", " + names[4] + ", " + names[5] + ", " + 
                  names[6];  

  output += "\n";  
  var date = DateTime.Now;
  output += String.Format("It is {0:t} on {0:d}. The day of the week is {1}.", 
                          date, date.DayOfWeek);
  Console.WriteLine(output);                           
  // The example displays the following output:
  //     Balto, Vanya, Dakota, Samuel, Koani, Yiska, Yuma
  //     It is 10:29 AM on 1/8/2018. The day of the week is Monday.

Module Example
   Public Sub Main()
      Dim names = { "Balto", "Vanya", "Dakota", "Samuel", "Koani", "Yiska", "Yuma" }
      Dim output = names(0) + ", " + names(1) + ", " + names(2) + ", " + 
                   names(3) + ", " + names(4) + ", " + names(5) + ", " + 
                   names(6)  
    
      output += vbCrLf  
      Dim dat = DateTime.Now
      output += String.Format("It is {0:t} on {0:d}. The day of the week is {1}.", 
                              dat, dat.DayOfWeek)
      Console.WriteLine(output)                           
   End Sub
End Module
' The example displays the following output:
'     Balto, Vanya, Dakota, Samuel, Koani, Yiska, Yuma
'     It is 10:29 AM on 1/8/2018. The day of the week is Monday.

Al contrario, l'uso di stringhe interpolate nell'esempio seguente produce codice molto più chiaro e conciso rispetto all'istruzione di concatenazione di stringhe e alla chiamata al metodo Format nell'esempio precedente.

  string[] names = { "Balto", "Vanya", "Dakota", "Samuel", "Koani", "Yiska", "Yuma" };
  string output = $"{names[0]}, {names[1]}, {names[2]}, {names[3]}, {names[4]}, " + 
                  $"{names[5]}, {names[6]}";  

  var date = DateTime.Now;
  output += $"\nIt is {date:t} on {date:d}. The day of the week is {date.DayOfWeek}.";
  Console.WriteLine(output);                           
  // The example displays the following output:
  //     Balto, Vanya, Dakota, Samuel, Koani, Yiska, Yuma
  //     It is 10:29 AM on 1/8/2018. The day of the week is Monday.

Module Example
   Public Sub Main()
      Dim names = { "Balto", "Vanya", "Dakota", "Samuel", "Koani", "Yiska", "Yuma" }
      Dim output = $"{names(0)}, {names(1)}, {names(2)}, {names(3)}, {names(4)}, " + 
                   $"{names(5)}, {names(6)}"  
    
      Dim dat = DateTime.Now
      output += $"{vbCrLf}It is {dat:t} on {dat:d}. The day of the week is {dat.DayOfWeek}." 
      Console.WriteLine(output)                           
   End Sub
End Module
' The example displays the following output:
'     Balto, Vanya, Dakota, Samuel, Koani, Yiska, Yuma
'     It is 10:29 AM on 1/8/2018. The day of the week is Monday.

Dove è possibile trovare un elenco delle stringhe di formato predefinite che possono essere usate con gli elementi di formato?

Ricerca per categorie l'allineamento delle stringhe di risultato che sostituiscono gli elementi di formato?

La sintassi generale di un elemento di formato è:

{index[,alignment][: formatString]}

dove alignment è un intero con segno che definisce la larghezza del campo. Se questo valore è negativo, il testo nel campo viene allineato a sinistra. Se è positivo, il testo è allineato a destra.

Ricerca per categorie controllare il numero di cifre dopo il separatore decimale?

Tutte le stringhe di formato numerico standard tranne "D" (usato solo con numeri interi), "G", "R" e "X" consentono un identificatore di precisione che definisce il numero di cifre decimali nella stringa di risultato. Nell'esempio seguente vengono utilizzate stringhe di formato numerico standard per controllare il numero di cifre decimali nella stringa di risultato.

object[] values = { 1603, 1794.68235, 15436.14 };
string result;
foreach (var value in values) {
   result = String.Format("{0,12:C2}   {0,12:E3}   {0,12:F4}   {0,12:N3}  {1,12:P2}\n",
                          Convert.ToDouble(value), Convert.ToDouble(value) / 10000);
   Console.WriteLine(result);
}                           
// The example displays output like the following:
//       $1,603.00     1.603E+003      1603.0000      1,603.000       16.03 %
//    
//       $1,794.68     1.795E+003      1794.6824      1,794.682       17.95 %
//    
//      $15,436.14     1.544E+004     15436.1400     15,436.140      154.36 %
Module Example
   Public Sub Main()
      Dim values() As Object = { 1603, 1794.68235, 15436.14 }
      Dim result As String
      For Each value In values
         result = String.Format("{0,12:C2}   {0,12:E3}   {0,12:F4}   {0,12:N3}  {1,12:P2}",
                                value, CDbl(value) / 10000)
         Console.WriteLine(result) 
         Console.WriteLine()
      Next                             
   End Sub
End Module
' The example displays the following output:
'       $1,603.00     1.603E+003      1603.0000      1,603.000       16.03 %
'    
'       $1,794.68     1.795E+003      1794.6824      1,794.682       17.95 %
'    
'      $15,436.14     1.544E+004     15436.1400     15,436.140      154.36 %

Se si usa una stringa di formato numericopersonalizzato, usare l'identificatore di formato "0" per controllare il numero di cifre decimali nella stringa di risultato, come illustrato nell'esempio seguente.

decimal value = 16309.5436m;
string result = String.Format("{0,12:#.00000} {0,12:0,000.00} {0,12:000.00#}", 
                              value);
Console.WriteLine(result);
// The example displays the following output:
//        16309.54360    16,309.54    16309.544
Module Example
   Public Sub Main()
      Dim value As Decimal = 16309.5436d
      Dim result As String = String.Format("{0,12:#.00000} {0,12:0,000.00} {0,12:000.00#}", 
                                           value)
      Console.WriteLine(result)
   End Sub
End Module
' The example displays the following output:
'    16309.54360    16,309.54    16309.544

Ricerca per categorie controllare il numero di cifre integrali?

Per impostazione predefinita, le operazioni di formattazione visualizzano solo cifre integrali non zero. Se si formattano numeri interi, è possibile usare un identificatore di precisione con le stringhe di formato standard "D" e "X" per controllare il numero di cifre.

int value = 1326;
string result = String.Format("{0,10:D6} {0,10:X8}", value);
Console.WriteLine(result);
// The example displays the following output:
//     001326   0000052E
Module Example
   Public Sub Main()
      Dim value As Integer = 1326
      Dim result As String = String.Format("{0,10:D6} {0,10:X8}", value)
      Console.WriteLine(result)
   End Sub
End Module
' The example displays the following output:
'       001326   0000052E

È possibile riempire un numero intero o a virgola mobile con zeri iniziali per produrre una stringa di risultato con un numero specificato di cifre integrali usando l'identificatore di formato numerico personalizzato "0", come illustrato nell'esempio seguente.

int value = 16342;
string result = String.Format("{0,18:00000000} {0,18:00000000.000} {0,18:000,0000,000.0}", 
                              value);
Console.WriteLine(result);
// The example displays the following output:
//           00016342       00016342.000    0,000,016,342.0
Module Example
   Public Sub Main()
      Dim value As Integer = 16342
      Dim result As String = String.Format("{0,18:00000000} {0,18:00000000.000} {0,18:000,0000,000.0}", 
                                           value)
      Console.WriteLine(result)
   End Sub
End Module
' The example displays the following output:
'           00016342       00016342.000    0,000,016,342.0

Quanti elementi è possibile includere nell'elenco dei formati?

Non esiste alcun limite pratico. Il secondo parametro del metodo è contrassegnato con l'attributo , che consente di includere un elenco delimitato o una matrice di oggetti come Format(IFormatProvider, String, Object[]) ParamArrayAttribute elenco di formato.

Ricerca per categorie includere parentesi graffe letterali ("{" e "}") nella stringa di risultato?

Ad esempio, come si impedisce alla chiamata al metodo seguente di generare FormatException un'eccezione?

result = String.Format("The text has {0} '{' characters and {1} '}' characters.",
                       nOpen, nClose);
result = String.Format("The text has {0} '{' characters and {1} '}' characters.",
                       nOpen, nClose)

Una singola parentesi graffa di apertura o chiusura viene sempre interpretata come l'inizio o la fine di un elemento di formato. Per essere interpretato letteralmente, deve essere preceduto da un carattere di escape. Per eseguire l'escape di una parentesi graffa, aggiungere un'altra parentesi graffa ("{{" e "}}" anziché "{" e "}"), come nella chiamata al metodo seguente:

string result;
int nOpen = 1;
int nClose = 2;
result = String.Format("The text has {0} '{{' characters and {1} '}}' characters.",
                       nOpen, nClose);
Console.WriteLine(result);
result = String.Format("The text has {0} '{{' characters and {1} '}}' characters.",
                       nOpen, nClose)

Tuttavia, anche le parentesi graffe precedute da un carattere di escape sono facilmente interpretate in modo erto. È consigliabile includere le parentesi graffe nell'elenco dei formati e usare gli elementi di formato per inserirli nella stringa di risultato, come illustrato nell'esempio seguente.

string result;
int nOpen = 1;
int nClose = 2;
result = String.Format("The text has {0} '{1}' characters and {2} '{3}' characters.",
                       nOpen, "{", nClose, "}");
Console.WriteLine(result);
result = String.Format("The text has {0} '{1}' characters and {2} '{3}' characters.",
                       nOpen, "{", nClose, "}")

Perché la chiamata al metodo String.Format genera un'eccezione FormatException?

La causa più comune dell'eccezione è che l'indice di un elemento di formato non corrisponde a un oggetto nell'elenco di formati. In genere questo indica che gli indici degli elementi di formato sono stati numerati in modo errati o che si è dimenticato di includere un oggetto nell'elenco dei formati. Il tentativo di includere un carattere parentesi graffa sinistra o destra senza caratteri di escape genera anche un'eccezione FormatException . In alcuni casi, l'eccezione è il risultato di un errore di digitazione. Ad esempio, un errore tipico è quello di digitare in modo erto "[" (parentesi quadra aperta) anziché "{" (parentesi graffa sinistra).

Se il metodo Format(System.IFormatProvider,System.String,System.Object[]) supporta le matrici di parametri, perché il codice genera un'eccezione quando si usa una matrice?

Ad esempio, il codice seguente genera FormatException un'eccezione:

Random rnd = new Random();
int[]  numbers = new int[4];
int total = 0;
for (int ctr = 0; ctr <= 2; ctr++) {
   int number = rnd.Next(1001);
   numbers[ctr] = number;
   total += number;
}   
numbers[3] = total;
Console.WriteLine("{0} + {1} + {2} = {3}", numbers);
Imports System.Collections.Generic

Module Example
   Public Sub Main()
      Dim rnd As New Random()
      Dim numbers(3) As Integer
      Dim total As Integer = 0
      For ctr = 0 To 2
         Dim number As Integer = rnd.Next(1001)
         numbers(ctr) = number
         total += number
      Next
      numbers(3) = total
      Console.WriteLine("{0} + {1} + {2} = {3}", numbers)   
   End Sub
End Module

Si tratta di un problema di risoluzione dell'overload del compilatore. Poiché il compilatore non può convertire una matrice di interi in una matrice di oggetti, considera la matrice di interi come un singolo argomento, quindi chiama il Format(String, Object) metodo . L'eccezione viene generata perché sono presenti quattro elementi di formato, ma solo un singolo elemento nell'elenco di formati.

Poiché né Visual Basic né C# possono convertire una matrice di interi in una matrice di oggetti, è necessario eseguire la conversione manualmente prima di chiamare il Format(String, Object[]) metodo . Nell'esempio seguente viene fornita un'implementazione di .

Random rnd = new Random();
int[]  numbers = new int[4];
int total = 0;
for (int ctr = 0; ctr <= 2; ctr++) {
   int number = rnd.Next(1001);
   numbers[ctr] = number;
   total += number;
}   
numbers[3] = total;
object[] values = new object[numbers.Length];
numbers.CopyTo(values, 0);
Console.WriteLine("{0} + {1} + {2} = {3}", values);
Imports System.Collections.Generic

Module Example
   Public Sub Main()
      Dim rnd As New Random()
      Dim numbers(3) As Integer
      Dim total As Integer = 0
      For ctr = 0 To 2
         Dim number As Integer = rnd.Next(1001)
         numbers(ctr) = number
         total += number
      Next
      numbers(3) = total
      Dim values(numbers.Length - 1) As Object
      numbers.CopyTo(values, 0) 
      Console.WriteLine("{0} + {1} + {2} = {3}", values)   
   End Sub
End Module

Format(String, Object)

Sostituisce uno o più elementi di formato in una stringa con la rappresentazione di stringa di un oggetto specificato.

public:
 static System::String ^ Format(System::String ^ format, System::Object ^ arg0);
public static string Format (string format, object arg0);
public static string Format (string format, object? arg0);
static member Format : string * obj -> string
Public Shared Function Format (format As String, arg0 As Object) As String

Parametri

arg0
Object

Oggetto da formattare.

Restituisce

String

Copia di format in cui qualsiasi elemento di formato viene sostituito dalla rappresentazione di stringa di arg0.

Eccezioni

format è null.

L'elemento di formato in format non è valido.

-oppure-

L'indice di un elemento di formato è diverso da zero.

Commenti

Importante

Anziché chiamare il metodo String.Format o usare stringhe di formato composite, è possibile usare stringhe interpolate se supportate dal linguaggio. Una stringa interpolata è una stringa che contiene espressioni interpolate. Ogni espressione interpolata viene risolta con il valore dell'espressione e inclusa nella stringa di risultato al momento dell'assegnazione della stringa. Per altre informazioni, vedere Interpolazione di stringhe (Riferimenti per C#) e Stringhe interpolate (Riferimenti per Visual Basic).

Questo metodo usa la funzionalità di formattazione composita per convertire il valore di un'espressione nella relativa rappresentazione di stringa e incorporare tale rappresentazione in una stringa.

Quando tuttavia si chiama il metodo String.Format, non è necessario concentrarsi sull'overload specifico che si vuole chiamare. È invece possibile chiamare il metodo con una stringa di formato composta che include uno o più elementi di formato. Si assegna a ogni elemento di formato un indice numerico; il primo indice inizia da 0. Oltre alla stringa iniziale, la chiamata al metodo deve avere tanti argomenti aggiuntivi quanti sono i valori di indice. Ad esempio, una stringa i cui elementi di formato hanno indici pari a 0 e 1 deve avere 2 argomenti; un'altra con indici da 0 a 5 deve avere 6 argomenti. Il compilatore di linguaggio risolverà quindi la chiamata al metodo a un overload specifico del metodo String.Format.

Per la documentazione dettagliata relativa all'uso del metodo String.Format, vedere Getting started with the String.Format method (Introduzione al metodo String.Format) e Which method do I call? (Metodo da chiamare).

Esempio: Formattazione di un singolo argomento

Nell'esempio seguente viene Format(String, Object) utilizzato il metodo per incorporare l'età di un utente al centro di una stringa.

using namespace System;

void main()
{
   DateTime birthdate = DateTime(1993, 7, 28);
   array<DateTime>^ dates = gcnew array<DateTime> { DateTime(1993, 8, 16), 
                                                    DateTime(1994, 7, 28), 
                                                    DateTime(2000, 10, 16), 
                                                    DateTime(2003, 7, 27), 
                                                    DateTime(2007, 5, 27) };

   for each (DateTime dateValue in dates)
   {
      TimeSpan interval = dateValue - birthdate;
      // Get the approximate number of years, without accounting for leap years.
      int years = ((int)interval.TotalDays) / 365;
      // See if adding the number of years exceeds dateValue.
      String^ output;
      if (birthdate.AddYears(years) <= dateValue) {
         output = String::Format("You are now {0} years old.", years);
         Console::WriteLine(output);
      }   
      else {
         output = String::Format("You are now {0} years old.", years - 1);
         Console::WriteLine(output);
      }      
   }
}
// The example displays the following output:
//       You are now 0 years old.
//       You are now 1 years old.
//       You are now 7 years old.
//       You are now 9 years old.
//       You are now 13 years old.
DateTime birthdate = new DateTime(1993, 7, 28);
DateTime[] dates = { new DateTime(1993, 8, 16), 
                     new DateTime(1994, 7, 28), 
                     new DateTime(2000, 10, 16), 
                     new DateTime(2003, 7, 27), 
                     new DateTime(2007, 5, 27) };

foreach (DateTime dateValue in dates)
{
   TimeSpan interval = dateValue - birthdate;
   // Get the approximate number of years, without accounting for leap years.
   int years = ((int) interval.TotalDays) / 365;
   // See if adding the number of years exceeds dateValue.
   string output;
   if (birthdate.AddYears(years) <= dateValue) {
      output = String.Format("You are now {0} years old.", years);
      Console.WriteLine(output);
   }   
   else {
      output = String.Format("You are now {0} years old.", years - 1);
      Console.WriteLine(output);
   }      
}
// The example displays the following output:
//       You are now 0 years old.
//       You are now 1 years old.
//       You are now 7 years old.
//       You are now 9 years old.
//       You are now 13 years old.
Module Example
   Public Sub Main()
      Dim birthdate As Date = #7/28/1993#
      Dim dates() As Date = { #9/16/1993#, #7/28/1994#, #10/16/2000#, _
                              #7/27/2003#, #5/27/2007# }
      For Each dateValue As Date In dates
         Dim interval As TimeSpan = dateValue - birthdate
         ' Get the approximate number of years, without accounting for leap years.
         Dim years As Integer = CInt(interval.TotalDays) \ 365
         ' See if adding the number of years exceeds dateValue.
         Dim output As String
         If birthdate.AddYears(years) <= dateValue Then
            output = String.Format("You are now {0} years old.", years)
            Console.WriteLine(output)
         Else
            output = String.Format("You are now {0} years old.", years - 1)
            Console.WriteLine(output)   
         End If
      Next
   End Sub
End Module
' The example displays the following output:
'       You are now 0 years old.
'       You are now 1 years old.
'       You are now 7 years old.
'       You are now 9 years old.
'       You are now 13 years old.

Vedi anche

Si applica a

Format(String, Object[])

Sostituisce l'elemento di formato presente in una stringa specificata con la rappresentazione di stringa di un oggetto corrispondente in una matrice specificata.

public:
 static System::String ^ Format(System::String ^ format, ... cli::array <System::Object ^> ^ args);
public static string Format (string format, params object[] args);
public static string Format (string format, params object?[] args);
static member Format : string * obj[] -> string
Public Shared Function Format (format As String, ParamArray args As Object()) As String

Parametri

args
Object[]

Matrice di oggetti che contiene zero o più oggetti da formattare.

Restituisce

String

Copia di format in cui gli elementi di formato sono stati sostituiti dalla rappresentazione di stringa degli oggetti corrispondenti in args.

Eccezioni

format o args è null.

format non è valido.

-oppure-

L'indice di un elemento di formato è minore di zero oppure maggiore o uguale alla lunghezza della matrice args.

Commenti

Importante

Anziché chiamare il metodo String.Format o usare stringhe di formato composite, è possibile usare stringhe interpolate se supportate dal linguaggio. Una stringa interpolata è una stringa che contiene espressioni interpolate. Ogni espressione interpolata viene risolta con il valore dell'espressione e inclusa nella stringa di risultato al momento dell'assegnazione della stringa. Per altre informazioni, vedere Interpolazione di stringhe (Riferimenti per C#) e Stringhe interpolate (Riferimenti per Visual Basic).

Questo metodo usa la funzionalità di formattazione composita per convertire il valore di quattro o più espressioni nelle relative rappresentazioni di stringa e incorporare tali rappresentazioni in una stringa. Poiché il args parametro è contrassegnato con l'attributo , è possibile passare gli oggetti al metodo System.ParamArrayAttribute come singoli argomenti o come Object matrice.

Quando tuttavia si chiama il metodo String.Format, non è necessario concentrarsi sull'overload specifico che si vuole chiamare. È invece possibile chiamare il metodo con una stringa di formato composta che include uno o più elementi di formato. Si assegna a ogni elemento di formato un indice numerico; il primo indice inizia da 0. Oltre alla stringa iniziale, la chiamata al metodo deve avere tanti argomenti aggiuntivi quanti sono i valori di indice. Ad esempio, una stringa i cui elementi di formato hanno indici pari a 0 e 1 deve avere 2 argomenti; un'altra con indici da 0 a 5 deve avere 6 argomenti. Il compilatore di linguaggio risolverà quindi la chiamata al metodo a un overload specifico del metodo String.Format.

Per la documentazione dettagliata relativa all'uso del metodo String.Format, vedere Getting started with the String.Format method (Introduzione al metodo String.Format) e Which method do I call? (Metodo da chiamare).

Esempio: Formattare più di tre argomenti

In questo esempio viene creata una stringa che contiene i dati relativi alla temperatura alta e bassa in una determinata data. La stringa di formato composito ha cinque elementi di formato nell'esempio C# e sei nell'esempio Visual Basic esempio. Due elementi di formato definiscono la larghezza della rappresentazione di stringa del valore corrispondente e il primo elemento di formato include anche una stringa di formato di data e ora standard.

using namespace System;

void main()
{
   DateTime date1 = DateTime(2009, 7, 1);
   TimeSpan hiTime = TimeSpan(14, 17, 32);
   Decimal hiTemp = (Decimal) 62.1; 
   TimeSpan loTime = TimeSpan(3, 16, 10);
   Decimal loTemp = (Decimal)54.8; 

   String^ result1 = String::Format("Temperature on {0:d}:\n{1,11}: {2} degrees (hi)\n{3,11}: {4} degrees (lo)", 
                                    date1, hiTime, hiTemp, loTime, loTemp);
   Console::WriteLine(result1);
   Console::WriteLine();
           
   String^ result2 = String::Format("Temperature on {0:d}:\n{1,11}: {2} degrees (hi)\n{3,11}: {4} degrees (lo)", 
                                    gcnew array<Object^> { date1, hiTime, hiTemp, loTime, loTemp });
   Console::WriteLine(result2);
}
// The example displays the following output:
//       Temperature on 7/1/2009:
//          14:17:32: 62.1 degrees (hi)
//          03:16:10: 54.8 degrees (lo)
//       Temperature on 7/1/2009:
//          14:17:32: 62.1 degrees (hi)
//          03:16:10: 54.8 degrees (lo)
DateTime date1 = new DateTime(2009, 7, 1);
TimeSpan hiTime = new TimeSpan(14, 17, 32);
decimal hiTemp = 62.1m; 
TimeSpan loTime = new TimeSpan(3, 16, 10);
decimal loTemp = 54.8m; 

string result1 = String.Format("Temperature on {0:d}:\n{1,11}: {2} degrees (hi)\n{3,11}: {4} degrees (lo)", 
                               date1, hiTime, hiTemp, loTime, loTemp);
Console.WriteLine(result1);
Console.WriteLine();
     
string result2 = String.Format("Temperature on {0:d}:\n{1,11}: {2} degrees (hi)\n{3,11}: {4} degrees (lo)", 
                               new object[] { date1, hiTime, hiTemp, loTime, loTemp });
Console.WriteLine(result2);
// The example displays output like the following:
//       Temperature on 7/1/2009:
//          14:17:32: 62.1 degrees (hi)
//          03:16:10: 54.8 degrees (lo)
//       Temperature on 7/1/2009:
//          14:17:32: 62.1 degrees (hi)
//          03:16:10: 54.8 degrees (lo)
Module Example
   Public Sub Main()
      Dim date1 As Date = #7/1/2009#
      Dim hiTime As New TimeSpan(14, 17, 32)
      Dim hiTemp As Decimal = 62.1d 
      Dim loTime As New TimeSpan(3, 16, 10)
      Dim loTemp As Decimal = 54.8d 

      Dim result1 As String = String.Format("Temperature on {0:d}:{5}{1,11}: {2} degrees (hi){5}{3,11}: {4} degrees (lo)", _
                                           date1, hiTime, hiTemp, loTime, loTemp, vbCrLf)
      Console.WriteLine(result1)
      Console.WriteLine()
           
      Dim result2 As String = String.Format("Temperature on {0:d}:{5}{1,11}: {2} degrees (hi){5}{3,11}: {4} degrees (lo)", _
                                            New Object() { date1, hiTime, hiTemp, loTime, loTemp, vbCrLf })
      Console.WriteLine(result2)                                            
   End Sub
End Module
' The example displays the following output:
'       Temperature on 7/1/2009:
'          14:17:32: 62.1 degrees (hi)
'          03:16:10: 54.8 degrees (lo)
'
'       Temperature on 7/1/2009:
'          14:17:32: 62.1 degrees (hi)
'          03:16:10: 54.8 degrees (lo)

È anche possibile passare gli oggetti da formattare come matrice anziché come elenco di argomenti.

using namespace System;

ref class CityInfo
{
public:
   CityInfo(String^ name, int population, Decimal area, int year)
   {
      this->Name = name;
      this->Population = population;
      this->Area = area;
      this->Year = year;
   }
   
   String^ Name; 
   int Population;
   Decimal Area;
   int Year;
};

ref class Example
{
public:
   static void ShowPopulationData(CityInfo^ city)
   {
      array<Object^>^ args = gcnew array<Object^> { city->Name, city->Year, city->Population, city->Area };
      String^ result = String::Format("{0} in {1}: Population {2:N0}, Area {3:N1} sq. feet", 
                                    args);
      Console::WriteLine(result); 
   }
};

void main()
{
   CityInfo^ nyc2010 = gcnew CityInfo("New York", 8175133, (Decimal) 302.64, 2010);
   Example::ShowPopulationData(nyc2010);
   CityInfo^ sea2010 = gcnew CityInfo("Seattle", 608660, (Decimal) 83.94, 2010);      
   Example::ShowPopulationData(sea2010); 
}
// The example displays the following output:
//       New York in 2010: Population 8,175,133, Area 302.6 sq. feet
//       Seattle in 2010: Population 608,660, Area 83.9 sq. feet
using System;

public class CityInfo
{
   public CityInfo(String name, int population, Decimal area, int year)
   {
      this.Name = name;
      this.Population = population;
      this.Area = area;
      this.Year = year;
   }
   
   public readonly String Name; 
   public readonly int Population;
   public readonly Decimal Area;
   public readonly int Year;
}

public class Example
{
   public static void Main()
   {
      CityInfo nyc2010 = new CityInfo("New York", 8175133, 302.64m, 2010);
      ShowPopulationData(nyc2010);
      CityInfo sea2010 = new CityInfo("Seattle", 608660, 83.94m, 2010);      
      ShowPopulationData(sea2010); 
   }

   private static void ShowPopulationData(CityInfo city)
   {
      object[] args = { city.Name, city.Year, city.Population, city.Area };
      String result = String.Format("{0} in {1}: Population {2:N0}, Area {3:N1} sq. feet", 
                                    args);
      Console.WriteLine(result); 
   }
}
// The example displays the following output:
//       New York in 2010: Population 8,175,133, Area 302.6 sq. feet
//       Seattle in 2010: Population 608,660, Area 83.9 sq. feet
Public Class CityInfo
   Public Sub New(name As String, population As Integer, area As Decimal, year As Integer)
      Me.Name = name
      Me.Population = population
      Me.Area = area
      Me.Year = year
   End Sub
   
   Public ReadOnly Name As String
   Public ReadOnly Population As Integer
   Public ReadOnly Area As Decimal
   Public ReadOnly Year As Integer
End Class

Module Example
   Public Sub Main()
      Dim nyc2010 As New CityInfo("New York", 8175133, 302.64d, 2010)
      ShowPopulationData(nyc2010)
      Dim sea2010 As New CityInfo("Seattle", 608660, 83.94d, 2010)      
      ShowPopulationData(sea2010) 
   End Sub
   
   Private Sub ShowPopulationData(city As CityInfo)
      Dim args() As Object = { city.Name, city.Year, city.Population, city.Area }
      Dim result = String.Format("{0} in {1}: Population {2:N0}, Area {3:N1} sq. feet", args)
      Console.WriteLine(result) 
   End Sub
End Module
' The example displays the following output:
'       New York in 2010: Population 8,175,133, Area 302.6 sq. feet
'       Seattle in 2010: Population 608,660, Area 83.9 sq. feet

Vedi anche

Si applica a

Format(IFormatProvider, String, Object)

Sostituisce uno o più elementi di formato presenti in una stringa specificata con la rappresentazione di stringa dell'oggetto corrispondente. Un parametro fornisce le informazioni di formattazione specifiche delle impostazioni cultura.

public:
 static System::String ^ Format(IFormatProvider ^ provider, System::String ^ format, System::Object ^ arg0);
public static string Format (IFormatProvider provider, string format, object arg0);
public static string Format (IFormatProvider? provider, string format, object? arg0);
static member Format : IFormatProvider * string * obj -> string
Public Shared Function Format (provider As IFormatProvider, format As String, arg0 As Object) As String

Parametri

provider
IFormatProvider

Oggetto che fornisce informazioni di formattazione specifiche delle impostazioni cultura.

arg0
Object

Oggetto da formattare.

Restituisce

String

Copia di format in cui uno o più elementi di formato vengono sostituiti dalla rappresentazione di stringa di arg0.

Eccezioni

format è null.

format non è valido.

-oppure-

L'indice di un elemento di formato è diverso da zero.

Commenti

Importante

Anziché chiamare il metodo String.Format o usare stringhe di formato composite, è possibile usare stringhe interpolate se supportate dal linguaggio. Una stringa interpolata è una stringa che contiene espressioni interpolate. Ogni espressione interpolata viene risolta con il valore dell'espressione e inclusa nella stringa di risultato al momento dell'assegnazione della stringa. Per altre informazioni, vedere Interpolazione di stringhe (Riferimenti per C#) e Stringhe interpolate (Riferimenti per Visual Basic).

Questo metodo usa la funzionalità di formattazione composita per convertire il valore di un'espressione nella relativa rappresentazione di stringa e incorporare tale rappresentazione in una stringa. Durante l'esecuzione della conversione, il metodo utilizza la formattazione con distinzione delle impostazioni cultura o un formattatore personalizzato. Il metodo esegue la conversione nella relativa rappresentazione di stringa chiamando il relativo metodo arg0 ToString(IFormatProvider) o, se l'elemento di formato corrispondente dell'oggetto include una stringa di formato, chiamando il relativo metodo ToString(String,IFormatProvider). Se questi metodi non esistono, chiama il metodo ToString senza parametri dell'oggetto.

Quando tuttavia si chiama il metodo String.Format, non è necessario concentrarsi sull'overload specifico che si vuole chiamare. È invece possibile chiamare il metodo con un oggetto che offre formattazione dipendente dalle impostazioni cultura o personalizzata e una stringa di formato composta che include uno o più elementi di formato. Si assegna a ogni elemento di formato un indice numerico; il primo indice inizia da 0. Oltre alla stringa iniziale, la chiamata al metodo deve avere tanti argomenti aggiuntivi quanti sono i valori di indice. Ad esempio, una stringa i cui elementi di formato hanno indici pari a 0 e 1 deve avere 2 argomenti; un'altra con indici da 0 a 5 deve avere 6 argomenti. Il compilatore di linguaggio risolverà quindi la chiamata al metodo a un overload specifico del metodo String.Format.

Per la documentazione dettagliata relativa all'uso del metodo String.Format, vedere Getting started with the String.Format method (Introduzione al metodo String.Format) e Which method do I call? (Metodo da chiamare).

Si applica a

Format(IFormatProvider, String, Object[])

Sostituisce gli elementi di formato presenti in una stringa con le rappresentazioni di stringa degli oggetti corrispondenti in una matrice specificata. Un parametro fornisce le informazioni di formattazione specifiche delle impostazioni cultura.

public:
 static System::String ^ Format(IFormatProvider ^ provider, System::String ^ format, ... cli::array <System::Object ^> ^ args);
public static string Format (IFormatProvider provider, string format, params object[] args);
public static string Format (IFormatProvider? provider, string format, params object?[] args);
static member Format : IFormatProvider * string * obj[] -> string
Public Shared Function Format (provider As IFormatProvider, format As String, ParamArray args As Object()) As String

Parametri

provider
IFormatProvider

Oggetto che fornisce informazioni di formattazione specifiche delle impostazioni cultura.

args
Object[]

Matrice di oggetti che contiene zero o più oggetti da formattare.

Restituisce

String

Copia di format in cui gli elementi di formato sono stati sostituiti dalla rappresentazione di stringa degli oggetti corrispondenti in args.

Eccezioni

format o args è null.

format non è valido.

-oppure-

L'indice di un elemento di formato è minore di zero oppure maggiore o uguale alla lunghezza della matrice args.

Commenti

Importante

Anziché chiamare il metodo String.Format o usare stringhe di formato composite, è possibile usare stringhe interpolate se supportate dal linguaggio. Una stringa interpolata è una stringa che contiene espressioni interpolate. Ogni espressione interpolata viene risolta con il valore dell'espressione e inclusa nella stringa di risultato al momento dell'assegnazione della stringa. Per altre informazioni, vedere Interpolazione di stringhe (Riferimenti per C#) e Stringhe interpolate (Riferimenti per Visual Basic).

Questo metodo usa la funzionalità di formattazione composita per convertire quattro o più espressioni nelle rispettive rappresentazioni di stringa e incorporare tali rappresentazioni in una stringa. Durante l'esecuzione della conversione, il metodo utilizza la formattazione con distinzione delle impostazioni cultura o un formattatore personalizzato. Il metodo converte ogni argomento nella relativa rappresentazione di stringa chiamando il relativo metodo Object ToString(IFormatProvider) o, se l'elemento di formato corrispondente dell'oggetto include una stringa di formato, chiamando il relativo metodo ToString(String,IFormatProvider). Se questi metodi non esistono, chiama il metodo ToString senza parametri dell'oggetto.

Quando tuttavia si chiama il metodo String.Format, non è necessario concentrarsi sull'overload specifico che si vuole chiamare. È invece possibile chiamare il metodo con un oggetto che offre formattazione dipendente dalle impostazioni cultura o personalizzata e una stringa di formato composta che include uno o più elementi di formato. Si assegna a ogni elemento di formato un indice numerico; il primo indice inizia da 0. Oltre alla stringa iniziale, la chiamata al metodo deve avere tanti argomenti aggiuntivi quanti sono i valori di indice. Ad esempio, una stringa i cui elementi di formato hanno indici pari a 0 e 1 deve avere 2 argomenti; un'altra con indici da 0 a 5 deve avere 6 argomenti. Il compilatore di linguaggio risolverà quindi la chiamata al metodo a un overload specifico del metodo String.Format.

Per la documentazione dettagliata relativa all'uso del metodo String.Format, vedere Getting started with the String.Format method (Introduzione al metodo String.Format) e Which method do I call? (Metodo da chiamare).

Esempio: Formattazione con distinzione delle impostazioni cultura

In questo esempio viene utilizzato il metodo per visualizzare la rappresentazione di stringa di alcuni valori di data e ora e valori Format(IFormatProvider, String, Object[]) numerici usando impostazioni cultura diverse.

string[] cultureNames = { "en-US", "fr-FR", "de-DE", "es-ES" };

DateTime dateToDisplay = new DateTime(2009, 9, 1, 18, 32, 0);
double value = 9164.32;

Console.WriteLine("Culture     Date                                Value\n");
foreach (string cultureName in cultureNames)
{
   System.Globalization.CultureInfo culture = new System.Globalization.CultureInfo(cultureName);
   string output = String.Format(culture, "{0,-11} {1,-35:D} {2:N}", 
                                 culture.Name, dateToDisplay, value);
   Console.WriteLine(output);
}    
// The example displays the following output:
//    Culture     Date                                Value
//    
//    en-US       Tuesday, September 01, 2009         9,164.32
//    fr-FR       mardi 1 septembre 2009              9 164,32
//    de-DE       Dienstag, 1. September 2009         9.164,32
//    es-ES       martes, 01 de septiembre de 2009    9.164,32
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim cultureNames() As String = { "en-US", "fr-FR", "de-DE", "es-ES" }
      
      Dim dateToDisplay As Date = #9/1/2009 6:32PM#
      Dim value As Double = 9164.32

      Console.WriteLine("Culture     Date                                Value")
      Console.WriteLine()      
      For Each cultureName As String In cultureNames
         Dim culture As New CultureInfo(cultureName)
         Dim output As String = String.Format(culture, "{0,-11} {1,-35:D} {2:N}", _
                                              culture.Name, dateToDisplay, value)
         Console.WriteLine(output)
      Next    
   End Sub
End Module
' The example displays the following output:
'       Culture     Date                                Value
'       
'       en-US       Tuesday, September 01, 2009         9,164.32
'       fr-FR       mardi 1 septembre 2009              9 164,32
'       de-DE       Dienstag, 1. September 2009         9.164,32
'       es-ES       martes, 01 de septiembre de 2009    9.164,32

Vedi anche

Si applica a

Format(String, Object, Object)

Sostituisce gli elementi di formato presenti in una stringa con la rappresentazione di stringa di due oggetti specificati.

public:
 static System::String ^ Format(System::String ^ format, System::Object ^ arg0, System::Object ^ arg1);
public static string Format (string format, object arg0, object arg1);
public static string Format (string format, object? arg0, object? arg1);
static member Format : string * obj * obj -> string
Public Shared Function Format (format As String, arg0 As Object, arg1 As Object) As String

Parametri

arg0
Object

Primo oggetto da formattare.

arg1
Object

Secondo oggetto da formattare.

Restituisce

String

Copia di format in cui gli elementi di formato vengono sostituiti dalle rappresentazioni di stringa di arg0 e arg1.

Eccezioni

format è null.

format non è valido.

-oppure-

L'indice di un elemento di formato è diverso da zero o uno.

Commenti

Importante

Anziché chiamare il metodo String.Format o usare stringhe di formato composite, è possibile usare stringhe interpolate se supportate dal linguaggio. Una stringa interpolata è una stringa che contiene espressioni interpolate. Ogni espressione interpolata viene risolta con il valore dell'espressione e inclusa nella stringa di risultato al momento dell'assegnazione della stringa. Per altre informazioni, vedere Interpolazione di stringhe (Riferimenti per C#) e Stringhe interpolate (Riferimenti per Visual Basic).

Questo metodo usa la funzionalità di formattazione composita per convertire il valore di due espressioni nelle relative rappresentazioni di stringa e incorporare tali rappresentazioni in una stringa.

Quando tuttavia si chiama il metodo String.Format, non è necessario concentrarsi sull'overload specifico che si vuole chiamare. È invece possibile chiamare il metodo con una stringa di formato composta che include uno o più elementi di formato. Si assegna a ogni elemento di formato un indice numerico; il primo indice inizia da 0. Oltre alla stringa iniziale, la chiamata al metodo deve avere tanti argomenti aggiuntivi quanti sono i valori di indice. Ad esempio, una stringa i cui elementi di formato hanno indici pari a 0 e 1 deve avere 2 argomenti; un'altra con indici da 0 a 5 deve avere 6 argomenti. Il compilatore di linguaggio risolverà quindi la chiamata al metodo a un overload specifico del metodo String.Format.

Per la documentazione dettagliata relativa all'uso del metodo String.Format, vedere Getting started with the String.Format method (Introduzione al metodo String.Format) e Which method do I call? (Metodo da chiamare).

Esempio: Formattare due argomenti

In questo esempio viene utilizzato Format(String, Object, Object) il metodo per visualizzare i dati relativi a ora e temperatura archiviati in un oggetto Dictionary<TKey,TValue> generico. Si noti che la stringa di formato contiene tre elementi di formato, anche se sono presenti solo due oggetti da formattare. Questo perché il primo oggetto nell'elenco (un valore di data e ora) viene usato da due elementi di formato: il primo elemento di formato visualizza l'ora e il secondo visualizza la data.

using namespace System;
using namespace System::Collections::Generic;

void main()
{
   Dictionary<DateTime, Double>^ temperatureInfo = gcnew Dictionary<DateTime, Double>(); 
   temperatureInfo->Add(DateTime(2010, 6, 1, 14, 0, 0), 87.46);
   temperatureInfo->Add(DateTime(2010, 12, 1, 10, 0, 0), 36.81);
      
   Console::WriteLine("Temperature Information:\n");
   String^ output;   
   for each (KeyValuePair<DateTime, Double>^ item in temperatureInfo)
   {
      output = String::Format("Temperature at {0,8:t} on {0,9:d}: {1,5:N1}�F", 
                              item->Key, item->Value);
      Console::WriteLine(output);
   }
}
// The example displays the following output:
//       Temperature Information:
//       
//       Temperature at  2:00 PM on  6/1/2010:  87.5�F
//       Temperature at 10:00 AM on 12/1/2010:  36.8�F
Dictionary<DateTime, Double> temperatureInfo = new Dictionary<DateTime, Double>(); 
temperatureInfo.Add(new DateTime(2010, 6, 1, 14, 0, 0), 87.46);
temperatureInfo.Add(new DateTime(2010, 12, 1, 10, 0, 0), 36.81);

Console.WriteLine("Temperature Information:\n");
string output;   
foreach (var item in temperatureInfo)
{
   output = String.Format("Temperature at {0,8:t} on {0,9:d}: {1,5:N1}°F", 
                          item.Key, item.Value);
   Console.WriteLine(output);
}
// The example displays output like the following:
//       Temperature Information:
//       
//       Temperature at  2:00 PM on  6/1/2010:  87.5°F
//       Temperature at 10:00 AM on 12/1/2010:  36.8°F
Imports System.Collections.Generic

Module Example
   Public Sub Main()
      Dim temperatureInfo As New Dictionary(Of Date, Double) 
      temperatureInfo.Add(#6/1/2010 2:00PM#, 87.46)
      temperatureInfo.Add(#12/1/2010 10:00AM#, 36.81)
      
      Console.WriteLine("Temperature Information:")
      Console.WriteLine()
      Dim output As String   
      For Each item In temperatureInfo
         output = String.Format("Temperature at {0,8:t} on {0,9:d}: {1,5:N1}°F", _
                                item.Key, item.Value)
         Console.WriteLine(output)
      Next
   End Sub
End Module
' The example displays the following output:
'       Temperature Information:
'       
'       Temperature at  2:00 PM on  6/1/2010:  87.5°F
'       Temperature at 10:00 AM on 12/1/2010:  36.8°F

Vedi anche

Si applica a

Format(IFormatProvider, String, Object, Object)

Sostituisce gli elementi di formato presenti in una stringa con la rappresentazione di stringa di due oggetti specificati. Un parametro fornisce le informazioni di formattazione specifiche delle impostazioni cultura.

public:
 static System::String ^ Format(IFormatProvider ^ provider, System::String ^ format, System::Object ^ arg0, System::Object ^ arg1);
public static string Format (IFormatProvider provider, string format, object arg0, object arg1);
public static string Format (IFormatProvider? provider, string format, object? arg0, object? arg1);
static member Format : IFormatProvider * string * obj * obj -> string
Public Shared Function Format (provider As IFormatProvider, format As String, arg0 As Object, arg1 As Object) As String

Parametri

provider
IFormatProvider

Oggetto che fornisce informazioni di formattazione specifiche delle impostazioni cultura.

arg0
Object

Primo oggetto da formattare.

arg1
Object

Secondo oggetto da formattare.

Restituisce

String

Copia di format in cui gli elementi di formato vengono sostituiti dalle rappresentazioni di stringa di arg0 e arg1.

Eccezioni

format è null.

format non è valido.

-oppure-

L'indice di un elemento di formato è diverso da zero o uno.

Commenti

Importante

Anziché chiamare il metodo String.Format o usare stringhe di formato composite, è possibile usare stringhe interpolate se supportate dal linguaggio. Una stringa interpolata è una stringa che contiene espressioni interpolate. Ogni espressione interpolata viene risolta con il valore dell'espressione e inclusa nella stringa di risultato al momento dell'assegnazione della stringa. Per altre informazioni, vedere Interpolazione di stringhe (Riferimenti per C#) e Stringhe interpolate (Riferimenti per Visual Basic).

Questo metodo usa la funzionalità di formattazione composita per convertire due espressioni nelle rispettive rappresentazioni di stringa e incorporare tali rappresentazioni in una stringa. Durante l'esecuzione della conversione, il metodo utilizza la formattazione con distinzione delle impostazioni cultura o un formattatore personalizzato. Il metodo converte ogni argomento nella relativa rappresentazione di stringa chiamando il relativo metodo Object ToString(IFormatProvider) o, se l'elemento di formato corrispondente dell'oggetto include una stringa di formato, chiamando il relativo metodo ToString(String,IFormatProvider). Se questi metodi non esistono, chiama il metodo ToString senza parametri dell'oggetto.

Quando tuttavia si chiama il metodo String.Format, non è necessario concentrarsi sull'overload specifico che si vuole chiamare. È invece possibile chiamare il metodo con un oggetto che offre formattazione dipendente dalle impostazioni cultura o personalizzata e una stringa di formato composta che include uno o più elementi di formato. Si assegna a ogni elemento di formato un indice numerico; il primo indice inizia da 0. Oltre alla stringa iniziale, la chiamata al metodo deve avere tanti argomenti aggiuntivi quanti sono i valori di indice. Ad esempio, una stringa i cui elementi di formato hanno indici pari a 0 e 1 deve avere 2 argomenti; un'altra con indici da 0 a 5 deve avere 6 argomenti. Il compilatore di linguaggio risolverà quindi la chiamata al metodo a un overload specifico del metodo String.Format.

Per la documentazione dettagliata relativa all'uso del metodo String.Format, vedere Getting started with the String.Format method (Introduzione al metodo String.Format) e Which method do I call? (Metodo da chiamare).

Si applica a

Format(String, Object, Object, Object)

Sostituisce gli elementi di formato in una stringa con le rappresentazioni di stringa di tre oggetti specificati.

public:
 static System::String ^ Format(System::String ^ format, System::Object ^ arg0, System::Object ^ arg1, System::Object ^ arg2);
public static string Format (string format, object arg0, object arg1, object arg2);
public static string Format (string format, object? arg0, object? arg1, object? arg2);
static member Format : string * obj * obj * obj -> string
Public Shared Function Format (format As String, arg0 As Object, arg1 As Object, arg2 As Object) As String

Parametri

arg0
Object

Primo oggetto da formattare.

arg1
Object

Secondo oggetto da formattare.

arg2
Object

Terzo oggetto da formattare.

Restituisce

String

Copia di format in cui gli elementi di formato sono stati sostituiti dalle rappresentazioni di stringa di arg0, arg1 e arg2.

Eccezioni

format è null.

format non è valido.

-oppure-

L'indice di un elemento di formato è minore di zero oppure maggiore di due.

Commenti

Importante

Anziché chiamare il metodo String.Format o usare stringhe di formato composite, è possibile usare stringhe interpolate se supportate dal linguaggio. Una stringa interpolata è una stringa che contiene espressioni interpolate. Ogni espressione interpolata viene risolta con il valore dell'espressione e inclusa nella stringa di risultato al momento dell'assegnazione della stringa. Per altre informazioni, vedere Interpolazione di stringhe (Riferimenti per C#) e Stringhe interpolate (Riferimenti per Visual Basic).

Questo metodo usa la funzionalità di formattazione composita per convertire il valore di tre espressioni nelle relative rappresentazioni di stringa e incorporare tali rappresentazioni in una stringa.

Quando tuttavia si chiama il metodo String.Format, non è necessario concentrarsi sull'overload specifico che si vuole chiamare. È invece possibile chiamare il metodo con una stringa di formato composta che include uno o più elementi di formato. Si assegna a ogni elemento di formato un indice numerico; il primo indice inizia da 0. Oltre alla stringa iniziale, la chiamata al metodo deve avere tanti argomenti aggiuntivi quanti sono i valori di indice. Ad esempio, una stringa i cui elementi di formato hanno indici pari a 0 e 1 deve avere 2 argomenti; un'altra con indici da 0 a 5 deve avere 6 argomenti. Il compilatore di linguaggio risolverà quindi la chiamata al metodo a un overload specifico del metodo String.Format.

Per la documentazione dettagliata relativa all'uso del metodo String.Format, vedere Getting started with the String.Format method (Introduzione al metodo String.Format) e Which method do I call? (Metodo da chiamare).

Esempio: Formattare tre argomenti

In questo esempio viene Format(String, Object, Object, Object) utilizzato il metodo per creare una stringa che illustra il risultato di un'operazione And booleana con due valori interi. Si noti che la stringa di formato include sei elementi di formato, ma il metodo ha solo tre elementi nel relativo elenco di parametri, perché ogni elemento viene formattato in due modi diversi.

using namespace System;

void main()
{
   String^ formatString = "    {0,10} ({0,8:X8})\n" + 
                           "And {1,10} ({1,8:X8})\n" + 
                           "  = {2,10} ({2,8:X8})";
   int value1 = 16932;
   int value2 = 15421;
   String^ result = String::Format(formatString, 
                                   value1, value2, value1 & value2);
   Console::WriteLine(result);
}
// The example displays the following output:
//                16932 (00004224)
//       And      15421 (00003C3D)
//         =         36 (00000024)
string formatString = "    {0,10} ({0,8:X8})\n" + 
                      "And {1,10} ({1,8:X8})\n" + 
                      "  = {2,10} ({2,8:X8})";
int value1 = 16932;
int value2 = 15421;
string result = String.Format(formatString, 
                              value1, value2, value1 & value2);
Console.WriteLine(result);
// The example displays the following output:
//                16932 (00004224)
//       And      15421 (00003C3D)
//         =         36 (00000024)
Public Module Example
   Public Sub Main()
      Dim formatString As String = "    {0,10} ({0,8:X8})" + vbCrLf +  _
                                   "And {1,10} ({1,8:X8})" + vbCrLf + _
                                   "  = {2,10} ({2,8:X8})"
      Dim value1 As Integer = 16932
      Dim value2 As Integer = 15421
      Dim result As String = String.Format(formatString, _
                                           value1, value2, value1 And value2)
      Console.WriteLine(result)                          
   End Sub
End Module
' The example displays the following output:
'                16932 (00004224)
'       And      15421 (00003C3D)
'         =         36 (00000024)

Vedi anche

Si applica a

Format(IFormatProvider, String, Object, Object, Object)

Sostituisce gli elementi di formato in una stringa con le rappresentazioni di stringa di tre oggetti specificati. Un parametro fornisce le informazioni di formattazione specifiche delle impostazioni cultura.

public:
 static System::String ^ Format(IFormatProvider ^ provider, System::String ^ format, System::Object ^ arg0, System::Object ^ arg1, System::Object ^ arg2);
public static string Format (IFormatProvider provider, string format, object arg0, object arg1, object arg2);
public static string Format (IFormatProvider? provider, string format, object? arg0, object? arg1, object? arg2);
static member Format : IFormatProvider * string * obj * obj * obj -> string
Public Shared Function Format (provider As IFormatProvider, format As String, arg0 As Object, arg1 As Object, arg2 As Object) As String

Parametri

provider
IFormatProvider

Oggetto che fornisce informazioni di formattazione specifiche delle impostazioni cultura.

arg0
Object

Primo oggetto da formattare.

arg1
Object

Secondo oggetto da formattare.

arg2
Object

Terzo oggetto da formattare.

Restituisce

String

Copia di format in cui gli elementi di formato sono stati sostituiti dalle rappresentazioni di stringa di arg0, arg1 e arg2.

Eccezioni

format è null.

format non è valido.

-oppure-

L'indice di un elemento di formato è minore di zero oppure maggiore di due.

Commenti

Importante

Anziché chiamare il metodo String.Format o usare stringhe di formato composite, è possibile usare stringhe interpolate se supportate dal linguaggio. Una stringa interpolata è una stringa che contiene espressioni interpolate. Ogni espressione interpolata viene risolta con il valore dell'espressione e inclusa nella stringa di risultato al momento dell'assegnazione della stringa. Per altre informazioni, vedere Interpolazione di stringhe (Riferimenti per C#) e Stringhe interpolate (Riferimenti per Visual Basic).

Questo metodo usa la funzionalità di formattazione composita per convertire tre espressioni nelle rispettive rappresentazioni di stringa e incorporare tali rappresentazioni in una stringa. Durante l'esecuzione della conversione, il metodo utilizza la formattazione con distinzione delle impostazioni cultura o un formattatore personalizzato. Il metodo converte ogni argomento nella relativa rappresentazione di stringa chiamando il relativo metodo Object ToString(IFormatProvider) o, se l'elemento di formato corrispondente dell'oggetto include una stringa di formato, chiamando il relativo metodo ToString(String,IFormatProvider). Se questi metodi non esistono, chiama il metodo ToString senza parametri dell'oggetto.

Quando tuttavia si chiama il metodo String.Format, non è necessario concentrarsi sull'overload specifico che si vuole chiamare. È invece possibile chiamare il metodo con un oggetto che offre formattazione dipendente dalle impostazioni cultura o personalizzata e una stringa di formato composta che include uno o più elementi di formato. Si assegna a ogni elemento di formato un indice numerico; il primo indice inizia da 0. Oltre alla stringa iniziale, la chiamata al metodo deve avere tanti argomenti aggiuntivi quanti sono i valori di indice. Ad esempio, una stringa i cui elementi di formato hanno indici pari a 0 e 1 deve avere 2 argomenti; un'altra con indici da 0 a 5 deve avere 6 argomenti. Il compilatore di linguaggio risolverà quindi la chiamata al metodo a un overload specifico del metodo String.Format.

Per la documentazione dettagliata relativa all'uso del metodo String.Format, vedere Getting started with the String.Format method (Introduzione al metodo String.Format) e Which method do I call? (Metodo da chiamare).

Si applica a