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

Definición

Convierte el valor de los objetos en cadenas en función de los formatos especificados y los inserta en otra cadena.Converts the value of objects to strings based on the formats specified and inserts them into another string.

Si aún no conoce el método String.Format, vea un resumen rápido en la sección Empezar a trabajar con el método String.Format.If you are new to the String.Format method, see the Get started with the String.Format method section for a quick overview.

Vea documentación general sobre el método String.Format en la sección Comentarios.See the Remarks section for general documentation for the String.Format method.

Sobrecargas

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

Reemplaza uno o más elementos de formato de una cadena por la representación de cadena de un objeto especificado.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[])

Reemplaza el elemento de formato de una cadena especificada por la representación de cadena de un objeto correspondiente de una matriz especificada.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)

Sustituye el elemento o elementos de formato en una cadena específica con la representación de cadena del objeto correspondiente.Replaces the format item or items in a specified string with the string representation of the corresponding object. Un parámetro proporciona información de formato específica de la referencia cultural.A parameter supplies culture-specific formatting information.

Format(IFormatProvider, String, Object[]) Format(IFormatProvider, String, Object[]) Format(IFormatProvider, String, Object[]) Format(IFormatProvider, String, Object[])

Reemplaza los elementos de formato de una cadena por las representaciones de cadena de los objetos correspondientes en una matriz especificada.Replaces the format items in a string with the string representations of corresponding objects in a specified array. Un parámetro proporciona información de formato específica de la referencia cultural.A parameter supplies culture-specific formatting information.

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

Reemplaza los elementos de formato de una cadena por la representación de cadena de dos objetos especificados.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)

Reemplaza los elementos de formato de una cadena por la representación de cadena de dos objetos especificados.Replaces the format items in a string with the string representation of two specified objects. Un parámetro proporciona información de formato específica de la referencia cultural.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)

Reemplaza los elementos de formato de una cadena por la representación de cadena de tres objetos especificados.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)

Reemplaza los elementos de formato de una cadena por la representación de cadena de tres objetos especificados.Replaces the format items in a string with the string representation of three specified objects. Un parámetro proporciona información de formato específica de la referencia cultural.An parameter supplies culture-specific formatting information.

Ejemplos

Muchos ejemplos que llaman al Format método se intercalan en la sección comentarios de este artículo.Numerous examples that call the Format method are interspersed through the Remarks section of this article.

Nota

Algunos de los ejemplos de C# de este artículo se ejecutan en el ejecutor de código en línea y área de juegos de Try.NET.Some of the C# examples in this article run in the Try.NET inline code runner and playground. Si está presente, haga clic en el botón Ejecutar para ejecutar un ejemplo en una ventana interactiva.When present, select the Run button to run an example in an interactive window. Una vez que se ejecuta el código, puede modificar y ejecutar el código modificado si vuelve a hacer clic en Ejecutar.Once you execute the code, you can modify it and run the modified code by selecting Run again. El código modificado se ejecuta en la ventana interactiva o, si se produce un error en la compilación, en la ventana interactiva se muestran todos los mensajes de error del compilador de C#.The modified code either runs in the interactive window or, if compilation fails, the interactive window displays all C# compiler error messages.

También puede descargar un conjunto completo String.Format de ejemplos, que se incluyen en un proyecto de .net Core 2,0 C# para y un proyecto de .net Core 2,0 para Visual Basic, desde el repositorio de GitHub dotnet/samples.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.

Estos son algunos de los ejemplos que se incluyen en el artículo:The following are some of the examples included in the article:

Crear una cadena de formatoCreate a format string

Insertar una cadenaInserting a string
El elemento de formatoThe format item
Aplicar formato a los elementos que tienen el mismo índiceFormat items that have the same index

Control de la salida con formatoControl formatted output

Controlar el formatoControlling formatting
Controlar el espaciadoControlling spacing
Controlar la alineaciónControlling alignment
Controlar el número de dígitos enterosControlling the number of integral digits
Controlar el número de dígitos después del separador decimalControlling the number of digits after the decimal separator
Incluir llaves literales en una cadena de resultadoIncluding literal braces in a result string

Hacer que las cadenas de formato tengan en cuenta las referencias culturalesMake format strings culture-sensitive

Formato que tiene en cuenta las referencias culturalesCulture-sensitive formatting

Personalizar la operación de formatoCustomize the formatting operation

Una operación de formato personalizadoA custom formatting operation
Un proveedor de interceptación y el formateador de números romanosAn intercept provider and Roman numeral formatter

Comentarios

Importante

En lugar de llamar al método String.Format o usar cadenas de formato compuesto, se pueden usar cadenas interpoladas si el lenguaje las admite.Instead of calling the String.Format method or using composite format strings, you can use interpolated strings if your language supports them. Una cadena interpolada es una cadena que contiene expresiones interpoladas.An interpolated string is a string that contains interpolated expressions. Cada expresión interpolada se resuelve con el valor de la expresión y se incluye en la cadena de resultado cuando se asigna la cadena.Each interpolated expression is resolved with the expression's value and included in the result string when the string is assigned. Para obtener más información, vea Interpolación de cadenas (Referencia de C#) y Cadenas interpoladas (referencia de Visual Basic).For more information, see String interpolation (C# Reference) and Interpolated Strings (Visual Basic Reference).

En esta sección:In this section:

Introducción al método String. Format Get started with the String.Format method
¿A qué método se llama? Which method do I call?
Método Format en Brief The Format method in brief
El elemento de formato The Format item
Cómo se da formato a los argumentos How arguments are formatted
Aplicar formato a los elementos que tienen el mismo índice Format items that have the same index
Formato y referencia cultural Formatting and culture
Operaciones de formato personalizado Custom formatting operations
String. Format Q & AString.Format Q & A

Introducción al método String. FormatGet started with the String.Format method

Use String.Format si necesita insertar el valor de un objeto, una variable o una expresión en otra cadena.Use String.Format if you need to insert the value of an object, variable, or expression into another string. Por ejemplo, puede insertar el valor de un Decimal valor en una cadena para mostrarlo al usuario como una sola cadena: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.

Y puede controlar el formato de ese valor: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.

Además del formato, también puede controlar la alineación y el espaciado.Besides formatting, you can also control alignment and spacing.

Insertar una cadenaInserting a string

String.Formatcomienza con una cadena de formato, seguida de uno o varios objetos o expresiones que se convertirán en cadenas y se insertarán en un lugar especificado de la cadena de 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. Por ejemplo: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.'

