Exportar (0) Imprimir
Expandir todo
Este artículo proviene de un motor de traducción automática. Mueva el puntero sobre las frases del artículo para ver el texto original. Más información.
Traducción
Original

String.Format (Método)

Reemplaza los elementos de formato de una cadena especificada por el equivalente textual del valor de un objeto correspondiente.

Este miembro está sobrecargado. Para obtener información completa sobre este miembro, incluida la sintaxis, el uso y algunos ejemplos, haga clic en un nombre de la lista de sobrecarga.

  Nombre Descripción
Método público Miembro estático Format(String, Object) Reemplaza uno o varios elementos de formato de una cadena especificada con la representación de cadena de un objeto especificado.
Método público Miembro estático 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.
Método público Miembro estático Format(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.
Método público Miembro estático Format(String, Object, Object) Reemplaza los elementos de formato en una cadena especificada por la representación de cadena de dos objetos especificados.
Método público Miembro estático Format(String, Object, Object, Object) Reemplaza los elementos de formato de una cadena especificada por la representación de cadena de tres objetos especificados.
Arriba

En esta sección:

Sintaxis sobrecargada del método
Parámetros
Valor devuelto
Excepciones
¿Qué método denomino?
El método de formato en resumen
El elemento de formato
Cómo se da formato a los argumentos
Elementos de formato que tienen el mismo índice
Formato y referencia cultural
Operaciones de formato personalizadas
Ejemplos:
       Dar formato a un solo argumento
       Dar formato a dos argumentos
       Dar formato a tres argumentos
       Dar formato más de tres argumentos
       Formato Cultura-sensible
       Una operación de formato personalizado
       Un proveedor de la intersección y un formateador de número romano
Información de versión

Sintaxis sobrecargada del método

Para obtener orientación adicional sobre cómo elegir una sobrecarga, vea ¿Qué método denomino?

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 con representaciones de cadena de los objetos correspondientes en una matriz especificado (ejemplo).

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

Reemplaza los elementos de formato con la representación de cadena de los objetos correspondientes en una matriz especificado, y utiliza la información cultura- concreta especificada de formato (ejemplo) o la información de formato personalizado (ejemplo).

Parámetros

Ésta es una lista completa de parámetros para el método de Format ; vea la sintaxis de sobrecarga anteriormente para los parámetros utilizados por cada una. Sólo el parámetro de format utilizan todas las sobrecargas.

Parámetro

Tipo

Descripción

s

String

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

arg0

String

El primer o solo el objeto al 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 al formato, proporcionado en una lista delimitada por comas o como una matriz.

provider

IFormatProvider

Un objeto que personalizada de fuentes o información cultura- específica de formato.

Valor devuelto

Tipo: String
Una copia de format donde los elementos de formato han sido reemplazados por las representaciones de cadena de los argumentos correspondientes.

Excepciones

Excepción

Condition

Se produce por

ArgumentNullException

format es null.

Todos sobrecargas.

FormatException

format no es válido.

O bien

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.

Todos sobrecargas.

¿Qué método denomino?

A

Call

Dé formato a uno o más objetos con las convenciones de la referencia cultural actual.

Salvo la sobrecarga que incluye un parámetro de provider , todas las sobrecargas de Format incluyen un parámetro de String seguido de uno o más parámetros de objetos. Debido a esto, no tiene que determinar que la sobrecarga de Format desea llamar. El compilador de lenguaje seleccione la sobrecarga adecuada de entre las sobrecargas que no tienen un parámetro de provider , basándose en la lista de argumentos. Por ejemplo, si la lista de argumentos tiene cinco argumentos, el compilador llamará al método de Format(String, Object[]) .

Dé formato a uno o más objetos usando las convenciones de una referencia cultural concreta.

Format(IFormatProvider, String, Object[])

Realiza una operación de formato personalizado con una implementación de ICustomFormatter o una implementación de IFormattable .

Format(IFormatProvider, String, Object[])

El método de formato en resumen

Cada sobrecarga del método de Format utiliza característica de formato compuesto a los marcadores de posición indizados cero- basados incluyen, denominados elementos de formato, en una cadena de formato compuesto. 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. Si el valor del argumento es null, el elemento de formato se reemplaza con String.Empty. Por ejemplo, la siguiente llamada al método de Format(String, Object, Object, Object) incluye una cadena de formato con tres elementos de formato, {0}, {1}, y {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.   


El elemento de formato

Un elemento de formato tiene esta sintaxis:

{ index[,alignment][ :formatString] }

Los corchetes indican elementos opcionales. Se requieren las llaves de apertura y de cierre. (Para incluir una apertura o de cierre literal en la cadena de formato, vea “Escaping admite la sección” del artículo de Formatos compuestos .)

Por ejemplo, un elemento de formato para dar formato a una fuerza el valor de divisa aparece como ésta:


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


Un elemento de formato tiene los elementos siguientes:

í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 incluye en esta posición de la cadena.

alignment

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

el formatString

Opcional. Una cadena que especifica el formato de cadena correspondiente del resultado del argumento. Si omite el formatString, el método sin parámetros de ToString de argumento correspondiente se denomina para generar su representación de cadena. Si especifica el formatString, el argumento hace referencia al elemento de formato debe implementar la interfaz de IFormattable . Tipos de cadenas de formato compatible con incluyen:

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

El ejemplo siguiente utiliza los argumentos de alignment y de formatString al formato de producción.


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 %


Cómo se da formato a los argumentos

Los 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 la lista de argumentos del método. El método de Format recupera el argumento y deriva su representación de cadena como sigue:

Para obtener un ejemplo que intercepte llamadas a métodos de ICustomFormatter.Format y permiten considere qué información pasa el método de Format a un método de formato para cada elemento de formato en una cadena de formato compuesto, vea Ejemplo 7: Un proveedor de la intersección y un formateador de número romano.

Elementos de formato que tienen el mismo índice

El método de Format produce una excepción de FormatException si es el índice de un elemento index es mayor o igual que el número de argumentos en la lista de argumentos. Sin embargo, format puede incluir varios elementos de formato que hay argumentos, mientras los elementos de formato múltiple tienen el mismo índice. En la llamada al método de 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: una muestra el valor decimal de un número, y el otro 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


Formato y referencia cultural

Normalmente, los objetos de la lista de argumentos se convierten en sus representaciones de cadena con las convenciones de la referencia cultural actual, devuelta por la propiedad de CultureInfo.CurrentCulture . Puede controlar este comportamiento llamando a la sobrecarga de Format(IFormatProvider, String, Object[]) . El parámetro de provider de esta sobrecarga es una implementación de IFormatProvider que personalizada de fuentes y la información cultura- específica de formato que se utiliza para moderar el proceso de formato.

La interfaz de IFormatProvider tiene un solo miembro, GetFormat, que devuelve el objeto que proporciona información de formato. .NET Framework tiene tres implementaciones de IFormatProvider que proporcionan el formato cultura- concreto:

Operaciones de formato personalizadas

También puede llamar a la sobrecarga de Format(IFormatProvider, String, Object[]) para realizar operaciones de formato personalizadas. Por ejemplo, puede dar formato a un entero como un número de identificación o como un número de teléfono. Para realizar el formato personalizado, el argumento de provider debe implementar las interfaces de IFormatProvider y de ICustomFormatter . Cuando el método de Format(IFormatProvider, String, Object[]) se pasa una implementación de ICustomFormatter como argumento de provider , las llamadas al método de Format su implementación de IFormatProvider.GetFormat y solicitudes un objeto de ICustomFormatterescrito. Llama al método de Format de objeto devuelto de ICustomFormatter para dar formato a cada elemento de formato en la cadena formada pasada al.

Para obtener más información sobre 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 enteros a números personalizados con formato, vea Ejemplo 6: Una operación de formato personalizado. Para obtener un ejemplo que convierte bytes sin signo a números romanos, vea Ejemplo 7: Un proveedor de la intersección y un formateador de número romano.

Ejemplo 1: Dar formato a un solo argumento

En el siguiente ejemplo se usa el método Format(String, Object) para incrustar la edad de un individuo en mitad 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.


Ejemplo 2: Dar formato a dos argumentos

Este ejemplo utiliza el método de Format(String, Object, Object) para mostrar los datos de tiempo y de temperatura almacenados en un objeto genérico de Dictionary<TKey, TValue> . Observe que la cadena de formato tiene tres elementos de formato, aunque hay sólo dos objetos al formato. Esto es porque el primer objeto de la lista (un valor de fecha y hora) utiliza dos elementos de formato: El primer elemento de formato muestra el tiempo, 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


Ejemplo 3: Dar formato a tres argumentos

Este ejemplo utiliza el método de Format(String, Object, Object, Object) para crear una cadena que muestra el resultado de una operación booleana de And con dos valores enteros. Observe 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 se da formato a cada elemento 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)


Ejemplo 4: Dar formato más de tres argumentos

Este ejemplo crea una cadena que contiene datos de temperatura de máximo y mínimo 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, además el primer elemento de formato también incluye una cadena del formato de fecha y hora 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 dar formato como 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


Ejemplo 5: formato Cultura-sensible

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


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


Ejemplo 6: Una operación de formato personalizado

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


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.


Ejemplo 7: Un proveedor de la intersección y un formateador de número romano

Este ejemplo define un proveedor de formato personalizado que implemente las interfaces de ICustomFormatter y de IFormatProvider para realizar dos tareas:

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

  • Si el objeto que se va a dar formato es un valor sin signo de bytes que debe dar formato mediante la cadena de formato estándar “r”, el formateador personalizado da formato al valor numérico como 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


Información de versión

.NET Framework

Todas las sobrecargas se admiten en: 4,5, 4, 3,5, 3,0, 2,0, 1,1, 1,0

.NET Framework Client Profile

Todas las sobrecargas se admiten en: 4, 3,5 SP1

Biblioteca de clases portable

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

.NET para aplicaciones de la Tienda Windows

Sólo Format(String, Object[]) y Format(IFormatProvider, String, Object[]) se admiten en Windows 8

Adiciones de comunidad

AGREGAR
Mostrar:
© 2015 Microsoft