String.Format String.Format String.Format String.Format Method

Definizione

Converte il valore degli oggetti in stringhe in base ai formati specificati e le inserisce in un'altra stringa.Converts the value of objects to strings based on the formats specified and inserts them into another string.

Se non si ha familiarità con il metodo String.Format, vedere la sezione Iniziare a utilizzare il metodo String. Format per una rapida panoramica.If you are new to the String.Format method, see the Get started with the String.Format method section for a quick overview.

Vedere la sezione Osservazioni per la documentazione generale per il metodo String.Format.See the Remarks section for general documentation for the String.Format method.

Overload

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

Sostituisce uno o più elementi di formato in una stringa con la rappresentazione di stringa di un oggetto specificato.Replaces one or more format items in a string with the string representation of a specified object.

Format(String, Object[]) Format(String, Object[]) Format(String, Object[]) 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.Replaces the format item in a specified string with the string representation of a corresponding object in a specified array.

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

Sostituisce uno o più elementi di formato presenti in una stringa specificata con la rappresentazione di stringa dell'oggetto corrispondente.Replaces the format item or items in a specified string with the string representation of the corresponding object. Un parametro fornisce le informazioni di formattazione specifiche delle impostazioni cultura.A parameter supplies culture-specific formatting information.

Format(IFormatProvider, String, Object[]) Format(IFormatProvider, String, Object[]) Format(IFormatProvider, String, Object[]) 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.Replaces the format items in a string with the string representations of corresponding objects in a specified array. Un parametro fornisce le informazioni di formattazione specifiche delle impostazioni cultura.A parameter supplies culture-specific formatting information.

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

Sostituisce gli elementi di formato presenti in una stringa con la rappresentazione di stringa di due oggetti specificati.Replaces the format items in a string with the string representation of two specified objects.

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

Sostituisce gli elementi di formato presenti in una stringa con la rappresentazione di stringa di due oggetti specificati.Replaces the format items in a string with the string representation of two specified objects. Un parametro fornisce le informazioni di formattazione specifiche delle impostazioni cultura.A parameter supplies culture-specific formatting information.

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

Sostituisce gli elementi di formato in una stringa con le rappresentazioni di stringa di tre oggetti specificati.Replaces the format items in a string with the string representation of three specified objects.

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

Sostituisce gli elementi di formato in una stringa con le rappresentazioni di stringa di tre oggetti specificati.Replaces the format items in a string with the string representation of three specified objects. Un parametro fornisce le informazioni di formattazione specifiche delle impostazioni cultura.An parameter supplies culture-specific formatting information.

Esempi

Esaminare numerosi esempi che chiamano il Format metodo vengono intercalati tramite i osservazioni sezione di questo articolo.Numerous examples that call the Format method are interspersed through the Remarks section of this article.

Nota

Gli esempi in C# in questo articolo vengono eseguiti nello strumento di esecuzione e playground per codice inline Try.NET.The C# examples in this article run in the Try.NET inline code runner and playground. Selezionare il pulsante Esegui per eseguire un esempio in una finestra interattiva.Select the Run button to run an example in an interactive window. Dopo aver eseguito il codice, è possibile modificarlo ed eseguire il codice modificato selezionando di nuovo Esegui.Once you execute the code, you can modify it and run the modified code by selecting Run again. Il codice modificato viene eseguito nella finestra interattiva o, se la compilazione non riesce, la finestra interattiva visualizza tutti i messaggi di errore del compilatore C#.The modified code either runs in the interactive window or, if compilation fails, the interactive window displays all C# compiler error messages.

È anche possibile scaricare un set completo di String.Format esempi, inclusi una progetto .NET Core 2.0 per Visual c# e un progetto .NET Core 2.0 per Visual Basic, dal dotnet / repository GitHub degli esempi.You can also download a complete set of String.Format examples, which are included a .NET Core 2.0 project for C# and a .NET Core 2.0 project for Visual Basic, from the dotnet/samples GitHub repository.

Di seguito sono indicati alcuni degli esempi inclusi nell'articolo:The following are some of the examples included in the article:

Creare una stringa di formatoCreate a format string

Inserimento di una stringaInserting a string
L'elemento di formatoThe format item
Elementi di formato che hanno lo stesso indiceFormat items that have the same index

Controllare l'output formattatoControl formatted output

Controllare la formattazioneControlling formatting
Controllare la spaziaturaControlling spacing
Controllo dell'allineamentoControlling alignment
Controllo del numero di cifre integraliControlling the number of integral digits
Controllo del numero di cifre dopo il separatore decimaleControlling the number of digits after the decimal separator
Tra parentesi graffe letterale in una stringa di risultatoIncluding literal braces in a result string

Verificare le stringhe di formato distinzione delle impostazioni culturaMake format strings culture-sensitive

Formattazione dipendente dalle impostazioni culturaCulture-sensitive formatting

Personalizzare l'operazione di formattazioneCustomize the formatting operation

Un'operazione di formattazione personalizzataA custom formatting operation
Un provider di intercettazione e il formattatore numerale romanoAn intercept provider and Roman numeral formatter

Commenti

Importante

Anziché chiamare il metodo String.Format o usare stringhe di formato composite, è possibile usare stringhe interpolate se supportate dal linguaggio.Instead of calling the String.Format method or using composite format strings, you can use interpolated strings if your language supports them. Una stringa interpolata è una stringa che contiene espressioni interpolate.An interpolated string is a string that contains interpolated expressions. Ogni espressione interpolata viene risolta con il valore dell'espressione e inclusa nella stringa di risultato al momento dell'assegnazione della stringa.Each interpolated expression is resolved with the expression's value and included in the result string when the string is assigned. Per altre informazioni, vedere Interpolazione di stringhe (Riferimenti per C#) e Stringhe interpolate (Riferimenti per Visual Basic).For more information, see String interpolation (C# Reference) and Interpolated Strings (Visual Basic Reference).

Contenuto della sezione:In this section:

Iniziare con il metodo String. Format Get started with the String.Format method
Quale metodo viene chiamato? Which method do I call?
Il metodo di formato in breve The Format method in brief
L'elemento di formato The Format item
La formattazione di argomenti How arguments are formatted
Elementi di formato che hanno lo stesso indice Format items that have the same index
Formattazione e le impostazioni cultura Formatting and culture
Operazioni di formattazione personalizzata Custom formatting operations
String. Format domande e risposteString.Format Q & A

Iniziare con il metodo String. FormatGet started with the String.Format method

Usare String.Format se è necessario inserire il valore di un oggetto, una variabile o espressione in un'altra stringa.Use String.Format if you need to insert the value of an object, variable, or expression into another string. Ad esempio, è possibile inserire il valore di un Decimal valore in una stringa per visualizzarlo all'utente sotto forma di stringa singolo:For example, you can insert the value of a Decimal value into a string to display it to the user as a single string:

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.

Ed è possibile controllare la formattazione del valore:And you can control that value's formatting:

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 a formattazione, è anche possibile controllare l'allineamento e spaziatura.Besides formatting, you can also control alignment and spacing.

Inserimento di una stringaInserting a string

String.Format inizia 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.String.Format starts with a format string, followed by one or more objects or expressions that will be converted to strings and inserted at a specified place in the format string. Ad esempio:For example:

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.'

Il {0} nel formato di stringa è un elemento di formato.The {0} in the format string is a format item. 0 è l'indice dell'oggetto il cui valore di stringa verrà inserito in tale posizione.0 is the index of the object whose string value will be inserted at that position. (Gli indici iniziano da 0). Se l'oggetto da inserire non è una stringa, relativo ToString viene chiamato per convertire i dati a una prima di inserirlo nella stringa di risultato.(Indexes start at 0.) If the object to be inserted is not a string, its ToString method is called to convert it to one before inserting it in the result string.

Ecco un altro esempio che usa due elementi di formato e due oggetti nell'elenco di oggetti:Here's another example that uses two format items and two objects in the object list:

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 un numero di elementi di formato e il numero di oggetti nell'elenco di oggetti come si desidera, fino a quando l'indice di ogni elemento di formato è un oggetto corrispondente nell'elenco di oggetti.You can have as many format items and as many objects in the object list as you want, as long as the index of every format item has a matching object in the object list. Inoltre non devi preoccuparti sulla quale eseguire l'overload si chiama; il compilatore seleziona quello appropriato per l'utente.You also don't have to worry about which overload you call; the compiler will select the appropriate one for you.

Controllare la formattazioneControlling formatting

È possibile seguire l'indice in un elemento di formato con una stringa di formato per controllare come viene formattato un oggetto.You can follow the index in a format item with a format string to control how an object is formatted. Ad esempio, {0:d} si applica la stringa di formato "d" per il primo oggetto nell'elenco di oggetti.For example, {0:d} applies the "d" format string to the first object in the object list. Di seguito è riportato un esempio con un singolo oggetto e due elementi di formato:Here is an example with a single object and two format items:

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'

Un numero di supporto di tipi di formattare le stringhe, inclusi tutti i tipi numerici (entrambe standard e personalizzati stringhe di formato), tutte le date e ore (entrambi standard epersonalizzati stringhe di formato) e gli intervalli di tempo (entrambi standard e personalizzato stringhe di formato), tutti i tipi di enumerazione i tipi di enumerazione , e GUID.A number of types support format strings, including all numeric types (both standard and custom format strings), all dates and times (both standard and custom format strings) and time intervals (both standard and custom format strings), all enumeration types enumeration types, and GUIDs. È anche possibile aggiungere il supporto per le stringhe di formato per i tipi personalizzati.You can also add support for format strings to your own types.

Controllare la spaziaturaControlling spacing

È possibile definire la larghezza della stringa inserita nella stringa di risultato tramite, ad esempio sintassi {0,12}, che inserisce una stringa di 12 caratteri.You can define the width of the string that is inserted into the result string by using syntax such as {0,12}, which inserts a 12-character string. La rappresentazione di stringa del primo oggetto in questo caso, viene allineato a destra nel campo di 12 caratteri.In this case, the string representation of the first object is right-aligned in the 12-character field. (Se la rappresentazione di stringa del primo oggetto è di più di 12 caratteri, tuttavia, la larghezza preferita del campo viene ignorata e l'intera stringa viene inserita nella stringa di risultato.)(If the string representation of the first object is more than 12 characters in length, though, the preferred field width is ignored, and the entire string is inserted into the result string.)

L'esempio seguente definisce un campo di 6 caratteri per memorizzare la stringa "Year" e alcune stringhe anno, nonché un campo di 15 caratteri per contenere la stringa "Popolamento" e alcuni dati della popolazione.The following example defines a 6-character field to hold the string "Year" and some year strings, as well as an 15-character field to hold the string "Population" and some population data. Si noti che i caratteri sono allineati a destra del campo.Note that the characters are right-aligned in the field.

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
using System;
using System.Text;
 
class Example
{
   public static void Main()
   {
       // <Snippet33>
       int[] years = { 2013, 2014, 2015 };
       int[] population = { 1025632, 1105967, 1148203 };
       var sb = new 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

Controllo dell'allineamentoControlling alignment

Per impostazione predefinita, le stringhe sono allineati a destra nel proprio campo se si specifica una lunghezza di campo.By default, strings are right-aligned within their field if you specify a field width. Per allineare a sinistra le stringhe in un campo, ad esempio si anteporre la larghezza del campo con un segno negativo, {0,-12} per definire un campo allineato a sinistra di 12 caratteri.To left-align strings in a field, you preface the field width with a negative sign, such as {0,-12} to define a 12-character left-aligned field.

Nell'esempio seguente è simile a quello precedente, ad eccezione del fatto che Allinea a sinistra di etichette e dati.The following example is similar to the previous one, except that it left-aligns both labels and data.

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.String.Format makes use of the composite formatting feature. Per altre informazioni, vedere Formattazione composita.For more information, see Composite Formatting.

Quale metodo viene chiamato?Which method do I call?

ATo CallCall
Formattare uno o più oggetti usando le convenzioni delle impostazioni cultura correnti.Format one or more objects by using the conventions of the current culture. Fatta eccezione per gli overload che includono un provider parametro, i rimanenti Format overload includono un String parametro seguita da uno o più parametri dell'oggetto.Except for the overloads that include a provider parameter, the remaining Format overloads include a String parameter followed by one or more object parameters. Per questo motivo, non è necessario determinare quale Format overload si intende chiamare.Because of this, you don't have to determine which Format overload you intend to call. Il compilatore di linguaggio consente di selezionare l'overload appropriato tra gli overload che non hanno un provider parametro, in base all'elenco di argomenti.Your language compiler selects the appropriate overload from among the overloads that don't have a provider parameter, based on your argument list. Ad esempio, se all'elenco di argomenti dispone di cinque argomenti, il compilatore chiama il Format(String, Object[]) (metodo).For example, if your argument list has five arguments, the compiler calls the Format(String, Object[]) method.
Formattare uno o più oggetti usando le convenzioni delle impostazioni cultura specifiche.Format one or more objects by using the conventions of a specific culture. Ciascuna Format overload che inizia con un provider parametro è seguito da un String parametro e uno o più parametri dell'oggetto.Each Format overload that begins with a provider parameter is followed by a String parameter and one or more object parameters. Per questo motivo, non è necessario determinare specifico a cui Format overload si intende chiamare.Because of this, you don't have to determine which specific Format overload you intend to call. Il compilatore di linguaggio consente di selezionare l'overload appropriato tra gli overload che includono un provider parametro, in base all'elenco di argomenti.Your language compiler selects the appropriate overload from among the overloads that have a provider parameter, based on your argument list. Ad esempio, se all'elenco di argomenti dispone di cinque argomenti, il compilatore chiama il Format(IFormatProvider, String, Object[]) (metodo).For example, if your argument list has five arguments, the compiler calls the Format(IFormatProvider, String, Object[]) method.
Eseguire un'operazione di formattazione personalizzata con un ICustomFormatter implementazione o IFormattable implementazione.Perform a custom formatting operation either with an ICustomFormatter implementation or an IFormattable implementation. Uno qualsiasi dei quattro overload con un provider parametro.Any of the four overloads with a provider parameter. Il compilatore consente di selezionare l'overload appropriato tra gli overload che includono un provider parametro, in base all'elenco di argomenti.The compiler selects the appropriate overload from among the overloads that have a provider parameter, based on your argument list.

Il metodo di formato in breveThe Format method in brief

Ogni overload del Format metodo Usa il funzionalità di formattazione composta includere segnaposto indicizzati in base zero, denominati formattare gli elementi, in una stringa di formato composito.Each overload of the Format method uses the composite formatting feature to include zero-based indexed placeholders, called format items, in a composite format string. In fase di esecuzione, ogni elemento di formato viene sostituito con la rappresentazione di stringa dell'argomento corrispondente in un elenco di parametri.At run time, each format item is replaced with the string representation of the corresponding argument in a parameter list. Se il valore dell'argomento null, l'elemento di formato viene sostituito con String.Empty.If the value of the argument is null, the format item is replaced with String.Empty. Ad esempio, la chiamata seguente al Format(String, Object, Object, Object) metodo include una stringa di formato con tre elementi di formato, {0}, {1}, e {2}e un elenco di argomenti con tre elementi.For example, the following call to the Format(String, Object, Object, Object) method includes a format string with three format items, {0}, {1}, and {2}, and an argument list with three items.

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.   

L'elemento di formatoThe format item

Questa sintassi è un elemento di formato:A format item has this syntax:

{index[,alignment][:formatString]}  

Parentesi quadre indicano elementi facoltativi.Brackets denote optional elements. Le parentesi e parentesi graffe di chiusura sono obbligatori.The opening and closing braces are required. (Per includere una valore letterale apertura o chiusura di parentesi graffa nella stringa di formato, vedere la escape delle parentesi graffe sezione il formattazione composita articolo.)(To include a literal opening or closing brace in the format string, see the Escaping Braces section in the Composite Formatting article.)

Ad esempio, un elemento di formato per formattare un valore di valuta potrebbe essere simile al seguente:For example, a format item to format a currency value might appear like this:

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 include gli elementi seguenti:A format item has the following elements:

indexindex
Indice a base zero dell'argomento la cui rappresentazione di stringa deve essere incluso nella posizione specificata nella stringa.The zero-based index of the argument whose string representation is to be included at this position in the string. Se questo argomento è null, una stringa vuota verrà inclusa nella posizione specificata nella stringa.If this argument is null, an empty string will be included at this position in the string.

alignmentalignment
Opzionale.Optional. Un intero con segno che indica la lunghezza totale del campo in cui viene inserito l'argomento e se viene allineato a destra (un numero intero positivo) o allineato a sinistra (un numero intero negativo).A signed integer that indicates the total length of the field into which the argument is inserted and whether it is right-aligned (a positive integer) or left-aligned (a negative integer). Se si omette allineamento, la rappresentazione di stringa dell'argomento corrispondente viene inserita in un campo senza spazi iniziali o finali.If you omit alignment, the string representation of the corresponding argument is inserted in a field with no leading or trailing spaces.

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 usata come larghezza del campo.If the value of alignment is less than the length of the argument to be inserted, alignment is ignored and the length of the string representation of the argument is used as the field width.

formatStringformatString
Opzionale.Optional. Stringa che specifica il formato della stringa di risultato dell'argomento corrispondente.A string that specifies the format of the corresponding argument's result string. Se si omette formatString, l'argomento corrispondente senza parametri del ToString metodo viene chiamato per generare la rappresentazione di stringa.If you omit formatString, the corresponding argument's parameterless ToString method is called to produce its string representation. Se si specifica formatString, l'argomento fa riferimento l'elemento di formato deve implementare il IFormattable interfaccia.If you specify formatString, the argument referenced by the format item must implement the IFormattable interface. I tipi che supportano le stringhe di formato includono:Types that support format strings include:

Si noti tuttavia che è possibile implementare qualsiasi tipo personalizzato IFormattable o estendere un tipo esistente IFormattable implementazione.However, note that any custom type can implement IFormattable or extend an existing type's IFormattable implementation.

L'esempio seguente usa il alignment e formatString argomenti per produrre l'output formattato.The following example uses the alignment and formatString arguments to produce formatted output.

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

La formattazione di argomentiHow arguments are formatted

Gli elementi di formato vengono elaborati in modo sequenziale dall'inizio della stringa.Format items are processed sequentially from the beginning of the string. Ogni elemento di formato include un indice che corrisponde a un oggetto nell'elenco di argomenti del metodo.Each format item has an index that corresponds to an object in the method's argument list. Il Format metodo recupera l'argomento e deriva relativa rappresentazione di stringa come indicato di seguito:The Format method retrieves the argument and derives its string representation as follows:

Per un esempio che intercetta le chiamate per il ICustomFormatter.Format (metodo) e consente di visualizzare le informazioni che il Format metodo passa a un metodo di formattazione per ogni elemento di formato in una stringa di formato composita, vedere esempio: Un provider di intercettazione e il formattatore numerale romano.For an example that intercepts calls to the ICustomFormatter.Format method and allows you to see what information the Format method passes to a formatting method for each format item in a composite format string, see Example: An intercept provider and Roman numeral formatter.

Per altre informazioni, vedere la nell'ordine di elaborazione sezione il formattazione composita articolo.For more information, see the Processing Order section in the Composite Formatting article.

Elementi di formato che hanno lo stesso indiceFormat items that have the same index

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.The Format method throws a FormatException exception if the index of an index item is greater than or equal to the number of arguments in the argument list. Tuttavia, format può includere più elementi di formato, quanti sono presenti argomenti, purché più elementi di formato hanno lo stesso indice.However, format can include more format items than there are arguments, as long as multiple format items have the same index. Nella chiamata al Format(String, Object) metodo nell'esempio seguente, l'elenco di argomenti contiene un solo argomento, ma la stringa di formato include due elementi di formato: uno viene visualizzato il valore decimale di un numero e l'altra consente di visualizzare il relativo valore esadecimale.In the call to the Format(String, Object) method in following example, the argument list has a single argument, but the format string includes two format items: one displays the decimal value of a number, and the other displays its hexadecimal value.

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

Formattazione e le impostazioni culturaFormatting and culture

In generale, gli oggetti nell'elenco di argomenti vengono convertiti nelle rispettive rappresentazioni di stringa usando le convenzioni delle impostazioni cultura correnti, che viene restituito dal CultureInfo.CurrentCulture proprietà.Generally, objects in the argument list are converted to their string representations by using the conventions of the current culture, which is returned by the CultureInfo.CurrentCulture property. È possibile controllare questo comportamento chiamando uno degli overload del Format che include un provider parametro.You can control this behavior by calling one of the overloads of Format that includes a provider parameter. Il provider parametro è un IFormatProvider elaborare implementazione che fornisce informazioni di formattazione specifiche delle impostazioni cultura e personalizzate che consente di moderato la formattazione.The provider parameter is an IFormatProvider implementation that supplies custom and culture-specific formatting information that is used to moderate the formatting process.

Il IFormatProvider interfaccia dispone di un singolo membro, GetFormat, che è responsabile della restituzione dell'oggetto che fornisce informazioni di formattazione.The IFormatProvider interface has a single member, GetFormat, which is responsible for returning the object that provides formatting information. .NET ha tre IFormatProvider implementazioni che forniscono informazioni di formattazione specifiche delle impostazioni cultura:.NET has three IFormatProvider implementations that provide culture-specific formatting:

Operazioni di formattazione personalizzataCustom formatting operations

È inoltre possibile chiamare uno degli overload del Format metodo con un provider parametru typu IFormatProvider per eseguire operazioni di formattazione personalizzate.You can also call the any of the overloads of the Format method that have a provider parameter of type IFormatProvider to perform custom formatting operations. È ad esempio, è stato possibile formattare un integer come un numero di identificazione o un numero di telefono.For example, you could format an integer as an identification number or as a telephone number. Per eseguire la formattazione personalizzata, il provider argomento deve implementare sia il IFormatProvider e ICustomFormatter interfacce.To perform custom formatting, your provider argument must implement both the IFormatProvider and ICustomFormatter interfaces. Quando la Format viene passato un ICustomFormatter implementazione come il provider argomento, il Format chiamate al metodo relativo IFormatProvider.GetFormat implementazione e richiede un oggetto di tipo ICustomFormatter.When the Format method is passed an ICustomFormatter implementation as the provider argument, the Format method calls its IFormatProvider.GetFormat implementation and requests an object of type ICustomFormatter. Chiama quindi l'oggetto restituito ICustomFormatter dell'oggetto Format metodo per formattare ogni elemento di formato della stringa composita passato ad esso.It then calls the returned ICustomFormatter object's Format method to format each format item in the composite string passed to it.

Per altre informazioni su come fornire soluzioni di formattazione personalizzate, vedere come: Definire e usare provider di formato numerico personalizzato e ICustomFormatter.For more information about providing custom formatting solutions, see How to: Define and Use Custom Numeric Format Providers and ICustomFormatter. Per un esempio che converte i numeri interi in numeri formattati personalizzati, vedere esempio: Un'operazione di formattazione personalizzata.For an example that converts integers to formatted custom numbers, see Example: A custom formatting operation. Per un esempio che converte i byte senza segno in numeri romani, vedere esempio: Un provider di intercettazione e il formattatore numerale romano.For an example that converts unsigned bytes to Roman numerals, see Example: An intercept provider and Roman numeral formatter.

Esempio: Un'operazione di formattazione personalizzataExample: A custom formatting operation

Questo esempio definisce un provider di formato che formatta un valore integer come un numero di account dei clienti nel formato x-xxxxx-xx.This example defines a format provider that formats an integer value as a customer account number in the form 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: Un provider di intercettazione e il formattatore numerale romanoExample: An intercept provider and Roman numeral formatter

Questo esempio viene definito un provider di formato personalizzata che implementa il ICustomFormatter e IFormatProvider interfacce eseguire due operazioni:This example defines a custom format provider that implements the ICustomFormatter and IFormatProvider interfaces to do two things:

  • Visualizza i parametri passati al relativo ICustomFormatter.Format implementazione.It displays the parameters passed to its ICustomFormatter.Format implementation. Ciò consente di vedere quali parametri il Format(IFormatProvider, String, Object[]) metodo passa all'implementazione di formattazione personalizzata per ogni oggetto che tenta di formattare.This enables us to see what parameters the Format(IFormatProvider, String, Object[]) method is passing to the custom formatting implementation for each object that it tries to format. Ciò può essere utile quando si esegue il debug dell'applicazione.This can be useful when you're debugging your application.

  • Se l'oggetto da formattare è un valore byte senza segno che deve essere formattato usando la stringa di formato standard "R", il formattatore personalizzato il valore numerico viene formattato come un numerale romano.If the object to be formatted is an unsigned byte value that is to be formatted by using the "R" standard format string, the custom formatter formats the numeric value as a Roman numeral.

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 & AString.Format Q & A

Il motivo per cui è preferibile l'interpolazione di stringhe tramite chiamate al String.Format metodo?Why do you recommend string interpolation over calls to the String.Format method?

Interpolazione di stringhe è:String interpolation is:

  • Più flessibile.More flexible. Può essere utilizzato in qualsiasi stringa senza richiedere una chiamata a un metodo che supporta la formattazione composita.It can be used in any string without requiring a call to a method that supports composite formatting. In caso contrario, è necessario chiamare il Format metodo o un altro metodo che supporta la formattazione composita, ad esempio Console.WriteLine o StringBuilder.AppendFormat.Otherwise, you have to call the Format method or another method that supports composite formatting, such as Console.WriteLine or StringBuilder.AppendFormat.

  • Più leggibile.More readable. Poiché nell'espressione interpolata è presente l'espressione da inserire in una stringa anziché in un elenco di argomenti, le stringhe interpolate sono molto più semplice di codice e di leggere.Because the expression to insert into a string appears in the interpolated expression rather than in a argument list, interpolated strings are far easier to code and to read. A causa delle loro maggiore leggibilità, le stringhe interpolate possono sostituire non solo le chiamate ai metodi di formato composito, ma possono anche essere utilizzati nelle operazioni di concatenazione di stringhe per produrre codice più conciso e chiaro.Because of their greater readability, interpolated strings can replace not only calls to composite format methods, but they can also be used in string concatenation operations to produce more concise, clearer code.

Un confronto tra i seguenti due esempi di codice viene illustrato il superiorità di stringhe interpolate tramite la concatenazione di stringhe e le chiamate ai metodi di formattazione composita.A comparison of the following two code examples illustrates the superiority of interpolated strings over string concatenation and calls to composite formatting methods. L'uso di più operazioni di concatenazione di stringhe nell'esempio seguente produce codice dettagliato e difficile da leggere.The use of multiple string concatenation operations in the following example produces verbose and hard-to-read code.

using System;

public class Example
{
   public static void Main()
   {
      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 delle stringhe interpolate nell'esempio seguente produce codice molto più chiara, concisa rispetto dell'istruzione di concatenazione di stringhe e la chiamata al Format metodo nell'esempio precedente.In contrast, the use of interpolated strings in the following example produce much clearer, more concise code than the string concatenation statement and the call to the Format method in the previous example.

using System;

public class Example
{
   public static void Main()
   {
      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 trovare un elenco delle stringhe di formato predefinito che può essere usato con gli elementi di formato?Where can I find a list of the predefined format strings that can be used with format items?

Come si controlla l'allineamento delle stringhe di risultato che sostituiscono gli elementi di formato?How do I control the alignment of the result strings that replace format items?

La sintassi generale di un elemento di formato è:The general syntax of a format item is:

{index[,alignment][: formatString]}  

in cui allineamento è un intero con segno che definisce la larghezza del campo.where alignment is a signed integer that defines the field width. Se questo valore è negativo, il testo nel campo viene allineato a sinistra.If this value is negative, text in the field is left-aligned. Se è positivo, il testo è allineato a destra.If it is positive, text is right-aligned.

Come si controlla il numero di cifre dopo il separatore decimale?How do I control the number of digits after the decimal separator?

Tutti i stringhe di formato numerico standard ad eccezione di "D" (che viene usato con solo numeri interi), "G", "R" e "X" Consenti a un identificatore di precisione che definisce il numero di cifre decimali nella stringa di risultato.All standard numeric format strings except "D" (which is used with integers only), "G", "R", and "X" allow a precision specifier that defines the number of decimal digits in the result string. L'esempio seguente usa le stringhe di formato numerico standard per controllare il numero di cifre decimali nella stringa di risultato.The following example uses standard numeric format strings to control the number of decimal digits in the result string.

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 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 un' stringa di formato numerico personalizzato, usare l'identificatore di formato "0" per controllare il numero di cifre decimali nella stringa di risultato, come illustrato nell'esempio seguente.If you're using a custom numeric format string, use the "0" format specifier to control the number of decimal digits in the result string, as the following example shows.

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

Come si controlla il numero di cifre integrali?How do I control the number of integral digits?

Per impostazione predefinita, le operazioni di formattazione visualizzano solo cifre integrali diverso da zero.By default, formatting operations only display non-zero integral digits. Se si desidera formattare numeri interi, è possibile usare un identificatore di precisione con "D" e "X" stringhe di formato standard per controllare il numero di cifre.If you are formatting integers, you can use a precision specifier with the "D" and "X" standard format strings to control the number of digits.

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
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 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 il valore "0" identificatore di formato numerico personalizzato, come illustrato nell'esempio seguente.You can pad an integer or floating-point number with leading zeros to produce a result string with a specified number of integral digits by using the "0" custom numeric format specifier, as the following example shows.

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

Il numero di elementi è possibile includere nell'elenco formato?How many items can I include in the format list?

Non sono previsti limiti pratici.There is no practical limit. 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 l'elenco di formato.The second parameter of the Format(IFormatProvider, String, Object[]) method is tagged with the ParamArrayAttribute attribute, which allows you to include either a delimited list or an object array as your format list.

Come includere valori letterali parentesi graffe ("{" e "}") nella stringa di risultato?How do I include literal braces ("{" and "}") in the result string?

Ad esempio, come si impedisce la seguente chiamata al metodo generi un FormatException eccezione?For example, how do you prevent the following method call from throwing a FormatException exception?

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 apertura o la parentesi graffa di chiusura viene sempre interpretato come l'inizio o alla fine di un elemento di formato.A single opening or closing brace is always interpreted as the beginning or end of a format item. Per essere interpretato letteralmente, deve essere codificata.To be interpreted literally, it must be escaped. Una graffa mediante l'aggiunta di un'altra parentesi graffa ("{{" e "}}" invece di "{" e "}"), come nella chiamata al metodo seguente:You escape a brace by adding another brace ("{{" and "}}" instead of "{" and "}"), as in the following method call:

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 con caratteri di escape delle parentesi graffe sono facilmente interpretate.However, even escaped braces are easily misinterpreted. È consigliabile includere le parentesi graffe nell'elenco di formato e usare elementi di formato per inserirli nella stringa di risultato, come illustrato nell'esempio seguente.We recommend that you include braces in the format list and use format items to insert them in the result string, as the following example shows.

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, "}")

Il motivo per cui la chiamata al metodo String. Format viene generata un'eccezione FormatException?Why does my call to the String.Format method throw a FormatException?

La causa più comune dell'eccezione è che l'indice di un elemento di formato non corrisponde a un oggetto nell'elenco formato.The most common cause of the exception is that the index of a format item doesn't correspond to an object in the format list. In genere indica che è stata misnumbered gli indici degli elementi di formato o ha dimenticato di includere un oggetto nell'elenco di formato.Usually this indicates that you've misnumbered the indexes of format items or you've forgotten to include an object in the format list. Tenta di includere una parentesi graffa sinistra o destra senza caratteri di escape di caratteri genera anche un FormatException.Attempting to include an unescaped left or right brace character also throws a FormatException. 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).Occasionally, the exception is the result of a typo; for example, a typical mistake is to mistype "[" (the left bracket) instead of "{" (the left brace).

Se il metodo Format(System.IFormatProvider,System.String,System.Object[]) supporta matrici di parametri, perché il mio codice genera un'eccezione quando si usa una matrice?If the Format(System.IFormatProvider,System.String,System.Object[]) method supports parameter arrays, why does my code throw an exception when I use an array?

Ad esempio, il codice seguente genera un FormatException eccezione:For example, the following code throws a FormatException exception:

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);   
   }
}
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.This is a problem of compiler overload resolution. Poiché il compilatore non è possibile convertire una matrice di integer in una matrice di oggetti, considera la matrice di integer come un solo argomento, in modo che chiama il Format(String, Object) (metodo).Because the compiler cannot convert an array of integers to an object array, it treats the integer array as a single argument, so it calls the Format(String, Object) method. Poiché sono presenti quattro elementi di formato, ma solo un singolo elemento nell'elenco formato, viene generata l'eccezione.The exception is thrown because there are four format items but only a single item in the format list.

Poiché Visual Basic né c# può convertire una matrice di interi in una matrice di oggetti, è necessario eseguire la conversione prima di chiamare il Format(String, Object[]) (metodo).Because neither Visual Basic nor C# can convert an integer array to an object array, you have to perform the conversion yourself before calling the Format(String, Object[]) method. Nell'esempio seguente fornisce un'implementazione.The following example provides one implementation.

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);   
   }
}
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) Format(String, Object) Format(String, Object) Format(String, Object)

Sostituisce uno o più elementi di formato in una stringa con la rappresentazione di stringa di un oggetto specificato.Replaces one or more format items in a string with the string representation of a specified object.

public:
 static System::String ^ Format(System::String ^ format, System::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 Object Object Object

Oggetto da formattare.The object to format.

Restituisce

Copia di format in cui qualsiasi elemento di formato viene sostituito dalla rappresentazione di stringa di arg0.A copy of format in which any format items are replaced by the string representation of arg0.

Eccezioni

L'elemento di formato in format non è valido.The format item in format is invalid.

In alternativa-or- L'indice di un elemento di formato è diverso da zero.The index of a format item is not zero.

Commenti

Importante

Anziché chiamare il metodo String.Format o usare stringhe di formato composite, è possibile usare stringhe interpolate se supportate dal linguaggio.Instead of calling the String.Format method or using composite format strings, you can use interpolated strings if your language supports them. Una stringa interpolata è una stringa che contiene espressioni interpolate.An interpolated string is a string that contains interpolated expressions. Ogni espressione interpolata viene risolta con il valore dell'espressione e inclusa nella stringa di risultato al momento dell'assegnazione della stringa.Each interpolated expression is resolved with the expression's value and included in the result string when the string is assigned. Per altre informazioni, vedere Interpolazione di stringhe (Riferimenti per C#) e Stringhe interpolate (Riferimenti per Visual Basic).For more information, see String interpolation (C# Reference) and Interpolated Strings (Visual Basic Reference).

Questo metodo Usa il funzionalità di formattazione composita per convertire il valore di un'espressione nella relativa rappresentazione di stringa e incorporare la rappresentazione in una stringa.This method uses the composite formatting feature to convert the value of an expression to its string representation and to embed that representation in a string.

Quando tuttavia si chiama il metodo String.Format, non è necessario concentrarsi sull'overload specifico che si vuole chiamare.However, when calling the String.Format method, it is not necessary to focus on the particular overload that you want to call. È invece possibile chiamare il metodo con una stringa di formato composta che include uno o più elementi di formato.Instead, you can call the method with a composite format string that includes one or more format items. Si assegna a ogni elemento di formato un indice numerico; il primo indice inizia da 0.You assign each format item a numeric index; the first index starts at 0. Oltre alla stringa iniziale, la chiamata al metodo deve avere tanti argomenti aggiuntivi quanti sono i valori di indice.In addition to the initial string, your method call should have as many additional arguments as it has index values. 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.For example, a string whose format items have indexes of 0 and 1 should have 2 arguments; one with indexes 0 through 5 should have 6 arguments. Il compilatore di linguaggio risolverà quindi la chiamata al metodo a un overload specifico del metodo String.Format.Your language compiler will then resolve your method call to a particular overload of the String.Format method.

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).For more detailed documentation on using the String.Format method, see Getting started with the String.Format method and Which method do I call?.

Esempio: Formattazione di un singolo argomentoExample: Formatting a single argument

L'esempio seguente usa il Format(String, Object) metodo per incorporare l'età di un individuo a metà di una stringa.The following example uses the Format(String, Object) method to embed an individual's age in the middle of a string.

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.
using System;

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

Format(String, Object[]) Format(String, Object[]) Format(String, Object[]) 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.Replaces the format item in a specified string with the string representation of a corresponding object in a specified array.

public:
 static System::String ^ Format(System::String ^ format, ... cli::array <System::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.An object array that contains zero or more objects to format.

Restituisce

Copia di format in cui gli elementi di formato sono stati sostituiti dalla rappresentazione di stringa degli oggetti corrispondenti in args.A copy of format in which the format items have been replaced by the string representation of the corresponding objects in args.

Eccezioni

format non è valido.format is invalid.

In alternativa-or- L'indice di un elemento di formato è minore di zero oppure maggiore o uguale alla lunghezza della matrice args.The index of a format item is less than zero, or greater than or equal to the length of the args array.

Commenti

Importante

Anziché chiamare il metodo String.Format o usare stringhe di formato composite, è possibile usare stringhe interpolate se supportate dal linguaggio.Instead of calling the String.Format method or using composite format strings, you can use interpolated strings if your language supports them. Una stringa interpolata è una stringa che contiene espressioni interpolate.An interpolated string is a string that contains interpolated expressions. Ogni espressione interpolata viene risolta con il valore dell'espressione e inclusa nella stringa di risultato al momento dell'assegnazione della stringa.Each interpolated expression is resolved with the expression's value and included in the result string when the string is assigned. Per altre informazioni, vedere Interpolazione di stringhe (Riferimenti per C#) e Stringhe interpolate (Riferimenti per Visual Basic).For more information, see String interpolation (C# Reference) and Interpolated Strings (Visual Basic Reference).

Questo metodo Usa il funzionalità di formattazione composita per convertire il valore di quattro o più espressioni per le rappresentazioni di stringa e incorporare tali rappresentazioni in una stringa.This method uses the composite formatting feature to convert the value of four or more expressions to their string representations and to embed those representations in a string. Poiché il args parametro è contrassegnato con il System.ParamArrayAttribute attributo, è possibile passare gli oggetti al metodo come singoli argomenti o come un Object matrice.Since the args parameter is marked with the System.ParamArrayAttribute attribute, you can pass the objects to the method as individual arguments or as an Object array.

Quando tuttavia si chiama il metodo String.Format, non è necessario concentrarsi sull'overload specifico che si vuole chiamare.However, when calling the String.Format method, it is not necessary to focus on the particular overload that you want to call. È invece possibile chiamare il metodo con una stringa di formato composta che include uno o più elementi di formato.Instead, you can call the method with a composite format string that includes one or more format items. Si assegna a ogni elemento di formato un indice numerico; il primo indice inizia da 0.You assign each format item a numeric index; the first index starts at 0. Oltre alla stringa iniziale, la chiamata al metodo deve avere tanti argomenti aggiuntivi quanti sono i valori di indice.In addition to the initial string, your method call should have as many additional arguments as it has index values. 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.For example, a string whose format items have indexes of 0 and 1 should have 2 arguments; one with indexes 0 through 5 should have 6 arguments. Il compilatore di linguaggio risolverà quindi la chiamata al metodo a un overload specifico del metodo String.Format.Your language compiler will then resolve your method call to a particular overload of the String.Format method.

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).For more detailed documentation on using the String.Format method, see Getting started with the String.Format method and Which method do I call?.

Esempio: Formattazione di più di tre argomentiExample: Formatting more than three arguments

In questo esempio crea una stringa che contiene i dati sulla temperatura minimo e massimo in una data specifica.This example creates a string that contains data on the high and low temperature on a particular date. La stringa di formato composito ha cinque elementi di formato nell'esempio c# e sei nell'esempio Visual Basic.The composite format string has five format items in the C# example and six in the Visual Basic example. Due degli elementi di formato definire la larghezza della rappresentazione di stringa del relativo valore corrispondente e il primo elemento di formato include anche una stringa di formato di ora e data standard.Two of the format items define the width of their corresponding value's string representation, and the first format item also includes a standard date and time format string.

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)
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 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 una matrice anziché come un elenco di argomenti.You can also pass the objects to be formatted as an array rather than as an argument list.

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

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

Sostituisce uno o più elementi di formato presenti in una stringa specificata con la rappresentazione di stringa dell'oggetto corrispondente.Replaces the format item or items in a specified string with the string representation of the corresponding object. Un parametro fornisce le informazioni di formattazione specifiche delle impostazioni cultura.A parameter supplies culture-specific formatting information.

public:
 static System::String ^ Format(IFormatProvider ^ provider, System::String ^ format, System::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 IFormatProvider IFormatProvider IFormatProvider

Oggetto che fornisce informazioni di formattazione specifiche delle impostazioni cultura.An object that supplies culture-specific formatting information.

arg0
Object Object Object Object

Oggetto da formattare.The object to format.

Restituisce

Copia di format in cui uno o più elementi di formato vengono sostituiti dalla rappresentazione di stringa di arg0.A copy of format in which the format item or items have been replaced by the string representation of arg0.

Eccezioni

format non è valido.format is invalid.

In alternativa-or- L'indice di un elemento di formato è diverso da zero.The index of a format item is not zero.

Commenti

Importante

Anziché chiamare il metodo String.Format o usare stringhe di formato composite, è possibile usare stringhe interpolate se supportate dal linguaggio.Instead of calling the String.Format method or using composite format strings, you can use interpolated strings if your language supports them. Una stringa interpolata è una stringa che contiene espressioni interpolate.An interpolated string is a string that contains interpolated expressions. Ogni espressione interpolata viene risolta con il valore dell'espressione e inclusa nella stringa di risultato al momento dell'assegnazione della stringa.Each interpolated expression is resolved with the expression's value and included in the result string when the string is assigned. Per altre informazioni, vedere Interpolazione di stringhe (Riferimenti per C#) e Stringhe interpolate (Riferimenti per Visual Basic).For more information, see String interpolation (C# Reference) and Interpolated Strings (Visual Basic Reference).

Questo metodo Usa il funzionalità di formattazione composita per convertire il valore di un'espressione nella relativa rappresentazione di stringa e incorporare la rappresentazione in una stringa.This method uses the composite formatting feature to convert the value of an expression to its string representation and to embed that representation in a string. Nell'esecuzione della conversione, il metodo Usa formattazione dipendente dalle impostazioni cultura o un formattatore personalizzato.In performing the conversion, the method uses culture-sensitive formatting or a custom formatter. Il metodo converte arg0 alla relativa rappresentazione di stringa chiamando relativo ToString (IFormatProvider) metodo oppure, se l'oggetto del corrispondente elemento di formato include una stringa di formato chiamando relativo ToString ( String, IFormatProvider) (metodo).The method converts arg0 to its string representation by calling its ToString(IFormatProvider) method or, if the object's corresponding format item includes a format string, by calling its ToString(String,IFormatProvider) method. Se questi metodi non esistono, viene chiamato l'oggetto senza parametri ToString (metodo).If these methods don't exist, it calls the object's parameterless ToString method.

Quando tuttavia si chiama il metodo String.Format, non è necessario concentrarsi sull'overload specifico che si vuole chiamare.However, when calling the String.Format method, it is not necessary to focus on the particular overload that you want to call. È 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.Instead, you can call the method with an object that provides culture-sensitive or custom formatting and a composite format string that includes one or more format items. Si assegna a ogni elemento di formato un indice numerico; il primo indice inizia da 0.You assign each format item a numeric index; the first index starts at 0. Oltre alla stringa iniziale, la chiamata al metodo deve avere tanti argomenti aggiuntivi quanti sono i valori di indice.In addition to the initial string, your method call should have as many additional arguments as it has index values. 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.For example, a string whose format items have indexes of 0 and 1 should have 2 arguments; one with indexes 0 through 5 should have 6 arguments. Il compilatore di linguaggio risolverà quindi la chiamata al metodo a un overload specifico del metodo String.Format.Your language compiler will then resolve your method call to a particular overload of the String.Format method.

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).For more detailed documentation on using the String.Format method, see Getting started with the String.Format method and Which method do I call?.

Format(IFormatProvider, String, Object[]) Format(IFormatProvider, String, Object[]) Format(IFormatProvider, String, Object[]) 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.Replaces the format items in a string with the string representations of corresponding objects in a specified array. Un parametro fornisce le informazioni di formattazione specifiche delle impostazioni cultura.A parameter supplies culture-specific formatting information.

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);
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 IFormatProvider IFormatProvider IFormatProvider

Oggetto che fornisce informazioni di formattazione specifiche delle impostazioni cultura.An object that supplies culture-specific formatting information.

args
Object[]

Matrice di oggetti che contiene zero o più oggetti da formattare.An object array that contains zero or more objects to format.

Restituisce

Copia di format in cui gli elementi di formato sono stati sostituiti dalla rappresentazione di stringa degli oggetti corrispondenti in args.A copy of format in which the format items have been replaced by the string representation of the corresponding objects in args.

Eccezioni

format non è valido.format is invalid.

In alternativa-or- L'indice di un elemento di formato è minore di zero oppure maggiore o uguale alla lunghezza della matrice args.The index of a format item is less than zero, or greater than or equal to the length of the args array.

Commenti

Importante

Anziché chiamare il metodo String.Format o usare stringhe di formato composite, è possibile usare stringhe interpolate se supportate dal linguaggio.Instead of calling the String.Format method or using composite format strings, you can use interpolated strings if your language supports them. Una stringa interpolata è una stringa che contiene espressioni interpolate.An interpolated string is a string that contains interpolated expressions. Ogni espressione interpolata viene risolta con il valore dell'espressione e inclusa nella stringa di risultato al momento dell'assegnazione della stringa.Each interpolated expression is resolved with the expression's value and included in the result string when the string is assigned. Per altre informazioni, vedere Interpolazione di stringhe (Riferimenti per C#) e Stringhe interpolate (Riferimenti per Visual Basic).For more information, see String interpolation (C# Reference) and Interpolated Strings (Visual Basic Reference).

Questo metodo Usa il funzionalità di formattazione composita per convertire quattro o più espressioni per le rappresentazioni di stringa e incorporare tali rappresentazioni in una stringa.This method uses the composite formatting feature to convert four or more expressions to their string representations and to embed those representations in a string. Nell'esecuzione della conversione, il metodo Usa formattazione dipendente dalle impostazioni cultura o un formattatore personalizzato.In performing the conversion, the method uses culture-sensitive formatting or a custom formatter. Il metodo converte ognuno Object argomento alla relativa rappresentazione di stringa chiamando relativo ToString (IFormatProvider) metodo oppure, se l'oggetto del corrispondente elemento di formato include una stringa di formato chiamando relativo ToString(String,IFormatProvider) (metodo).The method converts each Object argument to its string representation by calling its ToString(IFormatProvider) method or, if the object's corresponding format item includes a format string, by calling its ToString(String,IFormatProvider) method. Se questi metodi non esistono, viene chiamato l'oggetto senza parametri ToString (metodo).If these methods don't exist, it calls the object's parameterless ToString method.

Quando tuttavia si chiama il metodo String.Format, non è necessario concentrarsi sull'overload specifico che si vuole chiamare.However, when calling the String.Format method, it is not necessary to focus on the particular overload that you want to call. È 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.Instead, you can call the method with an object that provides culture-sensitive or custom formatting and a composite format string that includes one or more format items. Si assegna a ogni elemento di formato un indice numerico; il primo indice inizia da 0.You assign each format item a numeric index; the first index starts at 0. Oltre alla stringa iniziale, la chiamata al metodo deve avere tanti argomenti aggiuntivi quanti sono i valori di indice.In addition to the initial string, your method call should have as many additional arguments as it has index values. 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.For example, a string whose format items have indexes of 0 and 1 should have 2 arguments; one with indexes 0 through 5 should have 6 arguments. Il compilatore di linguaggio risolverà quindi la chiamata al metodo a un overload specifico del metodo String.Format.Your language compiler will then resolve your method call to a particular overload of the String.Format method.

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).For more detailed documentation on using the String.Format method, see Getting started with the String.Format method and Which method do I call?.

Esempio: Formattazione dipendente dalle impostazioni culturaExample: Culture-sensitive formatting

Questo esempio viene usato il Format(IFormatProvider, String, Object[]) metodo per visualizzare la rappresentazione di stringa di alcuni valori di data e ora e valori numerici con varie impostazioni cultura.This example uses the Format(IFormatProvider, String, Object[]) method to display the string representation of some date and time values and numeric values by using several different cultures.

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

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

Sostituisce gli elementi di formato presenti in una stringa con la rappresentazione di stringa di due oggetti specificati.Replaces the format items in a string with the string representation of two specified objects.

public:
 static System::String ^ Format(System::String ^ format, System::Object ^ arg0, System::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 Object Object Object

Primo oggetto da formattare.The first object to format.

arg1
Object Object Object Object

Secondo oggetto da formattare.The second object to format.

Restituisce

Copia di format in cui gli elementi di formato vengono sostituiti dalle rappresentazioni di stringa di arg0 e arg1.A copy of format in which format items are replaced by the string representations of arg0 and arg1.

Eccezioni

format non è valido.format is invalid.

In alternativa-or- L'indice di un elemento di formato è diverso da zero o uno.The index of a format item is not zero or one.

Commenti

Importante

Anziché chiamare il metodo String.Format o usare stringhe di formato composite, è possibile usare stringhe interpolate se supportate dal linguaggio.Instead of calling the String.Format method or using composite format strings, you can use interpolated strings if your language supports them. Una stringa interpolata è una stringa che contiene espressioni interpolate.An interpolated string is a string that contains interpolated expressions. Ogni espressione interpolata viene risolta con il valore dell'espressione e inclusa nella stringa di risultato al momento dell'assegnazione della stringa.Each interpolated expression is resolved with the expression's value and included in the result string when the string is assigned. Per altre informazioni, vedere Interpolazione di stringhe (Riferimenti per C#) e Stringhe interpolate (Riferimenti per Visual Basic).For more information, see String interpolation (C# Reference) and Interpolated Strings (Visual Basic Reference).

Questo metodo Usa il funzionalità di formattazione composita per convertire il valore di due espressioni per le rappresentazioni di stringa e incorporare tali rappresentazioni in una stringa.This method uses the composite formatting feature to convert the value of two expressions to their string representations and to embed those representations in a string.

Quando tuttavia si chiama il metodo String.Format, non è necessario concentrarsi sull'overload specifico che si vuole chiamare.However, when calling the String.Format method, it is not necessary to focus on the particular overload that you want to call. È invece possibile chiamare il metodo con una stringa di formato composta che include uno o più elementi di formato.Instead, you can call the method with a composite format string that includes one or more format items. Si assegna a ogni elemento di formato un indice numerico; il primo indice inizia da 0.You assign each format item a numeric index; the first index starts at 0. Oltre alla stringa iniziale, la chiamata al metodo deve avere tanti argomenti aggiuntivi quanti sono i valori di indice.In addition to the initial string, your method call should have as many additional arguments as it has index values. 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.For example, a string whose format items have indexes of 0 and 1 should have 2 arguments; one with indexes 0 through 5 should have 6 arguments. Il compilatore di linguaggio risolverà quindi la chiamata al metodo a un overload specifico del metodo String.Format.Your language compiler will then resolve your method call to a particular overload of the String.Format method.

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).For more detailed documentation on using the String.Format method, see Getting started with the String.Format method and Which method do I call?.

Esempio: Formattazione di due argomentiExample: Formatting two arguments

Questo esempio Usa la Format(String, Object, Object) metodo per visualizzare i dati di temperatura e ora archiviati in un oggetto generico Dictionary<TKey,TValue> oggetto.This example uses the Format(String, Object, Object) method to display time and temperature data stored in a generic Dictionary<TKey,TValue> object. Si noti che la stringa di formato include tre elementi di formato, anche se sono presenti solo due oggetti da formattare.Note that the format string has three format items, although there are only two objects to format. Infatti, il primo oggetto nell'elenco (un valore data e ora) viene utilizzato dagli elementi di formato due: Il primo formato l'elemento consente di visualizzare l'ora e il secondo Visualizza la data.This is because the first object in the list (a date and time value) is used by two format items: The first format item displays the time, and the second displays the date.

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

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

Sostituisce gli elementi di formato presenti in una stringa con la rappresentazione di stringa di due oggetti specificati.Replaces the format items in a string with the string representation of two specified objects. Un parametro fornisce le informazioni di formattazione specifiche delle impostazioni cultura.A parameter supplies culture-specific formatting information.

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);
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 IFormatProvider IFormatProvider IFormatProvider

Oggetto che fornisce informazioni di formattazione specifiche delle impostazioni cultura.An object that supplies culture-specific formatting information.

arg0
Object Object Object Object

Primo oggetto da formattare.The first object to format.

arg1
Object Object Object Object

Secondo oggetto da formattare.The second object to format.

Restituisce

Copia di format in cui gli elementi di formato vengono sostituiti dalle rappresentazioni di stringa di arg0 e arg1.A copy of format in which format items are replaced by the string representations of arg0 and arg1.

Eccezioni

format non è valido.format is invalid.

In alternativa-or- L'indice di un elemento di formato è diverso da zero o uno.The index of a format item is not zero or one.

Commenti

Importante

Anziché chiamare il metodo String.Format o usare stringhe di formato composite, è possibile usare stringhe interpolate se supportate dal linguaggio.Instead of calling the String.Format method or using composite format strings, you can use interpolated strings if your language supports them. Una stringa interpolata è una stringa che contiene espressioni interpolate.An interpolated string is a string that contains interpolated expressions. Ogni espressione interpolata viene risolta con il valore dell'espressione e inclusa nella stringa di risultato al momento dell'assegnazione della stringa.Each interpolated expression is resolved with the expression's value and included in the result string when the string is assigned. Per altre informazioni, vedere Interpolazione di stringhe (Riferimenti per C#) e Stringhe interpolate (Riferimenti per Visual Basic).For more information, see String interpolation (C# Reference) and Interpolated Strings (Visual Basic Reference).

Questo metodo Usa il funzionalità di formattazione composita per convertire le rappresentazioni di stringa di due espressioni e incorporare tali rappresentazioni in una stringa.This method uses the composite formatting feature to convert two expressions to their string representations and to embed those representations in a string. Nell'esecuzione della conversione, il metodo Usa formattazione dipendente dalle impostazioni cultura o un formattatore personalizzato.In performing the conversion, the method uses culture-sensitive formatting or a custom formatter. Il metodo converte ognuno Object argomento alla relativa rappresentazione di stringa chiamando relativo ToString (IFormatProvider) metodo oppure, se l'oggetto del corrispondente elemento di formato include una stringa di formato chiamando relativo ToString(String,IFormatProvider) (metodo).The method converts each Object argument to its string representation by calling its ToString(IFormatProvider) method or, if the object's corresponding format item includes a format string, by calling its ToString(String,IFormatProvider) method. Se questi metodi non esistono, viene chiamato l'oggetto senza parametri ToString (metodo).If these methods don't exist, it calls the object's parameterless ToString method.

Quando tuttavia si chiama il metodo String.Format, non è necessario concentrarsi sull'overload specifico che si vuole chiamare.However, when calling the String.Format method, it is not necessary to focus on the particular overload that you want to call. È 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.Instead, you can call the method with an object that provides culture-sensitive or custom formatting and a composite format string that includes one or more format items. Si assegna a ogni elemento di formato un indice numerico; il primo indice inizia da 0.You assign each format item a numeric index; the first index starts at 0. Oltre alla stringa iniziale, la chiamata al metodo deve avere tanti argomenti aggiuntivi quanti sono i valori di indice.In addition to the initial string, your method call should have as many additional arguments as it has index values. 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.For example, a string whose format items have indexes of 0 and 1 should have 2 arguments; one with indexes 0 through 5 should have 6 arguments. Il compilatore di linguaggio risolverà quindi la chiamata al metodo a un overload specifico del metodo String.Format.Your language compiler will then resolve your method call to a particular overload of the String.Format method.

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).For more detailed documentation on using the String.Format method, see Getting started with the String.Format method and Which method do I call?.

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

Sostituisce gli elementi di formato in una stringa con le rappresentazioni di stringa di tre oggetti specificati.Replaces the format items in a string with the string representation of three specified objects.

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);
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 Object Object Object

Primo oggetto da formattare.The first object to format.

arg1
Object Object Object Object

Secondo oggetto da formattare.The second object to format.

arg2
Object Object Object Object

Terzo oggetto da formattare.The third object to format.

Restituisce

Copia di format in cui gli elementi di formato sono stati sostituiti dalle rappresentazioni di stringa di arg0, arg1 e arg2.A copy of format in which the format items have been replaced by the string representations of arg0, arg1, and arg2.

Eccezioni

format non è valido.format is invalid.

In alternativa-or- L'indice di un elemento di formato è minore di zero oppure maggiore di due.The index of a format item is less than zero, or greater than two.

Commenti

Importante

Anziché chiamare il metodo String.Format o usare stringhe di formato composite, è possibile usare stringhe interpolate se supportate dal linguaggio.Instead of calling the String.Format method or using composite format strings, you can use interpolated strings if your language supports them. Una stringa interpolata è una stringa che contiene espressioni interpolate.An interpolated string is a string that contains interpolated expressions. Ogni espressione interpolata viene risolta con il valore dell'espressione e inclusa nella stringa di risultato al momento dell'assegnazione della stringa.Each interpolated expression is resolved with the expression's value and included in the result string when the string is assigned. Per altre informazioni, vedere Interpolazione di stringhe (Riferimenti per C#) e Stringhe interpolate (Riferimenti per Visual Basic).For more information, see String interpolation (C# Reference) and Interpolated Strings (Visual Basic Reference).

Questo metodo Usa il funzionalità di formattazione composita per convertire il valore di tre espressioni per le rappresentazioni di stringa e incorporare tali rappresentazioni in una stringa.This method uses the composite formatting feature to convert the value of three expressions to their string representations and to embed those representations in a string.

Quando tuttavia si chiama il metodo String.Format, non è necessario concentrarsi sull'overload specifico che si vuole chiamare.However, when calling the String.Format method, it is not necessary to focus on the particular overload that you want to call. È invece possibile chiamare il metodo con una stringa di formato composta che include uno o più elementi di formato.Instead, you can call the method with a composite format string that includes one or more format items. Si assegna a ogni elemento di formato un indice numerico; il primo indice inizia da 0.You assign each format item a numeric index; the first index starts at 0. Oltre alla stringa iniziale, la chiamata al metodo deve avere tanti argomenti aggiuntivi quanti sono i valori di indice.In addition to the initial string, your method call should have as many additional arguments as it has index values. 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.For example, a string whose format items have indexes of 0 and 1 should have 2 arguments; one with indexes 0 through 5 should have 6 arguments. Il compilatore di linguaggio risolverà quindi la chiamata al metodo a un overload specifico del metodo String.Format.Your language compiler will then resolve your method call to a particular overload of the String.Format method.

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).For more detailed documentation on using the String.Format method, see Getting started with the String.Format method and Which method do I call?.

Esempio: Formattazione di tre argomentiExample: Formatting three arguments

Questo esempio Usa la Format(String, Object, Object, Object) metodo per creare una stringa in cui viene illustrato il risultato di un valore booleano And operazione con due valori integer.This example uses the Format(String, Object, Object, Object) method to create a string that illustrates the result of a Boolean And operation with two integer values. Si noti che la stringa di formato include sei elementi di formato, ma il metodo ha solo tre elementi nell'elenco dei parametri, poiché ogni elemento viene formattato in due modi diversi.Note that the format string includes six format items, but the method has only three items in its parameter list, because each item is formatted in two different ways.

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

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

Sostituisce gli elementi di formato in una stringa con le rappresentazioni di stringa di tre oggetti specificati.Replaces the format items in a string with the string representation of three specified objects. Un parametro fornisce le informazioni di formattazione specifiche delle impostazioni cultura.An parameter supplies culture-specific formatting information.

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);
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 IFormatProvider IFormatProvider IFormatProvider

Oggetto che fornisce informazioni di formattazione specifiche delle impostazioni cultura.An object that supplies culture-specific formatting information.

arg0
Object Object Object Object

Primo oggetto da formattare.The first object to format.

arg1
Object Object Object Object

Secondo oggetto da formattare.The second object to format.

arg2
Object Object Object Object

Terzo oggetto da formattare.The third object to format.

Restituisce

Copia di format in cui gli elementi di formato sono stati sostituiti dalle rappresentazioni di stringa di arg0, arg1 e arg2.A copy of format in which the format items have been replaced by the string representations of arg0, arg1, and arg2.

Eccezioni

format non è valido.format is invalid.

In alternativa-or- L'indice di un elemento di formato è minore di zero oppure maggiore di due.The index of a format item is less than zero, or greater than two.

Commenti

Importante

Anziché chiamare il metodo String.Format o usare stringhe di formato composite, è possibile usare stringhe interpolate se supportate dal linguaggio.Instead of calling the String.Format method or using composite format strings, you can use interpolated strings if your language supports them. Una stringa interpolata è una stringa che contiene espressioni interpolate.An interpolated string is a string that contains interpolated expressions. Ogni espressione interpolata viene risolta con il valore dell'espressione e inclusa nella stringa di risultato al momento dell'assegnazione della stringa.Each interpolated expression is resolved with the expression's value and included in the result string when the string is assigned. Per altre informazioni, vedere Interpolazione di stringhe (Riferimenti per C#) e Stringhe interpolate (Riferimenti per Visual Basic).For more information, see String interpolation (C# Reference) and Interpolated Strings (Visual Basic Reference).

Questo metodo Usa il funzionalità di formattazione composita per convertire le rappresentazioni di stringa di tre espressioni e incorporare tali rappresentazioni in una stringa.This method uses the composite formatting feature to convert three expressions to their string representations and to embed those representations in a string. Nell'esecuzione della conversione, il metodo Usa formattazione dipendente dalle impostazioni cultura o un formattatore personalizzato.In performing the conversion, the method uses culture-sensitive formatting or a custom formatter. Il metodo converte ognuno Object argomento alla relativa rappresentazione di stringa chiamando relativo ToString (IFormatProvider) metodo oppure, se l'oggetto del corrispondente elemento di formato include una stringa di formato chiamando relativo ToString(String,IFormatProvider) (metodo).The method converts each Object argument to its string representation by calling its ToString(IFormatProvider) method or, if the object's corresponding format item includes a format string, by calling its ToString(String,IFormatProvider) method. Se questi metodi non esistono, viene chiamato l'oggetto senza parametri ToString (metodo).If these methods don't exist, it calls the object's parameterless ToString method.

Quando tuttavia si chiama il metodo String.Format, non è necessario concentrarsi sull'overload specifico che si vuole chiamare.However, when calling the String.Format method, it is not necessary to focus on the particular overload that you want to call. È 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.Instead, you can call the method with an object that provides culture-sensitive or custom formatting and a composite format string that includes one or more format items. Si assegna a ogni elemento di formato un indice numerico; il primo indice inizia da 0.You assign each format item a numeric index; the first index starts at 0. Oltre alla stringa iniziale, la chiamata al metodo deve avere tanti argomenti aggiuntivi quanti sono i valori di indice.In addition to the initial string, your method call should have as many additional arguments as it has index values. 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.For example, a string whose format items have indexes of 0 and 1 should have 2 arguments; one with indexes 0 through 5 should have 6 arguments. Il compilatore di linguaggio risolverà quindi la chiamata al metodo a un overload specifico del metodo String.Format.Your language compiler will then resolve your method call to a particular overload of the String.Format method.

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).For more detailed documentation on using the String.Format method, see Getting started with the String.Format method and Which method do I call?.

Si applica a