La {0} de la cadena de formato es un elemento de formato.The {0} in the format string is a format item. 0es el índice del objeto cuyo valor de cadena se insertará en esa posición.0 is the index of the object whose string value will be inserted at that position. (Los índices comienzan en 0). Si el objeto que se va a insertar no es una cadena ToString , se llama a su método para convertirlo en uno antes de insertarlo en la cadena de resultado.(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.

Este es otro ejemplo en el que se usan dos elementos de formato y dos objetos en la lista de objetos: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.'

Puede tener tantos elementos de formato como los que desee en la lista de objetos, siempre que el índice de cada elemento de formato tenga un objeto correspondiente en la lista de objetos.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. Tampoco tiene que preocuparse de la sobrecarga a la que llame; el compilador seleccionará el adecuado.You also don't have to worry about which overload you call; the compiler will select the appropriate one for you.

Controlar el formatoControlling formatting

Puede seguir el índice de un elemento de formato con una cadena de formato para controlar cómo se da formato a un objeto.You can follow the index in a format item with a format string to control how an object is formatted. Por ejemplo, {0:d} aplica la cadena de formato "d" al primer objeto de la lista de objetos.For example, {0:d} applies the "d" format string to the first object in the object list. A continuación se muestra un ejemplo con un solo objeto y dos elementos de 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'

Varios tipos admiten cadenas de formato, incluidos todos los tipos numéricos (cadenas de formato estándar y personalizado ), todas las fechas y horas (cadenas de formato estándar y personalizadas ) e intervalos de tiempo (tanto estándar como cadenas de formato personalizado ), todos los tiposde enumeración de tipos de enumeración y 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. También puede Agregar compatibilidad con las cadenas de formato a sus propios tipos.You can also add support for format strings to your own types.

Controlar el espaciadoControlling spacing

Puede definir el ancho de la cadena que se inserta en la cadena de resultado mediante una sintaxis como {0,12}, que inserta una cadena de 12 caracteres.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. En este caso, la representación de cadena del primer objeto está alineada a la derecha en el campo de 12 caracteres.In this case, the string representation of the first object is right-aligned in the 12-character field. Si, sin embargo, la representación de cadena del primer objeto tiene más de 12 caracteres de longitud, se omite el ancho de campo preferido y se inserta la cadena completa en la cadena de resultado.(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.)

En el ejemplo siguiente se define un campo de 6 caracteres que contiene la cadena "Year" y algunas cadenas de año, así como un campo de 15 caracteres que contiene la cadena "Population" y algunos datos de población.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. Tenga en cuenta que los caracteres están alineados a la derecha en el 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
int[] years = { 2013, 2014, 2015 };
int[] population = { 1025632, 1105967, 1148203 };
var sb = new System.Text.StringBuilder();
sb.Append(String.Format("{0,6} {1,15}\n\n", "Year", "Population"));
for (int index = 0; index < years.Length; index++)
   sb.Append(String.Format("{0,6} {1,15:N0}\n", years[index], population[index]));

Console.WriteLine(sb);

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

Controlar la alineaciónControlling alignment

De forma predeterminada, las cadenas se alinean a la derecha dentro de su campo si especifica un ancho de campo.By default, strings are right-aligned within their field if you specify a field width. Para alinear a la izquierda las cadenas de un campo, debe anteponer el ancho del campo con un signo {0,-12} negativo, por ejemplo, para definir un campo de 12 caracteres alineado a la izquierda.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.

El siguiente ejemplo es similar al anterior, salvo que alinea a la izquierda las etiquetas y los datos.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.Formathace uso de la característica de formato compuesto.String.Format makes use of the composite formatting feature. Para obtener más información, consulte Formatos compuestos.For more information, see Composite Formatting.

¿A qué método se llama?Which method do I call?

EnTo CallCall
Dar formato a uno o más objetos mediante las convenciones de la referencia cultural actual.Format one or more objects by using the conventions of the current culture. A excepción de las sobrecargas que incluyen provider un parámetro, las Format sobrecargas restantes incluyen String un parámetro seguido de uno o varios parámetros de objeto.Except for the overloads that include a provider parameter, the remaining Format overloads include a String parameter followed by one or more object parameters. Por este motivo, no tiene que determinar a qué Format sobrecarga desea llamar.Because of this, you don't have to determine which Format overload you intend to call. El compilador del lenguaje selecciona la sobrecarga adecuada entre las sobrecargas que no provider tienen un parámetro, en función de la lista de argumentos.Your language compiler selects the appropriate overload from among the overloads that don't have a provider parameter, based on your argument list. Por ejemplo, si la lista de argumentos tiene cinco argumentos, el compilador llama al Format(String, Object[]) método.For example, if your argument list has five arguments, the compiler calls the Format(String, Object[]) method.
Dar formato a uno o más objetos mediante las convenciones de una referencia cultural concreta.Format one or more objects by using the conventions of a specific culture. Cada Format sobrecarga que comienza con un provider parámetro va seguida de un String parámetro y uno o varios parámetros de objeto.Each Format overload that begins with a provider parameter is followed by a String parameter and one or more object parameters. Por este motivo, no tiene que determinar a qué sobrecarga Format específica desea llamar.Because of this, you don't have to determine which specific Format overload you intend to call. El compilador del lenguaje selecciona la sobrecarga adecuada entre las sobrecargas que provider tienen un parámetro, en función de la lista de argumentos.Your language compiler selects the appropriate overload from among the overloads that have a provider parameter, based on your argument list. Por ejemplo, si la lista de argumentos tiene cinco argumentos, el compilador llama al Format(IFormatProvider, String, Object[]) método.For example, if your argument list has five arguments, the compiler calls the Format(IFormatProvider, String, Object[]) method.
Realice una operación de formato personalizada con una ICustomFormatter implementación de o IFormattable una implementación de.Perform a custom formatting operation either with an ICustomFormatter implementation or an IFormattable implementation. Cualquiera de las cuatro sobrecargas con un provider parámetro.Any of the four overloads with a provider parameter. El compilador selecciona la sobrecarga adecuada entre las sobrecargas que tienen provider un parámetro, en función de la lista de argumentos.The compiler selects the appropriate overload from among the overloads that have a provider parameter, based on your argument list.

Método Format en BriefThe Format method in brief

Cada sobrecarga del Format método utiliza la característica de formato compuesto para incluir marcadores de posición indizados basados en cero, denominados elementos de formato, en una cadena de formato compuesto.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. En tiempo de ejecución, cada elemento de formato se reemplaza con la representación de cadena del argumento correspondiente en una lista de parámetros.At run time, each format item is replaced with the string representation of the corresponding argument in a parameter list. Si el valor del argumento es null, el elemento de formato se reemplaza por. String.EmptyIf the value of the argument is null, the format item is replaced with String.Empty. Por ejemplo, la Format(String, Object, Object, Object) siguiente llamada al método incluye una cadena de formato con tres elementos de formato {0} {1},, y {2}, y una lista de argumentos con tres elementos.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.   

El elemento de formatoThe format item

Un elemento de formato tiene esta sintaxis:A format item has this syntax:

{index[,alignment][:formatString]}  

Los corchetes denotan elementos opcionales.Brackets denote optional elements. Las llaves de apertura y cierre son obligatorias.The opening and closing braces are required. (Para incluir una llave de apertura o de cierre literal en la cadena de formato, consulte la sección llaves de escape en el artículo formatos compuestos ).(To include a literal opening or closing brace in the format string, see the Escaping Braces section in the Composite Formatting article.)

Por ejemplo, un elemento de formato para dar formato a un valor de moneda podría ser similar al siguiente: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 de formato tiene los siguientes elementos:A format item has the following elements:

indexindex
Índice de base cero del argumento cuya representación de cadena se va a incluir en esta posición de la cadena.The zero-based index of the argument whose string representation is to be included at this position in the string. Si este argumento es null, se incluirá una cadena vacía en esta posición de la cadena.If this argument is null, an empty string will be included at this position in the string.

alignmentalignment
Opcional.Optional. Entero con signo que indica la longitud total del campo en el que se inserta el argumento y si está alineado a la derecha (un entero positivo) o alineado a la izquierda (un entero 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). Si omite alignment, la representación de cadena del argumento correspondiente se inserta en un campo sin espacios iniciales ni finales.If you omit alignment, the string representation of the corresponding argument is inserted in a field with no leading or trailing spaces.

Si el valor de alignment es menor que la longitud del argumento que se va a insertar, se omite alignment y se usa la longitud de la representación de cadena del argumento como el ancho 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
Opcional.Optional. Cadena que especifica el formato de la cadena de resultado del argumento correspondiente.A string that specifies the format of the corresponding argument's result string. Si omite FormatString, se llama al ToString método sin parámetros del argumento correspondiente para generar su representación de cadena.If you omit formatString, the corresponding argument's parameterless ToString method is called to produce its string representation. Si especifica FormatString, el argumento al que hace referencia el elemento de formato debe implementar IFormattable la interfaz.If you specify formatString, the argument referenced by the format item must implement the IFormattable interface. Los tipos que admiten cadenas de formato incluyen:Types that support format strings include:

Sin embargo, tenga en cuenta que cualquier tipo IFormattable personalizado puede implementar o extender la IFormattable implementación de un tipo existente.However, note that any custom type can implement IFormattable or extend an existing type's IFormattable implementation.

En el ejemplo siguiente se alignment usan formatString los argumentos y para generar la salida con formato.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 %
// 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 %

Cómo se da formato a los argumentosHow arguments are formatted

Los elementos de formato se procesan secuencialmente desde el principio de la cadena.Format items are processed sequentially from the beginning of the string. Cada elemento de formato tiene un índice que corresponde a un objeto de la lista de argumentos del método.Each format item has an index that corresponds to an object in the method's argument list. El Format método recupera el argumento y deriva su representación de cadena de la siguiente manera:The Format method retrieves the argument and derives its string representation as follows:

Para obtener un ejemplo que intercepta llamadas al ICustomFormatter.Format método y le permite ver qué información pasa el Format método a un método de formato para cada elemento de formato de una cadena de formato compuesto, vea el ejemplo: Un proveedor de interceptación y el formateadornumérico 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.

Para obtener más información, consulte la sección orden de procesamiento en el artículo formatos compuestos .For more information, see the Processing Order section in the Composite Formatting article.

Aplicar formato a los elementos que tienen el mismo índiceFormat items that have the same index

El Format método produce una FormatException excepción si el índice de un elemento de índice es mayor o igual que el número de argumentos de la lista de argumentos.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. Sin embargo format , puede incluir más elementos de formato que los argumentos, siempre que varios elementos de formato tengan el mismo índice.However, format can include more format items than there are arguments, as long as multiple format items have the same index. En la llamada al Format(String, Object) método en el ejemplo siguiente, la lista de argumentos tiene un único argumento, pero la cadena de formato incluye dos elementos de formato: uno muestra el valor decimal de un número y el otro muestra su valor hexadecimal.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.

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

Formato y referencia culturalFormatting and culture

Por lo general, los objetos de la lista de argumentos se convierten en sus representaciones de cadena usando las convenciones de la referencia cultural actual CultureInfo.CurrentCulture , devuelta por la propiedad.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. Puede controlar este comportamiento mediante una llamada a una de las sobrecargas Format de que incluye provider un parámetro.You can control this behavior by calling one of the overloads of Format that includes a provider parameter. El provider parámetro es una IFormatProvider implementación de que proporciona información de formato personalizada y específica de la referencia cultural que se usa para moderar el proceso de formato.The provider parameter is an IFormatProvider implementation that supplies custom and culture-specific formatting information that is used to moderate the formatting process.

La IFormatProvider interfaz tiene un solo miembro, GetFormat, que es responsable de devolver el objeto que proporciona información de formato.The IFormatProvider interface has a single member, GetFormat, which is responsible for returning the object that provides formatting information. .Net tiene tres IFormatProvider implementaciones que proporcionan un formato específico de la referencia cultural:.NET has three IFormatProvider implementations that provide culture-specific formatting:

Operaciones de formato personalizadoCustom formatting operations

También puede llamar a cualquiera de las sobrecargas del Format método que tienen un provider parámetro de tipo IFormatProvider para realizar operaciones de formato personalizadas.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. Por ejemplo, puede dar formato a un entero como un número de identificación o como un número de teléfono.For example, you could format an integer as an identification number or as a telephone number. Para realizar el formato personalizado, provider el argumento debe implementar las IFormatProvider interfaces ICustomFormatter y.To perform custom formatting, your provider argument must implement both the IFormatProvider and ICustomFormatter interfaces. Format provider IFormatProvider.GetFormat ICustomFormatterCuando se pasa al ICustomFormattermétodouna implementación como argumento, el método llama a su implementación y solicita un objeto de tipo. FormatWhen 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. A continuación, llama al ICustomFormatter método del Format objeto devuelto para dar formato a cada elemento de formato de la cadena compuesta que se le ha pasado.It then calls the returned ICustomFormatter object's Format method to format each format item in the composite string passed to it.

Para obtener más información acerca de cómo proporcionar soluciones de formato personalizado, consulte Cómo: Definir y usar proveedores de formato numérico personalizado y. ICustomFormatterFor more information about providing custom formatting solutions, see How to: Define and Use Custom Numeric Format Providers and ICustomFormatter. Para obtener un ejemplo en el que se convierten enteros en números personalizados con formato, vea ejemplo: Una operaciónde formato personalizado.For an example that converts integers to formatted custom numbers, see Example: A custom formatting operation. Para obtener un ejemplo en el que se convierten bytes sin signo en números romanos , vea el ejemplo: Un proveedor de interceptación y el formateadornumérico romano.For an example that converts unsigned bytes to Roman numerals, see Example: An intercept provider and Roman numeral formatter.

Ejemplo: Una operación de formato personalizadoExample: A custom formatting operation

En este ejemplo se define un proveedor de formato que da formato a un valor entero como un número de cuenta de cliente con el 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.

Ejemplo: Un proveedor de interceptación y el formateador de números romanosExample: An intercept provider and Roman numeral formatter

En este ejemplo se define un proveedor de formato personalizado que ICustomFormatter implementa IFormatProvider las interfaces y para hacer dos cosas:This example defines a custom format provider that implements the ICustomFormatter and IFormatProvider interfaces to do two things:

  • Muestra los parámetros que se han pasado ICustomFormatter.Format a su implementación.It displays the parameters passed to its ICustomFormatter.Format implementation. Esto nos permite ver qué parámetros está pasando Format(IFormatProvider, String, Object[]) el método a la implementación de formato personalizado para cada objeto al que intenta dar formato.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. Esto puede ser útil al depurar la aplicación.This can be useful when you're debugging your application.

  • Si el objeto al que se va a dar formato es un valor de byte sin signo al que se va a dar formato mediante la cadena de formato estándar "R", el formateador personalizado da formato al valor numérico como un número 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

¿Por qué se recomienda la interpolación de cadenas en String.Format las llamadas al método?Why do you recommend string interpolation over calls to the String.Format method?

La interpolación de cadenas es:String interpolation is:

  • Más flexible.More flexible. Se puede utilizar en cualquier cadena sin necesidad de una llamada a un método que admita formato compuesto.It can be used in any string without requiring a call to a method that supports composite formatting. De lo contrario, debe llamar al Format método u otro método que admita formatos compuestos, Console.WriteLine como 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.

  • Más legible.More readable. Dado que la expresión que se va a insertar en una cadena aparece en la expresión interpolada en lugar de en una lista de argumentos, las cadenas interpoladas son mucho más fáciles de codificar y leer.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. Debido a su mayor legibilidad, las cadenas interpoladas pueden reemplazar no solo llamadas a métodos de formato compuesto, sino que también se pueden usar en operaciones de concatenación de cadenas para generar código más conciso y más conciso.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.

Una comparación de los dos ejemplos de código siguientes muestra la superior de las cadenas interpoladas sobre la concatenación de cadenas y las llamadas a los métodos de formato compuesto.A comparison of the following two code examples illustrates the superiority of interpolated strings over string concatenation and calls to composite formatting methods. El uso de varias operaciones de concatenación de cadenas en el ejemplo siguiente genera código detallado y de difícil lectura.The use of multiple string concatenation operations in the following example produces verbose and hard-to-read code.

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.


Por el contrario, el uso de cadenas interpoladas en el ejemplo siguiente genera un código mucho más claro y conciso que la instrucción de concatenación de cadenas y la Format llamada al método en el ejemplo anterior.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.

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.


¿Dónde puedo encontrar una lista de las cadenas de formato predefinidas que se pueden usar con los elementos de formato?Where can I find a list of the predefined format strings that can be used with format items?

Cómo controlar la alineación de las cadenas de resultado que reemplazan a los elementos de formato?How do I control the alignment of the result strings that replace format items?

La sintaxis general de un elemento de formato es la siguiente:The general syntax of a format item is:

{index[,alignment][: formatString]}  

donde alignment es un entero con signo que define el ancho del campo.where alignment is a signed integer that defines the field width. Si este valor es negativo, el texto del campo se alinea a la izquierda.If this value is negative, text in the field is left-aligned. Si es positivo, el texto está alineado a la derecha.If it is positive, text is right-aligned.

Cómo controlar el número de dígitos después del separador decimalHow do I control the number of digits after the decimal separator?

Todas las cadenas de formato numérico estándar excepto "D" (que se usa solo con enteros), "G", "R" y "X" permiten un especificador de precisión que define el número de dígitos decimales en la cadena de resultado.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. En el ejemplo siguiente se usan cadenas de formato numérico estándar para controlar el número de dígitos decimales en la cadena de resultado.The following example uses standard numeric format strings to control the number of decimal digits in the result string.

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 %

Si utiliza una cadena de formato numérico personalizado, use el especificador de formato "0" para controlar el número de dígitos decimales en la cadena de resultado, como se muestra en el ejemplo siguiente.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.

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

Cómo controlar el número de dígitos enteros?How do I control the number of integral digits?

De forma predeterminada, las operaciones de formato solo muestran dígitos enteros distintos de cero.By default, formatting operations only display non-zero integral digits. Si va a dar formato a enteros, puede usar un especificador de precisión con las cadenas de formato estándar "D" y "X" para controlar el número de dígitos.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.

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

Puede rellenar un número entero o de punto flotante con ceros a la izquierda para generar una cadena de resultado con un número especificado de dígitos enteros mediante el especificador de formato numérico personalizado"0", como se muestra en el ejemplo siguiente.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.

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

¿Cuántos elementos se pueden incluir en la lista de formatos?How many items can I include in the format list?

No hay ningún límite práctico.There is no practical limit. El segundo parámetro del Format(IFormatProvider, String, Object[]) método se etiqueta con el ParamArrayAttribute atributo, lo que permite incluir una lista delimitada o una matriz de objetos como la lista de formatos.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.

Cómo incluir llaves literales ("{" y "}") en la cadena de resultado?How do I include literal braces ("{" and "}") in the result string?

Por ejemplo, ¿cómo se impide que la siguiente llamada al método inicie FormatException una excepción?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 sola llave de apertura o de cierre siempre se interpreta como el principio o el final de un elemento de formato.A single opening or closing brace is always interpreted as the beginning or end of a format item. Para que se interprete literalmente, debe ser un carácter de escape.To be interpreted literally, it must be escaped. Puede omitir una llave agregando otra llave ("{{" y "}}" en lugar de "{" y "}"), como en la siguiente llamada al método: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)

Sin embargo, incluso las llaves de escape se interpretan fácilmente erróneamente.However, even escaped braces are easily misinterpreted. Se recomienda incluir llaves en la lista de formatos y usar los elementos de formato para insertarlas en la cadena de resultado, como se muestra en el ejemplo siguiente.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, "}")

¿Por qué mi llamada al método String. Format produce una excepción FormatException?Why does my call to the String.Format method throw a FormatException?

La causa más común de la excepción es que el índice de un elemento de formato no se corresponde con un objeto de la lista de formatos.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. Normalmente, esto indica que ha numerado los índices de los elementos de formato o que ha olvidado incluir un objeto en la lista 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. Al intentar incluir un carácter de llave izquierda o derecha sin escape también se produce una FormatExceptionexcepción.Attempting to include an unescaped left or right brace character also throws a FormatException. En ocasiones, la excepción es el resultado de un errata; por ejemplo, un error típico es escribir "[" (el corchete de apertura) en lugar de "{" (la llave de apertura).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).

Si el método Format (System. IFormatProvider, System. String, System. Object []) admite matrices de parámetros, ¿por qué el código produce una excepción cuando se usa una matriz?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?

Por ejemplo, el código siguiente produce una FormatException excepción:For example, the following code throws a FormatException exception:

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

Se trata de un problema de la resolución de sobrecarga del compilador.This is a problem of compiler overload resolution. Dado que el compilador no puede convertir una matriz de enteros en una matriz de objetos, trata la matriz de enteros como un argumento único, por Format(String, Object) lo que llama al método.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. La excepción se produce porque hay cuatro elementos de formato, pero solo un elemento en la lista de formato.The exception is thrown because there are four format items but only a single item in the format list.

Dado que ni Visual Basic C# ni pueden convertir una matriz de enteros en una matriz de objetos, tendrá que realizar la conversión usted mismo antes Format(String, Object[]) de llamar al método.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. En el ejemplo siguiente se proporciona una implementación de.The following example provides one implementation.

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)

Reemplaza uno o más elementos de formato de una cadena por la representación de cadena de un objeto especificado.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

Parámetros

arg0
Object Object Object Object

Objeto al que se va a aplicar formato.The object to format.

Devoluciones

Copia de format en la que los elementos de formato se ha reemplazado por la representación de cadena de arg0.A copy of format in which any format items are replaced by the string representation of arg0.

Excepciones

El elemento de formato de format no es válido.The format item in format is invalid.

o bien-or- El índice de un elemento de formato no es cero.The index of a format item is not zero.

Comentarios

Importante

En lugar de llamar al método String.Format o usar cadenas de formato compuesto, se pueden usar cadenas interpoladas si el lenguaje las admite.Instead of calling the String.Format method or using composite format strings, you can use interpolated strings if your language supports them. Una cadena interpolada es una cadena que contiene expresiones interpoladas.An interpolated string is a string that contains interpolated expressions. Cada expresión interpolada se resuelve con el valor de la expresión y se incluye en la cadena de resultado cuando se asigna la cadena.Each interpolated expression is resolved with the expression's value and included in the result string when the string is assigned. Para obtener más información, vea Interpolación de cadenas (Referencia de C#) y Cadenas interpoladas (referencia de Visual Basic).For more information, see String interpolation (C# Reference) and Interpolated Strings (Visual Basic Reference).

Este método usa la característica de formato compuesto para convertir el valor de una expresión en su representación de cadena e incrustar esa representación en una cadena.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.

Pero al llamar al método String.Format, no es necesario centrarse en la sobrecarga concreta que se quiere llamar.However, when calling the String.Format method, it is not necessary to focus on the particular overload that you want to call. En su lugar, se puede llamar al método con un cadena de formato compuesto que incluya uno o varios elementos de formato.Instead, you can call the method with a composite format string that includes one or more format items. A cada elemento de formato se le asigna un índice numérico; el primer índice comienza en 0.You assign each format item a numeric index; the first index starts at 0. Además de la cadena inicial, la llamada al método debe tener tantos argumentos adicionales como valores de índice.In addition to the initial string, your method call should have as many additional arguments as it has index values. Por ejemplo, una cadena cuyos elementos de formato tienen los índices 0 y 1 debe tener dos argumentos; una con los índices de 0 a 5 debe tener seis argumentos.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. Después, el compilador del lenguaje resolverá la llamada de método en una sobrecarga concreta del método String.Format.Your language compiler will then resolve your method call to a particular overload of the String.Format method.

Para obtener información más detallada sobre el uso del método String.Format, vea Introducción al método String.Format y ¿Qué método se debe llamar?.For more detailed documentation on using the String.Format method, see Getting started with the String.Format method and Which method do I call?.

Ejemplo: Dar formato a un solo argumentoExample: Formatting a single argument

En el ejemplo siguiente se Format(String, Object) usa el método para insertar la edad de una persona en medio de una cadena.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.
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.
Consulte también:

Format(String, Object[]) Format(String, Object[]) Format(String, Object[]) Format(String, Object[])

Reemplaza el elemento de formato de una cadena especificada por la representación de cadena de un objeto correspondiente de una matriz especificada.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

Parámetros

args
Object[]

Matriz de objetos que contiene cero o más objetos a los que se va a aplicar formato.An object array that contains zero or more objects to format.

Devoluciones

Copia de format en la que los elementos de formato se han reemplazado por la representación de cadena de los objetos correspondientes de args.A copy of format in which the format items have been replaced by the string representation of the corresponding objects in args.

Excepciones

format no es válido.format is invalid.

O bien-or- El índice de un elemento de formato es menor que cero, o mayor o igual que la longitud de la matriz args.The index of a format item is less than zero, or greater than or equal to the length of the args array.

Comentarios

Importante

En lugar de llamar al método String.Format o usar cadenas de formato compuesto, se pueden usar cadenas interpoladas si el lenguaje las admite.Instead of calling the String.Format method or using composite format strings, you can use interpolated strings if your language supports them. Una cadena interpolada es una cadena que contiene expresiones interpoladas.An interpolated string is a string that contains interpolated expressions. Cada expresión interpolada se resuelve con el valor de la expresión y se incluye en la cadena de resultado cuando se asigna la cadena.Each interpolated expression is resolved with the expression's value and included in the result string when the string is assigned. Para obtener más información, vea Interpolación de cadenas (Referencia de C#) y Cadenas interpoladas (referencia de Visual Basic).For more information, see String interpolation (C# Reference) and Interpolated Strings (Visual Basic Reference).

Este método usa la característica de formato compuesto para convertir el valor de cuatro o más expresiones en sus representaciones de cadena e incrustar esas representaciones en una cadena.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. Dado que args el parámetro se marca con System.ParamArrayAttribute el atributo, puede pasar los objetos al método como argumentos individuales o como una Object matriz.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.

Pero al llamar al método String.Format, no es necesario centrarse en la sobrecarga concreta que se quiere llamar.However, when calling the String.Format method, it is not necessary to focus on the particular overload that you want to call. En su lugar, se puede llamar al método con un cadena de formato compuesto que incluya uno o varios elementos de formato.Instead, you can call the method with a composite format string that includes one or more format items. A cada elemento de formato se le asigna un índice numérico; el primer índice comienza en 0.You assign each format item a numeric index; the first index starts at 0. Además de la cadena inicial, la llamada al método debe tener tantos argumentos adicionales como valores de índice.In addition to the initial string, your method call should have as many additional arguments as it has index values. Por ejemplo, una cadena cuyos elementos de formato tienen los índices 0 y 1 debe tener dos argumentos; una con los índices de 0 a 5 debe tener seis argumentos.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. Después, el compilador del lenguaje resolverá la llamada de método en una sobrecarga concreta del método String.Format.Your language compiler will then resolve your method call to a particular overload of the String.Format method.

Para obtener información más detallada sobre el uso del método String.Format, vea Introducción al método String.Format y ¿Qué método se debe llamar?.For more detailed documentation on using the String.Format method, see Getting started with the String.Format method and Which method do I call?.

Ejemplo: Aplicar formato a más de tres argumentosExample: Formatting more than three arguments

En este ejemplo se crea una cadena que contiene datos sobre la temperatura alta y baja en una fecha determinada.This example creates a string that contains data on the high and low temperature on a particular date. La cadena de formato compuesto tiene cinco elementos de formato C# en el ejemplo y seis en el Visual Basic ejemplo.The composite format string has five format items in the C# example and six in the Visual Basic example. Dos de los elementos de formato definen el ancho de su representación de cadena del valor correspondiente y el primer elemento de formato también incluye una cadena de formato de fecha y hora estándar.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)
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)

También puede pasar los objetos a los que se va a dar formato como una matriz en lugar de como una lista de argumentos.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   
Consulte también:

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

Sustituye el elemento o elementos de formato en una cadena específica con la representación de cadena del objeto correspondiente.Replaces the format item or items in a specified string with the string representation of the corresponding object. Un parámetro proporciona información de formato específica de la referencia cultural.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

Parámetros

provider
IFormatProvider IFormatProvider IFormatProvider IFormatProvider

Objeto que proporciona información de formato específica de la referencia cultural.An object that supplies culture-specific formatting information.

arg0
Object Object Object Object

Objeto al que se va a aplicar formato.The object to format.

Devoluciones

Una copia de format en la que el elemento o elementos de formato se han sustituido con la representación de cadena de arg0.A copy of format in which the format item or items have been replaced by the string representation of arg0.

Excepciones

format no es válido.format is invalid.

O bien-or- El índice de un elemento de formato no es cero.The index of a format item is not zero.

Comentarios

Importante

En lugar de llamar al método String.Format o usar cadenas de formato compuesto, se pueden usar cadenas interpoladas si el lenguaje las admite.Instead of calling the String.Format method or using composite format strings, you can use interpolated strings if your language supports them. Una cadena interpolada es una cadena que contiene expresiones interpoladas.An interpolated string is a string that contains interpolated expressions. Cada expresión interpolada se resuelve con el valor de la expresión y se incluye en la cadena de resultado cuando se asigna la cadena.Each interpolated expression is resolved with the expression's value and included in the result string when the string is assigned. Para obtener más información, vea Interpolación de cadenas (Referencia de C#) y Cadenas interpoladas (referencia de Visual Basic).For more information, see String interpolation (C# Reference) and Interpolated Strings (Visual Basic Reference).

Este método usa la característica de formato compuesto para convertir el valor de una expresión en su representación de cadena e incrustar esa representación en una cadena.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. Al realizar la conversión, el método usa el formato dependiente de la referencia cultural o un formateador personalizado.In performing the conversion, the method uses culture-sensitive formatting or a custom formatter. El método convierte arg0 en su representación de cadena mediante una llamada a su método ToString (IFormatProvider) o, si el elemento de formato correspondiente del objeto incluye una cadena de formato, llamando a su ToString (String, IFormatProvider) forma.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. Si estos métodos no existen, llama al método ToString sin parámetros del objeto.If these methods don't exist, it calls the object's parameterless ToString method.

Pero al llamar al método String.Format, no es necesario centrarse en la sobrecarga concreta que se quiere llamar.However, when calling the String.Format method, it is not necessary to focus on the particular overload that you want to call. En su lugar, se puede llamar al método con un objeto que proporcione un formato con referencia cultural o personalizado, y una cadena de formato compuesto que incluya uno o varios elementos de 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. A cada elemento de formato se le asigna un índice numérico; el primer índice comienza en 0.You assign each format item a numeric index; the first index starts at 0. Además de la cadena inicial, la llamada al método debe tener tantos argumentos adicionales como valores de índice.In addition to the initial string, your method call should have as many additional arguments as it has index values. Por ejemplo, una cadena cuyos elementos de formato tienen los índices 0 y 1 debe tener dos argumentos; una con los índices de 0 a 5 debe tener seis argumentos.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. Después, el compilador del lenguaje resolverá la llamada de método en una sobrecarga concreta del método String.Format.Your language compiler will then resolve your method call to a particular overload of the String.Format method.

Para obtener información más detallada sobre el uso del método String.Format, vea Introducción al método String.Format y ¿Qué método se debe llamar?.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[])

Reemplaza los elementos de formato de una cadena por las representaciones de cadena de los objetos correspondientes en una matriz especificada.Replaces the format items in a string with the string representations of corresponding objects in a specified array. Un parámetro proporciona información de formato específica de la referencia cultural.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

Parámetros

provider
IFormatProvider IFormatProvider IFormatProvider IFormatProvider

Objeto que proporciona información de formato específica de la referencia cultural.An object that supplies culture-specific formatting information.

args
Object[]

Matriz de objetos que contiene cero o más objetos a los que se va a aplicar formato.An object array that contains zero or more objects to format.

Devoluciones

Copia de format en la que los elementos de formato se han reemplazado por la representación de cadena de los objetos correspondientes de args.A copy of format in which the format items have been replaced by the string representation of the corresponding objects in args.

Excepciones

format no es válido.format is invalid.

O bien-or- El índice de un elemento de formato es menor que cero, o mayor o igual que la longitud de la matriz args.The index of a format item is less than zero, or greater than or equal to the length of the args array.

Comentarios

Importante

En lugar de llamar al método String.Format o usar cadenas de formato compuesto, se pueden usar cadenas interpoladas si el lenguaje las admite.Instead of calling the String.Format method or using composite format strings, you can use interpolated strings if your language supports them. Una cadena interpolada es una cadena que contiene expresiones interpoladas.An interpolated string is a string that contains interpolated expressions. Cada expresión interpolada se resuelve con el valor de la expresión y se incluye en la cadena de resultado cuando se asigna la cadena.Each interpolated expression is resolved with the expression's value and included in the result string when the string is assigned. Para obtener más información, vea Interpolación de cadenas (Referencia de C#) y Cadenas interpoladas (referencia de Visual Basic).For more information, see String interpolation (C# Reference) and Interpolated Strings (Visual Basic Reference).

Este método usa la característica de formato compuesto para convertir cuatro o más expresiones en sus representaciones de cadena e incrustar esas representaciones en una cadena.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. Al realizar la conversión, el método usa el formato dependiente de la referencia cultural o un formateador personalizado.In performing the conversion, the method uses culture-sensitive formatting or a custom formatter. El método convierte cada Object argumento en su representación de cadena mediante una llamada a su método ToString (IFormatProvider) o, si el elemento de formato correspondiente del objeto incluye una cadena de formato, llamando a su ToString (cadena, IFormatProvider) .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. Si estos métodos no existen, llama al método ToString sin parámetros del objeto.If these methods don't exist, it calls the object's parameterless ToString method.

Pero al llamar al método String.Format, no es necesario centrarse en la sobrecarga concreta que se quiere llamar.However, when calling the String.Format method, it is not necessary to focus on the particular overload that you want to call. En su lugar, se puede llamar al método con un objeto que proporcione un formato con referencia cultural o personalizado, y una cadena de formato compuesto que incluya uno o varios elementos de 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. A cada elemento de formato se le asigna un índice numérico; el primer índice comienza en 0.You assign each format item a numeric index; the first index starts at 0. Además de la cadena inicial, la llamada al método debe tener tantos argumentos adicionales como valores de índice.In addition to the initial string, your method call should have as many additional arguments as it has index values. Por ejemplo, una cadena cuyos elementos de formato tienen los índices 0 y 1 debe tener dos argumentos; una con los índices de 0 a 5 debe tener seis argumentos.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. Después, el compilador del lenguaje resolverá la llamada de método en una sobrecarga concreta del método String.Format.Your language compiler will then resolve your method call to a particular overload of the String.Format method.

Para obtener información más detallada sobre el uso del método String.Format, vea Introducción al método String.Format y ¿Qué método se debe llamar?.For more detailed documentation on using the String.Format method, see Getting started with the String.Format method and Which method do I call?.

Ejemplo: Formato que tiene en cuenta las referencias culturalesExample: Culture-sensitive formatting

En este ejemplo se Format(IFormatProvider, String, Object[]) usa el método para mostrar la representación de cadena de algunos valores de fecha y hora y valores numéricos mediante el uso de varias referencias culturales diferentes.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.

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

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

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

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

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

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

Reemplaza los elementos de formato de una cadena por la representación de cadena de dos objetos especificados.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

Parámetros

arg0
Object Object Object Object

Primer objeto al que se va a dar formato.The first object to format.

arg1
Object Object Object Object

Segundo objeto al que se va a dar formato.The second object to format.

Devoluciones

Copia de format en la que los elementos de formato se ha reemplazado por las representaciones de cadena de arg0 y arg1.A copy of format in which format items are replaced by the string representations of arg0 and arg1.

Excepciones

format no es válido.format is invalid.

o bien-or- El índice de un elemento de formato no es cero o uno.The index of a format item is not zero or one.

Comentarios

Importante

En lugar de llamar al método String.Format o usar cadenas de formato compuesto, se pueden usar cadenas interpoladas si el lenguaje las admite.Instead of calling the String.Format method or using composite format strings, you can use interpolated strings if your language supports them. Una cadena interpolada es una cadena que contiene expresiones interpoladas.An interpolated string is a string that contains interpolated expressions. Cada expresión interpolada se resuelve con el valor de la expresión y se incluye en la cadena de resultado cuando se asigna la cadena.Each interpolated expression is resolved with the expression's value and included in the result string when the string is assigned. Para obtener más información, vea Interpolación de cadenas (Referencia de C#) y Cadenas interpoladas (referencia de Visual Basic).For more information, see String interpolation (C# Reference) and Interpolated Strings (Visual Basic Reference).

Este método usa la característica de formato compuesto para convertir el valor de dos expresiones en sus representaciones de cadena e incrustar esas representaciones en una cadena.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.

Pero al llamar al método String.Format, no es necesario centrarse en la sobrecarga concreta que se quiere llamar.However, when calling the String.Format method, it is not necessary to focus on the particular overload that you want to call. En su lugar, se puede llamar al método con un cadena de formato compuesto que incluya uno o varios elementos de formato.Instead, you can call the method with a composite format string that includes one or more format items. A cada elemento de formato se le asigna un índice numérico; el primer índice comienza en 0.You assign each format item a numeric index; the first index starts at 0. Además de la cadena inicial, la llamada al método debe tener tantos argumentos adicionales como valores de índice.In addition to the initial string, your method call should have as many additional arguments as it has index values. Por ejemplo, una cadena cuyos elementos de formato tienen los índices 0 y 1 debe tener dos argumentos; una con los índices de 0 a 5 debe tener seis argumentos.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. Después, el compilador del lenguaje resolverá la llamada de método en una sobrecarga concreta del método String.Format.Your language compiler will then resolve your method call to a particular overload of the String.Format method.

Para obtener información más detallada sobre el uso del método String.Format, vea Introducción al método String.Format y ¿Qué método se debe llamar?.For more detailed documentation on using the String.Format method, see Getting started with the String.Format method and Which method do I call?.

Ejemplo: Aplicar formato a dos argumentosExample: Formatting two arguments

En este ejemplo se Format(String, Object, Object) usa el método para mostrar los datos de tiempo y temperatura Dictionary<TKey,TValue> almacenados en un objeto genérico.This example uses the Format(String, Object, Object) method to display time and temperature data stored in a generic Dictionary<TKey,TValue> object. Tenga en cuenta que la cadena de formato tiene tres elementos de formato, aunque solo hay dos objetos a los que se va a dar formato.Note that the format string has three format items, although there are only two objects to format. Esto se debe a que dos elementos de formato usan el primer objeto de la lista (un valor de fecha y hora): El primer elemento de formato muestra la hora, mientras que la segunda muestra la fecha.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
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
Consulte también:

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

Reemplaza los elementos de formato de una cadena por la representación de cadena de dos objetos especificados.Replaces the format items in a string with the string representation of two specified objects. Un parámetro proporciona información de formato específica de la referencia cultural.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

Parámetros

provider
IFormatProvider IFormatProvider IFormatProvider IFormatProvider

Objeto que proporciona información de formato específica de la referencia cultural.An object that supplies culture-specific formatting information.

arg0
Object Object Object Object

Primer objeto al que se va a dar formato.The first object to format.

arg1
Object Object Object Object

Segundo objeto al que se va a dar formato.The second object to format.

Devoluciones

Copia de format en la que los elementos de formato se ha reemplazado por las representaciones de cadena de arg0 y arg1.A copy of format in which format items are replaced by the string representations of arg0 and arg1.

Excepciones

format no es válido.format is invalid.

O bien-or- El índice de un elemento de formato no es cero o uno.The index of a format item is not zero or one.

Comentarios

Importante

En lugar de llamar al método String.Format o usar cadenas de formato compuesto, se pueden usar cadenas interpoladas si el lenguaje las admite.Instead of calling the String.Format method or using composite format strings, you can use interpolated strings if your language supports them. Una cadena interpolada es una cadena que contiene expresiones interpoladas.An interpolated string is a string that contains interpolated expressions. Cada expresión interpolada se resuelve con el valor de la expresión y se incluye en la cadena de resultado cuando se asigna la cadena.Each interpolated expression is resolved with the expression's value and included in the result string when the string is assigned. Para obtener más información, vea Interpolación de cadenas (Referencia de C#) y Cadenas interpoladas (referencia de Visual Basic).For more information, see String interpolation (C# Reference) and Interpolated Strings (Visual Basic Reference).

Este método usa la característica de formato compuesto para convertir dos expresiones en sus representaciones de cadena e incrustar esas representaciones en una cadena.This method uses the composite formatting feature to convert two expressions to their string representations and to embed those representations in a string. Al realizar la conversión, el método usa el formato dependiente de la referencia cultural o un formateador personalizado.In performing the conversion, the method uses culture-sensitive formatting or a custom formatter. El método convierte cada Object argumento en su representación de cadena mediante una llamada a su método ToString (IFormatProvider) o, si el elemento de formato correspondiente del objeto incluye una cadena de formato, llamando a su ToString (cadena, IFormatProvider) .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. Si estos métodos no existen, llama al método ToString sin parámetros del objeto.If these methods don't exist, it calls the object's parameterless ToString method.

Pero al llamar al método String.Format, no es necesario centrarse en la sobrecarga concreta que se quiere llamar.However, when calling the String.Format method, it is not necessary to focus on the particular overload that you want to call. En su lugar, se puede llamar al método con un objeto que proporcione un formato con referencia cultural o personalizado, y una cadena de formato compuesto que incluya uno o varios elementos de 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. A cada elemento de formato se le asigna un índice numérico; el primer índice comienza en 0.You assign each format item a numeric index; the first index starts at 0. Además de la cadena inicial, la llamada al método debe tener tantos argumentos adicionales como valores de índice.In addition to the initial string, your method call should have as many additional arguments as it has index values. Por ejemplo, una cadena cuyos elementos de formato tienen los índices 0 y 1 debe tener dos argumentos; una con los índices de 0 a 5 debe tener seis argumentos.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. Después, el compilador del lenguaje resolverá la llamada de método en una sobrecarga concreta del método String.Format.Your language compiler will then resolve your method call to a particular overload of the String.Format method.

Para obtener información más detallada sobre el uso del método String.Format, vea Introducción al método String.Format y ¿Qué método se debe llamar?.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)

Reemplaza los elementos de formato de una cadena por la representación de cadena de tres objetos especificados.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

Parámetros

arg0
Object Object Object Object

Primer objeto al que se va a dar formato.The first object to format.

arg1
Object Object Object Object

Segundo objeto al que se va a dar formato.The second object to format.

arg2
Object Object Object Object

Tercer objeto al que se va a dar formato.The third object to format.

Devoluciones

Copia de format en la que los elementos de formato se ha reemplazado por las representaciones de cadena de arg0, arg1 y arg2.A copy of format in which the format items have been replaced by the string representations of arg0, arg1, and arg2.

Excepciones

format no es válido.format is invalid.

O bien-or- El índice de un elemento de formato es menor que cero o mayor que dos.The index of a format item is less than zero, or greater than two.

Comentarios

Importante

En lugar de llamar al método String.Format o usar cadenas de formato compuesto, se pueden usar cadenas interpoladas si el lenguaje las admite.Instead of calling the String.Format method or using composite format strings, you can use interpolated strings if your language supports them. Una cadena interpolada es una cadena que contiene expresiones interpoladas.An interpolated string is a string that contains interpolated expressions. Cada expresión interpolada se resuelve con el valor de la expresión y se incluye en la cadena de resultado cuando se asigna la cadena.Each interpolated expression is resolved with the expression's value and included in the result string when the string is assigned. Para obtener más información, vea Interpolación de cadenas (Referencia de C#) y Cadenas interpoladas (referencia de Visual Basic).For more information, see String interpolation (C# Reference) and Interpolated Strings (Visual Basic Reference).

Este método usa la característica de formato compuesto para convertir el valor de tres expresiones en sus representaciones de cadena e incrustar esas representaciones en una cadena.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.

Pero al llamar al método String.Format, no es necesario centrarse en la sobrecarga concreta que se quiere llamar.However, when calling the String.Format method, it is not necessary to focus on the particular overload that you want to call. En su lugar, se puede llamar al método con un cadena de formato compuesto que incluya uno o varios elementos de formato.Instead, you can call the method with a composite format string that includes one or more format items. A cada elemento de formato se le asigna un índice numérico; el primer índice comienza en 0.You assign each format item a numeric index; the first index starts at 0. Además de la cadena inicial, la llamada al método debe tener tantos argumentos adicionales como valores de índice.In addition to the initial string, your method call should have as many additional arguments as it has index values. Por ejemplo, una cadena cuyos elementos de formato tienen los índices 0 y 1 debe tener dos argumentos; una con los índices de 0 a 5 debe tener seis argumentos.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. Después, el compilador del lenguaje resolverá la llamada de método en una sobrecarga concreta del método String.Format.Your language compiler will then resolve your method call to a particular overload of the String.Format method.

Para obtener información más detallada sobre el uso del método String.Format, vea Introducción al método String.Format y ¿Qué método se debe llamar?.For more detailed documentation on using the String.Format method, see Getting started with the String.Format method and Which method do I call?.

Ejemplo: Aplicar formato a tres argumentosExample: Formatting three arguments

En este ejemplo se Format(String, Object, Object, Object) utiliza el método para crear una cadena que muestra el resultado de una And operación booleana con dos valores enteros.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. Tenga en cuenta que la cadena de formato incluye seis elementos de formato, pero el método solo tiene tres elementos en su lista de parámetros, porque cada elemento tiene el formato de dos maneras diferentes.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)
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)
Consulte también:

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

Reemplaza los elementos de formato de una cadena por la representación de cadena de tres objetos especificados.Replaces the format items in a string with the string representation of three specified objects. Un parámetro proporciona información de formato específica de la referencia cultural.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

Parámetros

provider
IFormatProvider IFormatProvider IFormatProvider IFormatProvider

Objeto que proporciona información de formato específica de la referencia cultural.An object that supplies culture-specific formatting information.

arg0
Object Object Object Object

Primer objeto al que se va a dar formato.The first object to format.

arg1
Object Object Object Object

Segundo objeto al que se va a dar formato.The second object to format.

arg2
Object Object Object Object

Tercer objeto al que se va a dar formato.The third object to format.

Devoluciones

Copia de format en la que los elementos de formato se ha reemplazado por las representaciones de cadena de arg0, arg1 y arg2.A copy of format in which the format items have been replaced by the string representations of arg0, arg1, and arg2.

Excepciones

format no es válido.format is invalid.

o bien-or- El índice de un elemento de formato es menor que cero o mayor que dos.The index of a format item is less than zero, or greater than two.

Comentarios

Importante

En lugar de llamar al método String.Format o usar cadenas de formato compuesto, se pueden usar cadenas interpoladas si el lenguaje las admite.Instead of calling the String.Format method or using composite format strings, you can use interpolated strings if your language supports them. Una cadena interpolada es una cadena que contiene expresiones interpoladas.An interpolated string is a string that contains interpolated expressions. Cada expresión interpolada se resuelve con el valor de la expresión y se incluye en la cadena de resultado cuando se asigna la cadena.Each interpolated expression is resolved with the expression's value and included in the result string when the string is assigned. Para obtener más información, vea Interpolación de cadenas (Referencia de C#) y Cadenas interpoladas (referencia de Visual Basic).For more information, see String interpolation (C# Reference) and Interpolated Strings (Visual Basic Reference).

Este método usa la característica de formato compuesto para convertir tres expresiones en sus representaciones de cadena e incrustar esas representaciones en una cadena.This method uses the composite formatting feature to convert three expressions to their string representations and to embed those representations in a string. Al realizar la conversión, el método usa el formato dependiente de la referencia cultural o un formateador personalizado.In performing the conversion, the method uses culture-sensitive formatting or a custom formatter. El método convierte cada Object argumento en su representación de cadena mediante una llamada a su método ToString (IFormatProvider) o, si el elemento de formato correspondiente del objeto incluye una cadena de formato, llamando a su ToString (cadena, IFormatProvider) .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. Si estos métodos no existen, llama al método ToString sin parámetros del objeto.If these methods don't exist, it calls the object's parameterless ToString method.

Pero al llamar al método String.Format, no es necesario centrarse en la sobrecarga concreta que se quiere llamar.However, when calling the String.Format method, it is not necessary to focus on the particular overload that you want to call. En su lugar, se puede llamar al método con un objeto que proporcione un formato con referencia cultural o personalizado, y una cadena de formato compuesto que incluya uno o varios elementos de 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. A cada elemento de formato se le asigna un índice numérico; el primer índice comienza en 0.You assign each format item a numeric index; the first index starts at 0. Además de la cadena inicial, la llamada al método debe tener tantos argumentos adicionales como valores de índice.In addition to the initial string, your method call should have as many additional arguments as it has index values. Por ejemplo, una cadena cuyos elementos de formato tienen los índices 0 y 1 debe tener dos argumentos; una con los índices de 0 a 5 debe tener seis argumentos.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. Después, el compilador del lenguaje resolverá la llamada de método en una sobrecarga concreta del método String.Format.Your language compiler will then resolve your method call to a particular overload of the String.Format method.

Para obtener información más detallada sobre el uso del método String.Format, vea Introducción al método String.Format y ¿Qué método se debe llamar?.For more detailed documentation on using the String.Format method, see Getting started with the String.Format method and Which method do I call?.

Se aplica a