Exportar (0) Imprimir
Expandir Tudo
Este artigo foi traduzido por máquina. Coloque o ponteiro do mouse sobre as frases do artigo para ver o texto original. Mais informações.
Tradução
Original

Método String.Format

Substitui cada item de formato em uma cadeia de caracteres especificada com o equivalente de texto do valor correspondente de um objeto.

Esse membro está sobrecarregado. Para informação completa sobre esse membro, incluindo sintaxe, uso e exemplos, clique em um nome na lista de sobrecargas.

  Nome Descrição
Método público Membro estático Format(String, Object) Substitui um ou mais itens de formato em uma String especificada com a representação de String de um objeto especificado.
Método público Membro estático Format(String, Object[]) Substitui o item de formato em uma String especificada com a representação de String de um objeto correspondente em um array especificado.
Método público Membro estático Format(IFormatProvider, String, Object[]) Substitui os itens de formato em uma cadeia de caracteres especificada com as representações de cadeia de caracteres de objetos correspondentes em uma matriz especificada. Um parâmetro fornece informações específicas à cultura específica de formatação.
Método público Membro estático Format(String, Object, Object) Substitui os itens de formato em uma String especificada com a representação de String de dois objetos especificados.
Método público Membro estático Format(String, Object, Object, Object) Substitui os itens de formato em uma String especificada com a representação de String de três objetos especificados.
Superior

Nesta seção:

Sintaxe de método sobrecarregada
Parâmetros
Valor de retorno
Exceções
Qual método devo chamar?
O método Format resumido
O item de formato
Como os argumentos são formatados
Itens de formato que têm o mesmo índice
Formatação e cultura
Operações de formatação personalizadas
Exemplos:
       Formatando um único argumento
       Formatando dois argumentos
       Formatando três argumentos
       Formatando mais de três argumentos
       Formatação a cultura acentos
       Uma operação de formatação personalizada
       Um provedor de interceptação e um formatador de numeral romano
Informações de versão

Sintaxe de método sobrecarregada

Para obter orientação adicional sobre como escolher uma sobrecarga, consulte Qual método devo chamar?

String String.Format(String format , Object arg0 )

Substitui os itens de formato com a representação de cadeia de caracteres de um objeto especificado (exemplo).

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

Substitui os itens de formato com a representação de cadeia de caracteres de dois objetos especificadosexemplo().

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

Substitui os itens de formato com a representação de cadeia de caracteres de três objetos especificados (exemplo).

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

Substitui os itens de formato com as representações de cadeia de caracteres de objetos correspondentes em uma matriz especificadaexemplo().

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

Substitui os itens de formato com a representação de cadeia de caracteres de objetos correspondentes em uma matriz especificada, e usa as informações específicas à cultura específica especificada de formatação (exemplo) ou as informações de formatação personalizada (exemplo).

Parâmetros

Esta é uma lista completa de parâmetros para o método de Format ; consulte a sintaxe de sobrecarga acima para os parâmetros usados por cada sobrecarga. Somente o parâmetro de format é usado por todas as sobrecargas.

PARAMETER

Tipo

Descrição

s

String

Uma cadeia de formato composta que contém um ou mais itens de formato (consulte O item de formato).

arg0

String

O primeiro ou o objeto no formato.

arg1

String

O segundo objeto a ser formatado.

arg2

String

O terceiro objeto a ser formatado.

args

String []

Zero ou mais objetos no formato, fornecido em uma lista delimitada por vírgulas ou como uma matriz.

provider

IFormatProvider

Um objeto que fornece as informações personalizadas ou cultura específica de formatação.

Valor de retorno

Tipo: String
Uma cópia de format em que os itens de formato foram substituídos por representações de cadeia de caracteres dos argumentos correspondentes.

Exceções

Exception

Condição

Lançado por

ArgumentNullException

format é null.

Todas as sobrecargas.

FormatException

format é inválida.

-ou-

O índice de um item de formato é menor que zero, ou maior ou igual ao número de argumentos na lista de argumentos.

Todas as sobrecargas.

Qual método devo chamar?

TO

Call

Formatar um ou mais objetos usando as convenções de cultura atual.

Com exceção de sobrecarga que inclui um parâmetro de provider , todas as sobrecargas de Format incluem um parâmetro de String seguido por um ou mais parâmetros do objeto. Por isso, não é necessário determinar quais sobrecarga de Format você pretende chamar. Seu compilador de idioma apropriado entre selecionará a sobrecarga das sobrecargas que não têm um parâmetro de provider , com base em sua lista de argumentos. Por exemplo, se a lista de argumentos tem cinco argumentos, o compilador chamará o método de Format(String, Object[]) .

Formatar um ou mais objetos usando as convenções de uma determinada cultura.

Format(IFormatProvider, String, Object[])

Executar uma operação personalizada de formatação com uma implementação de ICustomFormatter ou uma implementação de IFormattable .

Format(IFormatProvider, String, Object[])

O método Format resumido

Cada sobrecarga do método de Format usa recursos de formatação composto para incluir espaços reservados indexados com base em zero, itens de formato chamadas, em uma cadeia de formato composta. Em tempo de execução, cada item de formato é substituído pela representação de cadeia de caracteres do argumento correspondente em uma lista de parâmetros. Se o valor do argumento for null, o item de formato é substituído por String.Empty. Por exemplo, o seguinte chamada ao método de Format(String, Object, Object, Object) inclui uma cadeia de formato com três itens de formato, {0}, {1}, e {2}, e uma lista de argumento com três itens.


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.   


O item de formato

Um item de formato tem esta sintaxe:

{ index[,alignment][ :formatString] }

Os colchetes denotam os elementos opcionais. A abertura e fechamento as chaves são necessárias. (Para incluir uma chave literal de abertura ou fechar a cadeia de caracteres de formato, consulte a seção “chaves de escape” no artigo de Formatação composta .)

Por exemplo, um item de formato para formatar um valor monetário será algo como:


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


Um item de formato tem os seguintes elementos:

índice

O índice de base zero do argumento cuja representação de cadeia de caracteres deve ser incluída nessa posição na cadeia de caracteres. Se esse argumento for null, uma cadeia de caracteres vazia será incluída nessa posição na cadeia de caracteres.

alinhamento

Opcional. Um inteiro que indica o comprimento total do campo no qual o argumento é inserido e se ele está alinhado (um inteiro positivo) ou alinhada (um inteiro negativo). Se você omitir alinhamento, a representação de cadeia de caracteres do argumento correspondente será inserida em um campo sem os espaços à esquerda ou direita.

formatString

Opcional. Uma cadeia de caracteres que especifica o formato de cadeia de caracteres de resultado correspondente do argumento. Se você omitir formatString, o método sem parâmetros de ToString do argumento correspondente é chamado para gerar sua representação de cadeia de caracteres. Se você especificar formatString, o argumento referenciado pelo item de formato deve implementar a interface de IFormattable . Tipos que as cadeias de formato de suporte incluem:

No entanto, observe que qualquer tipo personalizado pode implementar IFormattable ou estender a implementação existente de IFormattable de um tipo.

O exemplo a seguir usa os argumentos de alignment e de formatString para gerar a saída formatada.


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 %


Como os argumentos são formatados

Os itens de formato são processados em sequência desde o início da cadeia de caracteres. Cada item de formato tem um índice que corresponde a um objeto na lista de argumentos de método. O método de Format recupera o argumento e derivar sua representação de cadeia de caracteres como segue:

  • Se o argumento for null, o método insere String.Empty na cadeia de caracteres de resultado.

  • Se você chamar a sobrecarga de Format(IFormatProvider, String, Object[]) e as ferramentas do parâmetro de provider a interface de ICustomFormatter , o argumento será passado ao método de ICustomFormatter.Format(String, Object, IFormatProvider) do objeto de provider . Se o item de formato inclui um argumento de formatString , será passado como o primeiro argumento para o método. Se a implementação de ICustomFormatter pode fornecer serviços de formatação, retorna uma representação de cadeia de caracteres do argumento; caso contrário, retorna null e a próxima etapa é executado.

  • Se o argumento implementa a interface de IFormattable , sua implementação de IFormattable.ToString será chamada.

  • O método sem parâmetros de ToString do argumento, que é substituído ou herdada da classe de Object , é chamado.

Para obter um exemplo que intercepte chamadas para o método de ICustomFormatter.Format e permitem que você considere informações que o método de Format passa para um método de formatação para cada item de formato em uma cadeia de formato composta, consulte Exemplo 7: Um provedor de interceptação e um formatador de numeral romano.

Itens de formato que têm o mesmo índice

O método de Format gerará uma exceção de FormatException se o índice de um item de índice é maior ou igual ao número de argumentos na lista de argumentos. No entanto, format pode incluir mais itens de formato de que há argumentos, como vários itens de formato têm o mesmo índice. Na chamada ao método de Format(String, Object) no exemplo a seguir, a lista de argumentos tem um único argumento, mas a cadeia de caracteres de formato inclui dois itens de formato: um exibe o valor decimal de um número e o outro, exibe o 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


Formatação e cultura

Em geral, os objetos na lista de argumentos são convertidos em suas representações de cadeia de caracteres usando as convenções de cultura atual, que é retornada pela propriedade de CultureInfo.CurrentCulture . Você pode controlar esse comportamento chamando a sobrecarga de Format(IFormatProvider, String, Object[]) . O parâmetro de provider dessa sobrecarga é uma implementação de IFormatProvider que fornece informações personalizadas e a cultura específica de formatação que é usada para moderar o processo de formatação.

A interface de IFormatProvider tem um único membro, GetFormat, que é responsável para retornar o objeto que fornece informações de formatação. O.NET Framework tem três implementações de IFormatProvider que fornecem a formatação cultura específica:

Operações de formatação personalizadas

Você também pode chamar a sobrecarga de Format(IFormatProvider, String, Object[]) para executar operações de formatação personalizadas. Por exemplo, você pode formatar um valor inteiro como um número de identificação ou como um número de telefone. Para executar a formatação personalizada, o argumento de provider deve implementar as interfaces de IFormatProvider e de ICustomFormatter . Quando o método de Format(IFormatProvider, String, Object[]) é passado uma implementação de ICustomFormatter como o argumento de provider , o método de Format chama sua implementação de IFormatProvider.GetFormat e solicitar um objeto de tipo ICustomFormatter. Chame o método retornado de Format do objeto de ICustomFormatter para formatar cada item de formato na cadeia de caracteres passada composta a ele.

Para obter mais informações sobre como fornecer soluções de formatação personalizadas, consulte Como definir e usar provedores de formatos numéricos personalizados e ICustomFormatter. Para obter um exemplo que converte números inteiros para números formatados personalizados, consulte Exemplo 6: Uma operação de formatação personalizada. Para obter um exemplo que converta bytes sem assinatura para numerais romanos, consulte Exemplo 7: Um provedor de interceptação e um formatador de numeral romano.

Exemplo 1: formatando um único argumento

O exemplo a seguir usa o método Format(String, Object) para incorporar a idade de uma pessoa no meio de uma seqüência de caracteres.


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.


Exemplo 2: formatando dois argumentos

Este exemplo usa o método de Format(String, Object, Object) para exibir temporal e os dados TEMP armazenados em Dictionary<TKey, TValue> genérico objeto. Observe que a cadeia de formato tem três itens de formato, embora exista apenas dois objetos no formato. Isso ocorre porque o primeiro objeto na lista (um valor de data e hora) é usado por dois itens de formato: O primeiro item de formato exibe a hora e o segundo, exibe a data.


using System;
using System.Collections.Generic;

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

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


Exemplo 3: formatando três argumentos

Este exemplo usa o método de Format(String, Object, Object, Object) para criar uma cadeia de caracteres que mostra o resultado de uma operação booliana de And com os dois valores inteiros. Observe que a cadeia de caracteres de formato inclui seis itens de formato, mas o método só tem três itens na lista de parâmetro, porque cada item é formatado de duas maneiras 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)


Exemplo 4: formatando mais de três argumentos

Este exemplo cria uma cadeia de caracteres que contém dados na temperatura de alto e baixo em uma data específica. A cadeia de caracteres de formato composta tem cinco formatar itens no exemplo do C# e seis no exemplo do Visual Basic. Dois dos itens de formato definem a largura da representação de cadeia de caracteres correspondente de seu valor, e o primeiro item de formato também inclui uma cadeia de formato padrão de data e hora.


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)


Você também pode passar os objetos a serem formatados como uma matriz em vez de uma 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


Exemplo 5: formatação sensível à cultura

Este exemplo usa o método de Format(IFormatProvider, String, Object[]) para exibir a representação de cadeia de caracteres de alguns valores de data e hora e valores numéricos usando várias culturas 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


Exemplo 6: uma operação de formatação personalizada

Este exemplo define um provedor de formato que formatou um valor inteiro como um número de conta de cliente em x-xxxxx-xx de formulário.


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.


Exemplo 7: um provedor de interceptação e formatador de algarismo romano

Este exemplo define um provedor personalizado de formato que implementa as interfaces de ICustomFormatter e de IFormatProvider para fazer duas coisas:

  • Exibe os parâmetros passados à sua implementação de ICustomFormatter.Format . Isso habilita-nos para consultar quais parâmetros do método Format(IFormatProvider, String, Object[]) estiver passando à implementação personalizada de formatação para cada objeto que tenta formatar. Isso pode ser útil quando você estiver depurando seu aplicativo.

  • Se o objeto a ser formatado for um valor não assinado de bytes que deve ser formatado usando a cadeia de caracteres de formato padrão de “R”, o formatador personalizado para o valor numérico como um numeral 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


Informações de versão

.NET Framework

Todas as sobrecargas são suportadas em: 4.5, 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile

Todas as sobrecargas são suportadas em: 4, 3.5 SP1

Biblioteca de Classes Portátil

Somente Format(String, Object[]) e Format(IFormatProvider, String, Object[]) têm suporte

.NET para aplicativos da Windows Store

Somente Format(String, Object[]) e Format(IFormatProvider, String, Object[]) têm suporte no Windows 8

Contribuições da comunidade

ADICIONAR
A Microsoft está realizando uma pesquisa online para saber sua opinião sobre o site do MSDN. Se você optar por participar, a pesquisa online lhe será apresentada quando você sair do site do MSDN.

Deseja participar?
Mostrar:
© 2014 Microsoft