Este artículo se tradujo automáticamente. Para ver el artículo en inglés, active la casilla Inglés. Además, puede mostrar el texto en inglés en una ventana emergente si mueve el puntero del mouse sobre el texto.
Traducción
Inglés

Método String.Format

 

Convierte el valor de los objetos en cadenas en función de los formatos especificados y los inserta en otra cadena.

Si está familiarizado con la String.Format método, consulte elcómo empezar a usar el método String.Format sección una breve introducción.

Consulte la comentarios sección para obtener documentación completa para todas las String.Format sobrecargas.

Espacio de nombres:   System
Ensamblado:  mscorlib (en mscorlib.dll)

NombreDescripción
System_CAPS_pubmethodSystem_CAPS_staticFormat(IFormatProvider, String, Object)

Sustituye el elemento o elementos de formato en una cadena específica con la representación de cadena del objeto correspondiente. Un parámetro proporciona información de formato específica de la referencia cultural.

System_CAPS_pubmethodSystem_CAPS_staticFormat(IFormatProvider, String, Object, Object)

Reemplaza los elementos de formato en una cadena especificada por la representación de cadena de dos objetos especificados. Un parámetro proporciona información de formato específica de la referencia cultural.

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

Reemplaza los elementos de formato de una cadena especificada por la representación de cadena de tres objetos especificados. Un parámetro proporciona información de formato específica de la referencia cultural.

System_CAPS_pubmethodSystem_CAPS_staticFormat(IFormatProvider, String, Object[])

Reemplaza los elementos de formato de una cadena especificada por representaciones de cadena de los objetos correspondientes en una matriz especificada. Un parámetro proporciona información de formato específica de la referencia cultural.

System_CAPS_pubmethodSystem_CAPS_staticFormat(String, Object)

Reemplaza uno o varios elementos de formato de una cadena especificada con la representación de cadena de un objeto especificado.

System_CAPS_pubmethodSystem_CAPS_staticFormat(String, Object, Object)

Reemplaza los elementos de formato en una cadena especificada por la representación de cadena de dos objetos especificados.

System_CAPS_pubmethodSystem_CAPS_staticFormat(String, Object, Object, Object)

Reemplaza los elementos de formato de una cadena especificada por la representación de cadena de tres objetos especificados.

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

Use String.Format si tiene que insertar el valor de un objeto, una variable o una expresión en otra cadena. Por ejemplo, puede insertar el valor de un Decimal valor en una cadena que se muestra al usuario como una sola cadena:

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

Y puede controlar el formato de ese valor:

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

Además de dar formato, también puede controlar alineación y el espaciado.

Inserción de una cadena

String.Formatse inicia con una cadena de formato, seguida de uno o varios objetos o expresiones que se convierten en cadenas y se inserta en un lugar especificado en la cadena de formato. Por ejemplo:

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

El {0} en el formato de cadena es un elemento de formato. 0es el índice del objeto cuyo valor de cadena que se van a insertar en esa posición. (Los índices empiezan en 0). Si el objeto que se va a insertar no es una cadena, su ToString método se llama para convertir a uno antes de insertarlo en la cadena de resultado.

Este es otro ejemplo que usa dos elementos de formato y dos objetos en la lista de objetos:

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

Puede tener tantos elementos de formato y todos los objetos en la lista de objetos que desee, siempre y cuando el índice de cada elemento de formato tiene un objeto correspondiente en la lista de objetos. Tampoco tiene que preocuparse acerca de la sobrecarga que se llama a; el compilador seleccionará la uno adecuado para usted.

Controlar el formato

Puede seguir el índice de un elemento de formato con una cadena de formato para controlar cómo se da formato a un objeto. Por ejemplo, {0:d} se aplica la cadena de formato "d" para el primer objeto en la lista de objetos. Este es un ejemplo con un único objeto y dos elementos de formato:

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

Cadenas, incluidos todos los tipos numéricos con formato de un número de compatibilidad de tipos (ambos estándar y personalizado las cadenas de formato), todas las fechas y horas (ambos estándar y personalizado las cadenas de formato) e intervalos de tiempo (ambos estándar y personalizado las cadenas de formato), todos los tipos de enumeración tipos de enumeración, y GUIDs. También puede agregar compatibilidad para las cadenas de formato a sus propios tipos.

Controlar el espaciado

Puede definir el ancho de la cadena que se inserta en la cadena de resultado utilizando sintaxis como {0,12}, que inserta una cadena de 12 caracteres. En este caso, la representación de cadena del primer objeto es alineado a la derecha en el campo de 12 caracteres. (Si la representación de cadena del primer objeto es más de 12 caracteres de longitud, sin embargo, se pasa por alto el ancho de campo preferido, y toda la cadena se inserta en la cadena de resultado.)

En el ejemplo siguiente se define un campo de 6 caracteres para contener la cadena "Año" y algunas cadenas de año, así como un campo de 15 caracteres para contener la cadena "Población" y algunos datos de la población. Tenga en cuenta que los caracteres están alineados a la derecha del campo.

int[] years = { 2013, 2014, 2015 };
int[] population = { 1025632, 1105967, 1148203 };
String s = String.Format("{0,6} {1,15}\n\n", "Year", "Population");
for(int index = 0; index < years.Length; index++)
   s += String.Format("{0,6} {1,15:N0}\n",
                      years[index], population[index]);
// Result:
//      Year      Population
//
//      2013       1,025,632
//      2014       1,105,967
//      2015       1,148,203
Controlar la alineación

De forma predeterminada, las cadenas son alineado a la derecha dentro de su ámbito si se especifica un ancho de campo. Para alinear a la izquierda cadenas en un campo, preceder el ancho de campo con un signo negativo como {0,-12} para definir un campo de 12 caracteres alineado a la derecha.

En el ejemplo siguiente es similar al anterior, salvo que alinean a la izquierda las etiquetas y los datos.

int[] years = { 2013, 2014, 2015 };
int[] population = { 1025632, 1105967, 1148203 };
String s = String.Format("{0,-10} {1,-10}\n\n", "Year", "Population");
for(int index = 0; index < years.Length; index++)
   s += String.Format("{0,-10} {1,-10:N0}\n",
                      years[index], population[index]);
// Result:
//    Year       Population
//
//    2013       1,025,632
//    2014       1,105,967
//    2015       1,148,203

String.Formathace uso de la característica de formato compuesto. Para obtener más información, consulta Formatos compuestos.

¿Para obtener instrucciones adicionales sobre cómo elegir una sobrecarga, consulte qué método se debe llamar?

String String.Format(String format, Object arg0)

Reemplaza los elementos de formato con la representación de cadena de un objeto especificado (ejemplo).

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

Reemplaza los elementos de formato con la representación de cadena de dos objetos especificados (ejemplo).

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

Reemplaza los elementos de formato con la representación de cadena de tres objetos especificados (ejemplo).

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

Reemplaza los elementos de formato por las representaciones de cadena de objetos correspondientes de una matriz especificada (ejemplo).

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

Reemplaza los elementos de formato con la representación de cadena de objetos correspondientes de una matriz especificada y usa la información de formato específica de la referencia cultural especificada (ejemplo) o información de formato personalizado (ejemplo).

Se trata de una lista completa de parámetros para el Format método; vea la sintaxis de la sobrecarga por encima de los parámetros utilizados por cada sobrecarga. Solo el format todas las sobrecargas se utiliza el parámetro.

Parámetro

Tipo

Descripción

format

String

Una cadena de formato compuesto que incluye uno o varios elementos de formato (vea el elemento de formato).

arg0

String

La primera o un solo objeto para dar formato.

arg1

String

Segundo objeto al que se va a dar formato.

arg2

String

Tercer objeto al que se va a dar formato.

args

String[]

Cero o más objetos para dar formato suministrado en una lista delimitada por comas o como una matriz.

provider

IFormatProvider

Objeto que proporciona información de formato personalizado o específico de la referencia cultural.

Tipo: String
una copia de format en que los elementos de formato se han sustituido por las representaciones de cadena de los argumentos correspondientes.

Excepción

Condición

Producida por

ArgumentNullException

El valor de format es null.

Todas las sobrecargas.

FormatException

format no es válido.

-o-

El índice de un elemento de formato es menor que cero, o mayor o igual que el número de argumentos en la lista de argumentos.

Todas las sobrecargas.

TO

Llamar

Aplicar formato a uno o varios objetos mediante las convenciones de la referencia cultural actual.

Excepto para las sobrecargas que incluyen un provider parámetro, el restoFormat sobrecargas incluyen un String parámetro seguido de uno o más parámetros de objeto. Por este motivo, no es necesario determinar qué Format sobrecarga que piensa llamar. El compilador del lenguaje seleccionará la sobrecarga adecuada entre las sobrecargas que no tienen un provider parámetro, en función de la lista de argumentos. Por ejemplo, si la lista de argumentos tiene cinco argumentos, el compilador llamará el Format(String, Object[]) método.

Aplicar formato a uno o varios objetos mediante las convenciones de una referencia cultural concreta.

CadaFormatsobrecarga que comienza con un provider parámetro va seguido de un String parámetro y uno o más parámetros de objeto. Por este motivo, no es necesario determinar qué específica Format sobrecarga que piensa llamar. El compilador del lenguaje seleccionará la sobrecarga adecuada entre las sobrecargas que tienen un provider parámetro, en función de la lista de argumentos. Por ejemplo, si la lista de argumentos tiene cinco argumentos, el compilador llamará el Format(IFormatProvider, String, Object[]) método.

Realizar una operación de formato personalizada con un ICustomFormatter implementación o IFormattable implementación.

Cualquiera de las cuatro sobrecargas con un provider parámetro. compilador seleccionará la sobrecarga adecuada entre las sobrecargas que tienen un provider parámetro, en función de la lista de argumentos.

Cada sobrecarga de la Format método usa la característica de formato compuesto para incluir marcadores de posición indizados basado en cero, denominados elementos de formato, en una cadena de formato compuesto. En tiempo de ejecución, cada elemento de formato se reemplaza por la representación de cadena del argumento correspondiente en una lista de parámetros. Si el valor del argumento es null, el elemento de formato se reemplaza con String.Empty. Por ejemplo, la siguiente llamada a la Format(String, Object, Object, Object) método incluye una cadena de formato y elementos de formato tres, {0}, {1}, {2} y una lista de argumentos con tres elementos.

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

Un elemento de formato tiene esta sintaxis:


{
index[,alignment][ :formatString] }

Corchetes indican elementos opcionales. Las llaves de cierre y apertura son necesarios. (Para incluir una literal apertura o cierre en la cadena de formato, vea la sección "Llaves de escape" en la Formatos compuestos artículo.)

Por ejemplo, un elemento de formato al formato de que un valor de moneda podría aparece como el siguiente:

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

Un elemento de formato consta de los siguientes elementos:

índice

El índice basado en cero del argumento cuya representación de cadena debe incluirse en esta posición de la cadena. Si este argumento es null, una cadena vacía se incluirá en esta posición en la cadena.

alineación

Opcional. Un entero con signo que indica la longitud total del campo en el que se inserta el argumento y si se alinean a la derecha (un entero positivo) o alineado a la izquierda (un entero negativo). Si se omite alineación, la representación de cadena del argumento correspondiente se inserta en un campo sin espacios iniciales ni finales.

Si el valor de alineación es menor que la longitud del argumento que se va a insertar, alineación se omite y la longitud de la representación de cadena del argumento se utiliza como el ancho de campo.

formatString

Opcional. Una cadena que especifica el formato de cadena de resultado del argumento correspondiente. Si se omite formatString, el argumento correspondiente sin parámetros ToString método se llama para mostrar la representación de cadena. Si especifica formatString, el argumento al que hace referencia el elemento de formato debe implementar la IFormattable interfaz. Los tipos que admiten las cadenas de formato incluyen:

Sin embargo, tenga en cuenta que puede implementar cualquier tipo personalizado IFormattable o extender un tipo existente IFormattable implementación.

En el ejemplo siguiente se usa el alignment y formatString argumentos para producir un resultado con formato.

using System;

public class Example
{
   public static void Main()
   {
      // Create array of 5-tuples with population data for three U.S. cities, 1940-1950.
      Tuple<string, DateTime, int, DateTime, int>[] cities = 
          { Tuple.Create("Los Angeles", new DateTime(1940, 1, 1), 1504277, 
                         new DateTime(1950, 1, 1), 1970358),
            Tuple.Create("New York", new DateTime(1940, 1, 1), 7454995, 
                         new DateTime(1950, 1, 1), 7891957),  
            Tuple.Create("Chicago", new DateTime(1940, 1, 1), 3396808, 
                         new DateTime(1950, 1, 1), 3620962),  
            Tuple.Create("Detroit", new DateTime(1940, 1, 1), 1623452, 
                         new DateTime(1950, 1, 1), 1849568) };

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

Elementos de formato se procesan secuencialmente desde el principio de la cadena. Cada elemento de formato tiene un índice que corresponde a un objeto de lista de argumentos del método. El Format método recupera el argumento y se deriva de la representación de cadena como se indica a continuación:

Para obtener un ejemplo que intercepta las llamadas a la ICustomFormatter.Format método y le permite ver la información que la Format método pasa a un método de formato para cada elemento de formato de cadena de formato compuesto, vea ejemplo 7: un proveedor de intersección y el número romano formateador.

El Format método produce un FormatException excepción si el índice de un elemento de índice es mayor o igual que el número de argumentos en la lista de argumentos. Sin embargo, format puede incluir más elementos de formato que se pasan argumentos, siempre y cuando varios elementos de formato tienen el mismo índice. En la llamada a la Format(String, Object) 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 la otra muestra su valor hexadecimal.

public class Example
{
   public static void Main()
   {
      short[] values= { Int16.MinValue, -27, 0, 1042, Int16.MaxValue };
      Console.WriteLine("{0,10}  {1,10}\n", "Decimal", "Hex");
      foreach (short value in values)
      {
         string formatString = String.Format("{0,10:G}: {0,10:X}", value);
         Console.WriteLine(formatString);
      }   
   }
}
// The example displays the following output:
//       Decimal         Hex
//    
//        -32768:       8000
//           -27:       FFE5
//             0:          0
//          1042:        412
//         32767:       7FFF

Por lo general, los objetos en la lista de argumentos se convierten en sus representaciones de cadena usando las convenciones de la referencia cultural actual, que es devuelto por la CultureInfo.CurrentCulture propiedad. Puede controlar este comportamiento mediante una llamada a una de las sobrecargas de Format que incluye un provider parámetro. El provider parámetro es un IFormatProvider proceso de implementación que proporciona información de formato personalizada y específica de la referencia cultural que se utiliza para moderar el formato.

El IFormatProvider interfaz tiene un solo miembro, GetFormat, que es responsable de devolver el objeto que proporciona información de formato. .NET Framework tiene tres IFormatProvider implementaciones que proporcionan el formato específico de la referencia cultural:

  • CultureInfo. Su GetFormat método devuelve una referencia cultural específica NumberFormatInfo objeto para dar formato a valores numéricos y una determinada referencia cultural DateTimeFormatInfo objeto para dar formato a valores de fecha y hora.

  • DateTimeFormatInfo, que se usa para el formato específico de la referencia cultural de los valores de fecha y hora. Su GetFormat método devuelve a sí mismo.

  • NumberFormatInfo, que se usa para el formato específico de la referencia cultural de los valores numéricos. Su GetFormat propiedad se devuelve a sí mismo.

También puede llamar a cualquiera de las sobrecargas de la Format método que tiene un provider parámetro Format(IFormatProvider, String, Object[]) sobrecarga para realizar operaciones de formato personalizadas. Por ejemplo, puede dar formato un entero como un número de identificación o como un número de teléfono. Para aplicar un formato personalizado, el provider argumento debe implementar ambas la IFormatProvider y ICustomFormatter interfaces. Cuando elFormat se pasa al método un ICustomFormatter implementación como el provider argumento, el Format llamadas al método su IFormatProvider.GetFormat implementación y solicita un objeto de tipo ICustomFormatter. A continuación, llama el valor devuelto ICustomFormatter del objeto Format pasa el método para cada elemento de formato de la cadena compuesta de formato.

Para obtener más información acerca de cómo proporcionar soluciones personalizadas de formato, vea Cómo: Definir y usar proveedores de formato numérico personalizado y ICustomFormatter. Para obtener un ejemplo que convierte números enteros en números personalizados con formato, consulte ejemplo 6: una operación de formato personalizada. Para obtener un ejemplo que convierte los bytes sin signo en numerales romanos, consulte ejemplo 7: un proveedor de intersección y el número romano formateador.

En el ejemplo siguiente se usa el Format(String, Object) método para incrustar la edad de un individuo dentro de una cadena.

using System;

[assembly: CLSCompliant(true)]
public class Example
{
   public static void Main()
   {
      DateTime birthdate = new DateTime(1993, 7, 28);
      DateTime[] dates = { new DateTime(1993, 8, 16), 
                           new DateTime(1994, 7, 28), 
                           new DateTime(2000, 10, 16), 
                           new DateTime(2003, 7, 27), 
                           new DateTime(2007, 5, 27) };

      foreach (DateTime dateValue in dates)
      {
         TimeSpan interval = dateValue - birthdate;
         // Get the approximate number of years, without accounting for leap years.
         int years = ((int) interval.TotalDays) / 365;
         // See if adding the number of years exceeds dateValue.
         string output;
         if (birthdate.AddYears(years) <= dateValue) {
            output = String.Format("You are now {0} years old.", years);
            Console.WriteLine(output);
         }   
         else {
            output = String.Format("You are now {0} years old.", years - 1);
            Console.WriteLine(output);
         }      
      }
   }
}
// The example displays the following output:
//       You are now 0 years old.
//       You are now 1 years old.
//       You are now 7 years old.
//       You are now 9 years old.
//       You are now 13 years old.

Este ejemplo se utiliza la Format(String, Object, Object) método para mostrar los datos de hora y de temperatura almacenados en un tipo genérico Dictionary<TKey, TValue> objeto. Tenga en cuenta que la cadena de formato tiene tres elementos de formato, aunque hay solo dos objetos para dar formato. Esto es porque el primer objeto de la lista (un valor de fecha y hora) se usa en dos elementos de formato: la primera pantallas de elementos de formato la hora y el segundo muestra la fecha.

using System;
using System.Collections.Generic;

public class Example
{
   public static void Main()
   {
      Dictionary<DateTime, Double> temperatureInfo = new Dictionary<DateTime, Double>(); 
      temperatureInfo.Add(new DateTime(2010, 6, 1, 14, 0, 0), 87.46);
      temperatureInfo.Add(new DateTime(2010, 12, 1, 10, 0, 0), 36.81);

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

Este ejemplo se utiliza la Format(String, Object, Object, Object) método para crear una cadena que se muestra el resultado de un valor booleano And operación con dos valores enteros. Tenga en cuenta que la cadena de formato incluye seis elementos de formato, pero el método tiene solo tres elementos en su lista de parámetros, porque cada elemento es un formato de dos maneras diferentes.

using System;

public class Example
{
   public static void Main()
   {
      string formatString = "    {0,10} ({0,8:X8})\n" + 
                            "And {1,10} ({1,8:X8})\n" + 
                            "  = {2,10} ({2,8:X8})";
      int value1 = 16932;
      int value2 = 15421;
      string result = String.Format(formatString, 
                                    value1, value2, value1 & value2);
      Console.WriteLine(result);
   }
}
// The example displays the following output:
//                16932 (00004224)
//       And      15421 (00003C3D)
//         =         36 (00000024)

En este ejemplo se crea una cadena que contiene datos sobre la temperatura alta y baja en una fecha determinada. La cadena de formato compuesto tiene cinco elementos de formato en el ejemplo de C# y seis en el ejemplo de Visual Basic. Dos de los elementos de formato definen el ancho de la representación de cadena de su valor correspondiente y el primer elemento de formato también incluye una cadena de formato de hora y fecha estándar.

using System;

public class Example
{
   public static void Main()
   {
      DateTime date1 = new DateTime(2009, 7, 1);
      TimeSpan hiTime = new TimeSpan(14, 17, 32);
      decimal hiTemp = 62.1m; 
      TimeSpan loTime = new TimeSpan(3, 16, 10);
      decimal loTemp = 54.8m; 

      string result1 = String.Format("Temperature on {0:d}:\n{1,11}: {2} degrees (hi)\n{3,11}: {4} degrees (lo)", 
                                     date1, hiTime, hiTemp, loTime, loTemp);
      Console.WriteLine(result1);
      Console.WriteLine();

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

También puede pasar los objetos que se va a tener el formato como una matriz en lugar de una lista de argumentos.

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

Este ejemplo se utiliza la Format(IFormatProvider, String, Object[]) método para mostrar la representación de cadena de algunos valores numéricos y valores de fecha y hora con varias referencias culturales diferentes.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      string[] cultureNames = { "en-US", "fr-FR", "de-DE", "es-ES" };

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

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

Este ejemplo define un proveedor de formato que se da formato a un valor entero como un número de cuenta de cliente en el formulario x-xxxxx-xx.

using System;

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

public class CustomerFormatter : IFormatProvider, ICustomFormatter
{
   public object GetFormat(Type formatType) 
   {
      if (formatType == typeof(ICustomFormatter))        
         return this; 
      else
         return null;
   }

   public string Format(string format, 
	                     object arg, 
	                     IFormatProvider formatProvider) 
   {                       
      if (! this.Equals(formatProvider))
      {
         return null;
      }
      else
      {
         if (String.IsNullOrEmpty(format)) 
            format = "G";

         string customerString = arg.ToString();
         if (customerString.Length < 8)
            customerString = customerString.PadLeft(8, '0');

         format = format.ToUpper();
         switch (format)
         {
            case "G":
               return customerString.Substring(0, 1) + "-" +
                                     customerString.Substring(1, 5) + "-" +
                                     customerString.Substring(6);
            case "S":                          
               return customerString.Substring(0, 1) + "/" +
                                     customerString.Substring(1, 5) + "/" +
                                     customerString.Substring(6);
            case "P":                          
               return customerString.Substring(0, 1) + "." +
                                     customerString.Substring(1, 5) + "." +
                                     customerString.Substring(6);
            default:
               throw new FormatException( 
                         String.Format("The '{0}' format specifier is not supported.", format));
         }
      }   
   }
}
// The example displays the following output:
//       7-92031-59
//       7-92031-59
//       7/92031/59
//       7.92031.59
//       The 'X' format specifier is not supported.

Este ejemplo define un proveedor de formato personalizado que implementa la ICustomFormatter y IFormatProvider interfaces hacer dos cosas:

  • Muestra los parámetros pasados a su ICustomFormatter.Format implementación. Esto nos permite ver qué parámetros el Format(IFormatProvider, String, Object[]) método está pasando a la implementación de formato personalizada para cada objeto que intenta dar formato. Esto puede ser útil al depurar la aplicación.

  • Si el objeto que se va a tener el formato es un valor de byte sin signo que se le aplicará el formato mediante la cadena de formato estándar "R", el formateador personalizado da formato al valor numérico como un número romano.

using System;
using System.Globalization;

public class InterceptProvider : IFormatProvider, ICustomFormatter
{
   public object GetFormat(Type formatType)
   {
      if (formatType == typeof(ICustomFormatter))
         return this;
      else
         return null;
   }

   public string Format(String format, Object obj, IFormatProvider provider) 
   {
      // Display information about method call.
      string formatString = format ?? "<null>";
      Console.WriteLine("Provider: {0}, Object: {1}, Format String: {2}",
                        provider, obj ?? "<null>", formatString);

      if (obj == null) return String.Empty;

      // If this is a byte and the "R" format string, format it with Roman numerals.
      if (obj is Byte && formatString.ToUpper().Equals("R")) {
         Byte value = (Byte) obj;
         int remainder;
         int result;
         String returnString = String.Empty;

         // Get the hundreds digit(s)
         result = Math.DivRem(value, 100, out remainder);
         if (result > 0)  
            returnString = new String('C', result);
         value = (Byte) remainder;
         // Get the 50s digit
         result = Math.DivRem(value, 50, out remainder);
         if (result == 1)
            returnString += "L";
         value = (Byte) remainder;
         // Get the tens digit.
         result = Math.DivRem(value, 10, out remainder);
         if (result > 0)
            returnString += new String('X', result);
         value = (Byte) remainder; 
         // Get the fives digit.
         result = Math.DivRem(value, 5, out remainder);
         if (result > 0)
            returnString += "V";
         value = (Byte) remainder;
         // Add the ones digit.
         if (remainder > 0) 
            returnString += new String('I', remainder);

         // Check whether we have too many X characters.
         int pos = returnString.IndexOf("XXXX");
         if (pos >= 0) {
            int xPos = returnString.IndexOf("L"); 
            if (xPos >= 0 & xPos == pos - 1)
               returnString = returnString.Replace("LXXXX", "XC");
            else
               returnString = returnString.Replace("XXXX", "XL");   
         }
         // Check whether we have too many I characters
         pos = returnString.IndexOf("IIII");
         if (pos >= 0)
            if (returnString.IndexOf("V") >= 0)
               returnString = returnString.Replace("VIIII", "IX");
            else
               returnString = returnString.Replace("IIII", "IV");    

         return returnString; 
      }   

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

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

.NET Framework

Se admiten todas las sobrecargas en: 4.5, 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile

Se admiten todas las sobrecargas en: 4, 3.5 SP1

Biblioteca de clases portable

Solo Format(String, Object[]) y Format(IFormatProvider, String, Object[]) son compatibles

.NET para aplicaciones de la Tienda Windows

Solo Format(String, Object[]) y Format(IFormatProvider, String, Object[]) se admiten en Windows 8

La sintaxis general de un elemento de formato es:

{index[,alignment][: formatString]}

donde alineación es un entero con signo que define el ancho de campo. Si este valor es negativo, texto en el campo está alineado a la izquierda. Si es positivo, el texto está alineado a la derecha.

Todos los cadenas de formato numérico estándar excepto "D" (que se usa con enteros solo), "G", "R" y "X" permite un especificador de precisión que define el número de dígitos decimales en la cadena de resultado. En el ejemplo siguiente se usa cadenas de formato numérico estándar para controlar el número de dígitos decimales en la cadena de resultado.

using System;

public class Example
{
   public static void Main()
   {
      object[] values = { 1603, 1794.68235, 15436.14 };
      string result;
      foreach (var value in values) {
         result = String.Format("{0,12:C2}   {0,12:E3}   {0,12:F4}   {0,12:N3}  {1,12:P2}\n",
                                Convert.ToDouble(value), Convert.ToDouble(value) / 10000);
         Console.WriteLine(result);
      }                           
   }
}
// The example displays the following output:
//       $1,603.00     1.603E+003      1603.0000      1,603.000       16.03 %
//    
//       $1,794.68     1.795E+003      1794.6824      1,794.682       17.95 %
//    
//      $15,436.14     1.544E+004     15436.1400     15,436.140      154.36 %

Si usas un cadena de formato numérico personalizado, usar 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.

using System;

public class Example
{
   public static void Main()
   {
      decimal value = 16309.5436m;
      string result = String.Format("{0,12:#.00000} {0,12:0,000.00} {0,12:000.00#}", 
                                    value);
      Console.WriteLine(result);
   }
}
// The example displays the following output:
//        16309.54360    16,309.54    16309.544

De forma predeterminada, las operaciones de formato solo muestran los dígitos integrales distinto de cero. Si se da formato a números enteros, puede utilizar un especificador de precisión con "D" y "X" cadenas de formato estándar para controlar el número de dígitos.

using System;

public class Example
{
   public static void Main()
   {
      int value = 1326;
      string result = String.Format("{0,10:D6} {0,10:X8}", value);
      Console.WriteLine(result);
   }
}
// The example displays the following output:
//     001326   0000052E

Puede rellenar un entero o un número 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 uso de "0" especificador de formato numérico personalizado, como se muestra en el ejemplo siguiente.

using System;

public class Example
{
   public static void Main()
   {
      int value = 16342;
      string result = String.Format("{0,18:00000000} {0,18:00000000.000} {0,18:000,0000,000.0}", 
                                    value);
      Console.WriteLine(result);
   }
}
// The example displays the following output:
//           00016342       00016342.000    0,000,016,342.0

No hay ningún límite práctico. El segundo parámetro de la Format(IFormatProvider, String, Object[]) método tiene una etiqueta con el ParamArrayAttribute atributo, que permite incluir una lista delimitada o una matriz de objetos como la lista de formato.

¿Por ejemplo, Cómo evito que la siguiente llamada de método genere un FormatException excepción?

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

Una apertura único o una llave de cierre se interpreta siempre como el principio o el final de un elemento de formato. Para que se interpreten literalmente, deben convertirse. Escape una llave mediante la adición de otra llave ("{{" y "}}" en lugar de "{" y "}"), como en la siguiente llamada de método:

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

Sin embargo, las llaves de escape incluso son fácilmente interpreta incorrectamente. Se recomienda que incluye llaves en la lista Formato y usar elementos de formato para insertar en la cadena de resultado, como se muestra en el ejemplo siguiente.

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

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 en la lista formato. Normalmente, esto indica que ha misnumbered los índices de los elementos de formato o ha olvidado incluir un objeto en la lista formato. En ocasiones, la excepción es el resultado de un error de escritura; Por ejemplo, un error típico es incorrectamente "[" (el corchete de apertura) en lugar de "{" (la llave de apertura).

Por ejemplo, el código siguiente produce un FormatException excepción:

using System;
using System.Collections.Generic;

public class Example
{
   public static void Main()
   {
      Random rnd = new Random();
      int[]  numbers = new int[4];
      int total = 0;
      for (int ctr = 0; ctr <= 2; ctr++) {
         int number = rnd.Next(1001);
         numbers[ctr] = number;
         total += number;
      }   
      numbers[3] = total;
      Console.WriteLine("{0} + {1} + {2} = {3}", numbers);   
   }
}

Se trata de un problema de resolución de sobrecarga de compilador. Dado que el compilador no puede convertir una matriz de enteros a una matriz de objetos, trata la matriz de enteros como un solo argumento, por ello, llama el Format(String, Object) método. La excepción se produce porque hay cuatro elementos de formato, pero sólo un único elemento en la lista formato.

Dado que Visual Basic ni C# puede convertir una matriz de enteros en una matriz de objetos, tendrá que realizar la conversión antes de llamar a la Format(String, Object[]) método. En el ejemplo siguiente se proporciona una implementación.

using System;
using System.Collections.Generic;

public class Example
{
   public static void Main()
   {
      Random rnd = new Random();
      int[]  numbers = new int[4];
      int total = 0;
      for (int ctr = 0; ctr <= 2; ctr++) {
         int number = rnd.Next(1001);
         numbers[ctr] = number;
         total += number;
      }   
      numbers[3] = total;
      object[] values = new object[numbers.Length];
      numbers.CopyTo(values, 0);
      Console.WriteLine("{0} + {1} + {2} = {3}", values);   
   }
}
Volver al principio
Mostrar: