Questo articolo è stato tradotto automaticamente. Per visualizzare l'articolo in inglese, selezionare la casella di controllo Inglese. È possibile anche visualizzare il testo inglese in una finestra popup posizionando il puntatore del mouse sopra il testo.
Traduzione
Inglese

Metodo String.Format

 

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

Se si ha familiarità con la String.Format metodo, vedere ilIntroduzione al metodo String. Format sezione per una rapida panoramica.

Vedere il osservazioni sezione per la documentazione completa per tutti i String.Format overload.

Spazio dei nomi:   System
Assembly:  mscorlib (in mscorlib.dll)

NomeDescrizione
System_CAPS_pubmethodSystem_CAPS_staticFormat(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.

System_CAPS_pubmethodSystem_CAPS_staticFormat(IFormatProvider, String, Object, Object)

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

System_CAPS_pubmethodSystem_CAPS_staticFormat(IFormatProvider, String, Object, Object, Object)

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

System_CAPS_pubmethodSystem_CAPS_staticFormat(IFormatProvider, String, Object[])

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

System_CAPS_pubmethodSystem_CAPS_staticFormat(String, Object)

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

System_CAPS_pubmethodSystem_CAPS_staticFormat(String, Object, Object)

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

System_CAPS_pubmethodSystem_CAPS_staticFormat(String, Object, Object, Object)

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

System_CAPS_pubmethodSystem_CAPS_staticFormat(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.

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

Decimal pricePerOunce = 17.36m;
String s = String.Format("The current price is {0} per ounce.",
                         pricePerOunce);
// Result: The current price is 17.36 per ounce.

Ed è possibile controllare la formattazione di tale valore:

Decimal pricePerOunce = 17.36m;
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.

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

Inserimento di una stringa

String.Formatinizia con una stringa di formato, seguita da uno o più oggetti o le espressioni che verranno convertite in stringhe e inserite in una posizione specificata nella stringa di formato. Ad esempio:

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

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

Ecco un altro esempio che utilizza 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.'

È possibile avere un numero di elementi di formato e il numero di oggetti nell'elenco di oggetti di come si desidera, purché l'indice di ogni elemento di formato è un oggetto corrispondente nell'elenco di oggetti. Inoltre, non è necessario sulla quale eseguire l'overload si chiama; il compilatore verrà selezionato quello più appropriato.

Il controllo della formattazione

È possibile seguire l'indice in un elemento di formato con una stringa di formato per controllare la formattazione dell'oggetto. Ad esempio, {0:d} si applica la stringa di formato "d" per il 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'

Un numero di supporto di tipi di formato di stringhe, inclusi tutti i tipi numerici (entrambi standard e personalizzato stringhe di formato), tutte le date e ore (entrambi standard e personalizzato stringhe di formato) e intervalli di tempo (entrambi standard e personalizzato stringhe di formato), tutti i tipi di enumerazione i tipi di enumerazione, e GUIDs. È anche possibile aggiungere supporto per le stringhe di formato per i tipi.

Controllare la spaziatura

È possibile definire la larghezza della stringa inserita nella stringa di risultato tramite, ad esempio sintassi {0,12}, che inserisce una stringa di 12 caratteri. La rappresentazione di stringa del primo oggetto in questo caso, è allineato a destra del campo di 12 caratteri. (Se la rappresentazione di stringa del primo oggetto è più di 12 caratteri, tuttavia, la larghezza preferita del campo 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 "Anno" e alcune stringhe di anno, nonché un campo di 15 caratteri per contenere la stringa "Popolazione" e alcuni dati della popolazione. Si noti che i caratteri sono allineati a destra del campo.

int[] years = { 2013, 2014, 2015 };
int[] population = { 1025632, 1105967, 1148203 };
String s = String.Format("{0,6} {1,15}\n\n", "Year", "Population");
for(int index = 0; index < years.Length; index++)
   s += String.Format("{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
Controllo dell'allineamento

Per impostazione predefinita, le stringhe sono allineati a destra nel loro campo se si specifica una larghezza di campo. Per allineare le stringhe in un campo a sinistra, fare precedere la larghezza del campo con un segno negativo, ad esempio {0,-12} per definire un campo allineato a destra di 12 caratteri.

Nell'esempio seguente è simile a quello precedente, ad eccezione del fatto che Allinea a sinistra delle etichette e i dati.

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]);
// Result:
//    Year       Population
//
//    2013       1,025,632
//    2014       1,105,967
//    2015       1,148,203

String.Formatutilizza la funzionalità di formattazione composta. Per altre informazioni, vedere Formattazione composita.

Per informazioni aggiuntive sulla scelta di un overload, vedere quale metodo chiamato?

String String.Format(String format, Object arg0)

Sostituisce gli elementi di formato con la rappresentazione di stringa di un oggetto specificato (esempio).

String String.Format(String format, Object arg0, Object arg1)

Sostituisce gli elementi di formato con la rappresentazione di stringa di due oggetti specificati (esempio).

String String.Format(String format, Object arg0, Object arg1, Object arg2)

Sostituisce gli elementi di formato con la rappresentazione di stringa di tre oggetti specificati (esempio).

String String.Format(String format, params Object[] args)

Sostituisce gli elementi di formato con le rappresentazioni di stringa degli oggetti corrispondenti in una matrice specificata (esempio).

String String.Format(IFormatProvider provider, String format, params Object[] args)

Sostituisce gli elementi di formato con la rappresentazione di stringa degli oggetti corrispondenti in una matrice specificata e Usa le informazioni di formattazione specifiche delle impostazioni cultura (esempio) o le informazioni di formattazione personalizzata (esempio).

Si tratta di un elenco completo dei parametri per il Format metodo, vedere la sintassi di overload in precedenza per i parametri utilizzati da ogni overload. Solo la format parametro viene utilizzato da tutti gli overload.

Parametro

Tipo

Descrizione

format

String

Stringa che include uno o più elementi di formato in formato composito (vedere l'elemento di formato).

arg0

String

Il primo o un solo oggetto da formattare.

arg1

String

Secondo oggetto da formattare.

arg2

String

Terzo oggetto da formattare.

args

String[]

Zero o più oggetti da formattare, fornito in un elenco delimitato da virgole o come una matrice.

provider

IFormatProvider

Oggetto che fornisce informazioni di formattazione personalizzate o impostazioni cultura specifiche.

Tipo: String
una copia di format in cui gli elementi di formato sono stati sostituiti dalle rappresentazioni di stringa di argomenti corrispondenti.

Exception

Condizione

Generata dal

ArgumentNullException

format è null.

Tutti gli overload.

FormatException

format non è valido.

-oppure-

L'indice di un elemento di formato è minore di zero oppure maggiore o uguale al numero di argomenti nell'elenco degli argomenti.

Tutti gli overload.

A

Chiamata

Formattare uno o più oggetti utilizzando le convenzioni delle impostazioni cultura correnti.

Ad eccezione di overload che includono un provider parametro, il rimanenteFormat overload includono un String parametro seguita da uno o più parametri di oggetto. Per questo motivo, non è necessario determinare quale Format overload si intende chiamare. Il compilatore di linguaggio selezionerà l'overload appropriato tra gli overload che non hanno un provider parametro, in base all'elenco di argomenti. Ad esempio, se all'elenco di argomenti dispone di cinque argomenti, il compilatore chiama il Format(String, Object[]) metodo.

Formattare uno o più oggetti utilizzando le convenzioni delle impostazioni cultura specifiche.

OgniFormatoverload che inizia con un provider parametro è seguito da un String parametro e uno o più parametri dell'oggetto. Per questo motivo, non è necessario determinare quali specifiche Format overload si intende chiamare. Il compilatore di linguaggio selezionerà l'overload appropriato tra gli overload che hanno un provider parametro, in base all'elenco di argomenti. Ad esempio, se all'elenco di argomenti dispone di cinque argomenti, il compilatore chiama il Format(IFormatProvider, String, Object[]) metodo.

Eseguire un'operazione di formattazione personalizzata con un ICustomFormatter implementazione o IFormattable implementazione.

Uno dei quattro overload con un provider parametro. compilatore selezionerà l'overload appropriato tra gli overload che hanno un provider parametro, in base all'elenco di argomenti.

Ogni overload del Format metodo utilizza il funzionalità di formattazione composta da includere in base zero segnaposto indicizzati, denominati elementi di formato, in una stringa di formato composita. 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 alla Format(String, Object, Object, Object) metodo include una stringa di formato con formato tre voci, {0}, \\{1 \\} e {2} e un elenco di argomenti con tre elementi.

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 the following output:
//    At 1/17/2012 9:30:00 AM in Chicago, the temperature was -16 degrees.   

Un elemento di formato presenta questa sintassi:


{
index[,alignment][ :formatString] }

Le parentesi quadre indicano elementi facoltativi. L'apertura e parentesi graffe di chiusura sono necessarie. (Per includere un valore letterale di apertura o parentesi graffa chiusa nella stringa di formato, vedere la sezione "Caratteri di escape delle parentesi graffe" il Formattazione composita articolo.)

Ad esempio, un elemento di formato in formato che potrebbe essere un valore di valuta apparirà simile al seguente:

String.Format("{0,-10:C}", 126347.89m);         

Un elemento di formato include gli elementi seguenti:

indice

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

allineamento

Parametro 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 allineato a sinistra (un numero intero negativo). Se si omette allineamento, la rappresentazione di stringa dell'argomento corrispondente viene inserita in un campo senza spazi iniziali o finali.

Se il valore di allineamento è minore della lunghezza dell'argomento deve essere inserito allineamento viene ignorato e la lunghezza della rappresentazione di stringa dell'argomento viene utilizzata come la larghezza del campo.

formatString

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

Tuttavia, si noti che è possibile implementare qualsiasi tipo personalizzato IFormattable o estendere un tipo esistente IFormattable implementazione.

L'esempio seguente usa il alignment e formatString argomenti per produrre l'output formattato.

using System;

public class Example
{
   public static void Main()
   {
      // 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
      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;      
      foreach (var 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 %

Elementi di formato vengono elaborati in sequenza dall'inizio della stringa. Ogni elemento di formato include un indice che corrisponde a un oggetto nell'elenco di argomenti del metodo. il Format recupera l'argomento di metodo e deriva relativa rappresentazione di stringa, come indicato di seguito:

Per un esempio che intercetta le chiamate al ICustomFormatter.Format metodo e consente di visualizzare le informazioni di Format metodo passa a un metodo di formattazione per ogni elemento di formato in una stringa di formato composita, vedere esempio 7: un provider intercetta e formattatore romano.

Il Format metodo genera un FormatException eccezione se l'indice di un elemento di indice è maggiore o uguale al numero di argomenti nell'elenco di argomenti. Tuttavia, format può includere più elementi di formato che non vi sono argomenti, a condizione che più elementi di formato hanno lo stesso indice. Nella chiamata alla Format(String, Object) nell'esempio seguente, l'elenco di argomenti metodo presenta un solo argomento, ma la stringa di formato include due elementi di formato: uno Visualizza il valore decimale di un numero e l'altro relativo valore esadecimale.

public class Example
{
   public static void Main()
   {
      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

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

La IFormatProvider interfaccia dispone di un singolo membro, GetFormat, che è responsabile di restituire l'oggetto che fornisce informazioni di formattazione. .NET Framework offre tre IFormatProvider implementazioni che forniscono informazioni di formattazione specifiche delle impostazioni cultura:

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

  • DateTimeFormatInfo, che viene utilizzato per la formattazione specifiche delle impostazioni cultura di valori di data e ora. Il relativo GetFormat metodo restituisce se stesso.

  • NumberFormatInfo, che viene utilizzato per la formattazione specifiche delle impostazioni cultura di valori numerici. Il relativo GetFormat proprietà restituisce se stesso.

È inoltre possibile chiamare degli overload del Format metodo che presenta un provider parametro Format(IFormatProvider, String, Object[]) eseguire l'overload per eseguire operazioni di formattazione personalizzate. Ad esempio, è possibile formattare un numero intero come un numero di identificazione o un numero di telefono. Per eseguire la formattazione personalizzata del provider argomento deve implementare entrambe le IFormatProvider e ICustomFormatter interfacce. Quando ilFormat viene passato un ICustomFormatter come implementazione di provider argomento, il Format chiamate al metodo relativo IFormatProvider.GetFormat implementazione e richiede un oggetto di tipo ICustomFormatter. Chiama quindi l'oggetto restituito ICustomFormatter dell'oggetto Format per formattare ogni elemento di formato della stringa composto passato a esso.

Per ulteriori informazioni su come fornire soluzioni di formattazione personalizzate, vedere Procedura: definire e utilizzare provider di formati numerici personalizzati e ICustomFormatter. Per un esempio che converte i numeri interi in formato numeri personalizzati, vedere esempio 6: un'operazione di formattazione personalizzata. Per un esempio che converte i numeri romani byte senza segno, vedere esempio 7: un provider intercetta e formattatore romano.

L'esempio seguente usa il Format(String, Object) metodo per incorporare l'età dei singoli all'interno di una stringa.

using System;

[assembly: CLSCompliant(true)]
public class Example
{
   public static void Main()
   {
      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.

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

using System;
using System.Collections.Generic;

public class Example
{
   public static void Main()
   {
      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 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

Questo esempio viene utilizzato il Format(String, Object, Object, Object) metodo per creare una stringa che illustra il risultato di un valore booleano And operazione con due valori integer. Si noti che la stringa di formato include sei elementi di formato, ma il metodo ha solo tre elementi nell'elenco dei parametri, perché ogni elemento è formattato in due modi diversi.

using System;

public class Example
{
   public static 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)

In questo esempio crea una stringa che contiene i dati sulla temperatura massima e minima in una determinata data. Stringa di formato composita ha cinque elementi di formato di esempio di c# e sei nell'esempio di Visual Basic. Due degli elementi di formato definire la larghezza della rappresentazione di stringa del valore corrispondente e il primo elemento di formato include anche una stringa di formato di ora e data standard.

using System;

public class Example
{
   public static void Main()
   {
      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 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)

È inoltre possibile passare gli oggetti da formattare come una matrice anziché da un elenco di argomenti.

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

Questo esempio viene utilizzato il Format(IFormatProvider, String, Object[]) metodo per visualizzare la rappresentazione di stringa di alcuni valori di data e ora e i valori numerici con varie impostazioni cultura.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      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)
      {
         CultureInfo culture = new 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

Questo esempio definisce un provider di formato che consenta di formattare un valore integer come un numero di conto del cliente in formato x-xxxxx-xx.

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.

In questo esempio definisce un provider di formato personalizzata che implementa la ICustomFormatter e IFormatProvider interfacce per eseguire due operazioni:

  • Visualizza i parametri passati al relativo ICustomFormatter.Format implementazione. Ciò consente di vedere quali parametri il Format(IFormatProvider, String, Object[]) metodo passa per l'implementazione di formattazione personalizzata per ogni oggetto che tenta di formattare. Può essere utile quando si esegue il debug dell'applicazione.

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

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

.NET Framework

Tutti gli overload sono supportati in: 4.5, 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile

Tutti gli overload sono supportati in: 4, 3.5 SP1

Libreria di classi portabile

Solo Format(String, Object[]) e Format(IFormatProvider, String, Object[]) sono supportati

.NET per app di Windows Store

Solo Format(String, Object[]) e Format(IFormatProvider, String, Object[]) sono supportati in Windows 8

La sintassi generale di un elemento di formato è:

{index[,alignment][: formatString]}

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

Tutti stringhe di formato numerico standard ad eccezione di "D" (che viene utilizzato con solo numeri interi), "G", "R" e "X" Consenti un identificatore di precisione che definisce il numero di cifre decimali nella stringa di risultato. L'esempio seguente usa le stringhe di formato numerico standard per controllare il numero di cifre decimali nella stringa di risultato.

using System;

public class Example
{
   public static void Main()
   {
      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 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 utilizza un stringa di formato numerico personalizzata, utilizzare l'identificatore di formato "0" per controllare il numero di cifre decimali nella stringa di risultato, come illustrato nell'esempio seguente.

using System;

public class Example
{
   public static void Main()
   {
      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

Per impostazione predefinita, le operazioni di formattazione vengono visualizzati solo cifre integrali diverso da zero. Se si desidera formattare numeri interi, è possibile utilizzare un identificatore di precisione con "D" e "X" stringhe di formato standard per controllare il numero di cifre.

using System;

public class Example
{
   public static void Main()
   {
      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

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

using System;

public class Example
{
   public static void Main()
   {
      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

Non sono previsti limiti pratici. Il secondo parametro del Format(IFormatProvider, String, Object[]) metodo è contrassegnato con il ParamArrayAttribute attributo, che consente di includere un elenco delimitato da virgole o una matrice di oggetti come elenco formato.

Ad esempio, come si impedisce la seguente chiamata al metodo generi un FormatException eccezione?

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

Un singolo apertura o la parentesi graffa di chiusura viene sempre interpretato come l'inizio o alla fine di un elemento di formato. Per essere interpretato letteralmente, deve essere codificata. Una parentesi graffa di escape mediante l'aggiunta di un'altra parentesi graffa ("{{" e "}}" anziché "{" e "}"), come nella chiamata al metodo seguente:

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

Tuttavia, anche con caratteri di escape delle parentesi graffe sono facilmente interpretate. È consigliabile che comprende parentesi graffe nell'elenco formato e utilizzare gli elementi di formato per inserirli nella stringa di risultato, come illustrato nell'esempio seguente.

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

La causa più comune dell'eccezione è che l'indice di un elemento di formato non corrisponde a un oggetto nell'elenco formato. In genere indica che è stata misnumbered gli indici degli elementi di formato o è stata dimenticata includere un oggetto nell'elenco formato. In alcuni casi, l'eccezione è il risultato di un errore di digitazione; ad esempio, un errore tipico è digitata "[" (la parentesi quadra aperta) invece di "{" (la parentesi graffa sinistra).

Ad esempio, il codice seguente genera un FormatException eccezione:

using System;
using System.Collections.Generic;

public class Example
{
   public static void Main()
   {
      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);   
   }
}

Si tratta di un problema di risoluzione dell'overload del compilatore. Perché non è possibile convertire una matrice di interi a una matrice di oggetti, tratta la matrice di integer come un solo 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 formato.

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

using System;
using System.Collections.Generic;

public class Example
{
   public static void Main()
   {
      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);   
   }
}
Torna all'inizio
Mostra: