Exportovat (0) Tisk
Rozbalit vše
Tento článek byl přeložen strojově počítačem. Původní text zobrazíte přesunutím ukazatele myši nad jednotlivé věty článku. Další informace
Překlad
Originál

String.Format – metoda

Nahradí každou formátovací položku v zadaném řetězci textovým ekvivalentem odpovídající objekt hodnoty.

Tento člen je přetížen. Podrobnější informace o tomto členu, včetně syntaxe, způsobu použití a příkladů, získáte kliknutím na název v seznamu přetížení.

  Název Popis
Veřejná metoda Statický člen Format(String, Object) Nahradí formátovací položky v zadaném řetězci řetězcové vyjádření zadaného objektu.
Veřejná metoda Statický člen Format(String, Object[]) Nahradí formátovací položku v zadaném řetězci s řetězcovou reprezentací odpovídajícího objektu v určeném poli.
Veřejná metoda Statický člen Format(IFormatProvider, String, Object[]) Nahradí formátovací položky v zadaném řetězci řetězcových reprezentací odpovídajících objektů v určeném poli. Parametr poskytuje informace o formátování specifické pro jazykovou verzi.
Veřejná metoda Statický člen Format(String, Object, Object) Nahradí formátovací položky v zadaném řetězci řetězcové reprezentace dvou zadaných objektů.
Veřejná metoda Statický člen Format(String, Object, Object, Object) Nahradí formátovací položky v zadaném řetězci řetězcové vyjádření tři zadané objekty.
Nahoru

V této části:

Syntaxe přetížené metody
Parametry
Návratová hodnota
Výjimky
Jakou metodu mám volat?
Přehled metody Format
Formát položky
Formátování argumentů
Položky formátu, které mají stejný index
Formátování a jazyková verze
Vlastní operace formátování
Příklady:
       Formátování jediným argumentem.
       Formátování dva argumenty.
       Formátování tři argumenty.
       Formátování více než tři argumenty:
       Formátování jazykové
       Vlastní operace formátování
       Technologie intercept poskytovatele a formátovací modul římských číslic
Informace o verzi

Syntaxe přetížené metody

Další rady týkající se přetížení naleznete v tématu Jakou metodu můžu volat?

String String.Format(String format , Object arg0 )

Nahradí formátovací položky řetězcové vyjádření zadaného objektu (Příklad).

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

Nahradí formátovací položky s řetězcovou reprezentací dva zadané objekty (Příklad).

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

Nahradí formátovací položky s řetězcovou reprezentací tři zadané objekty (Příklad).

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

Nahradí formátovací položky řetězcových reprezentací odpovídajících objektů v zadaném poli (Příklad).

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

Nahradí formátovací položky s řetězcovou reprezentací odpovídajících objektů v zadaném poli a použije zadané informace o formátování specifické pro jazykovou verzi (Příklad) nebo vlastní informace o formátování (Příklad).

Parametry

Toto je úplný seznam parametrů pro Format metoda; Další informace o syntaxi přetížení nad parametry používané každé přetížení. Pouze format parametr je používán všechny přetížení.

Parametr

Type

Popis

s

String

Složený formátovací řetězec, který obsahuje jednu nebo více položek formátu (viz položka formátu).

arg0

String

První nebo pouze objekt, který chcete formátovat.

arg1

String

Druhý objekt pro formátování.

arg2

String

Třetí objekt pro formátování.

args

String []

Nula nebo více objektů, které chcete formátovat, dodávané v čárkami oddělený seznam nebo v matici.

provider

IFormatProvider

Objekt, který poskytuje informace o formátování specifické pro jazykovou verzi nebo vlastní.

Návratová hodnota

Zadejte: String
Kopie format v-které formát položky byly nahrazeny řetězcové vyjádření odpovídající argumenty.

Výjimky

Výjimka

Podmínka

Vyvolané

ArgumentNullException

format je null.

Všechna přetížení.

FormatException

format je neplatná.

-nebo-

Formát položky indexu je menší než nula, nebo větší než nebo rovno počtu argumentů v seznamu argumentů.

Všechna přetížení.

Jakou metodu mám volat?

Do

Volání

Formát jednoho nebo více objektů pomocí konvence aktuální jazykové verze.

Kromě přetížení, které zahrnuje provider parametr, všechny Format přetížení zahrnout String parametru následuje jeden nebo více parametrů objektu. Z tohoto důvodu nemáte určit, která Format chcete volat přetížení. Překladač jazyka vybere odpovídající přetížení z přetížení, které nemají provider parametr v seznamu argumentů. Například, pokud argument seznam obsahuje pět argumentů, kompilátor bude volat Format(String, Object[]) metody.

Formát jednoho nebo více objektů za použití konvencí konkrétní verze kultury.

Format(IFormatProvider, String, Object[])

Provést vlastní operace formátování se ICustomFormatter provedení nebo IFormattable provedení.

Format(IFormatProvider, String, Object[])

Přehled metody Format

Každé přetížení Format používá metodu funkce složeného formátování Chcete-li zahrnout od nuly indexovaných symboly nazývá položky formátu ve složeném formátovacím řetězci. V době běhu každá položka formátu nahrazena řetězcovou reprezentací odpovídajícího argumentu v seznamu parametrů. Pokud je hodnota argumentu null, položka formátu je nahrazen String.Empty. Například následující volání Format(String, Object, Object, Object) metoda obsahuje formátovací řetězec s tři formátovací položky {0}, {1} a {2} a seznam argumentů se třemi položkami.


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.   


Položka formátu

Položku formát má následující syntaxi:

{ index[,alignment][ :formatString] }

Závorky označují volitelné prvky. Otevírací a zavírací závorky jsou povinné. (Zahrnout literální znak počáteční nebo pravá složená závorka v řetězci formátu naleznete v oddílu "Uvozovací znaky závorky" Složené formátování článek.)

Formát položky do formátu, který může být hodnota měny se zobrazí takto:


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


Formát položky obsahuje následující prvky:

index

Z nuly vycházející index argument, jehož řetězcové vyjádření by měla být zahrnuta v této pozici v řetězci. Pokud je tento argument null, prázdný řetězec budou zahrnuty do tohoto umístění v řetězci.

zarovnání

Volitelné. Podepsané číslo, které udává celkovou délku pole, do které tento argument je vložena a zda je zarovnán doprava (kladné celé číslo) nebo doleva (záporné celé číslo). Vynecháte-li Zarovnání, řetězcové vyjádření odpovídající argument je vložena do pole bez počátečních a koncových mezer.

formatString

Volitelné. Řetězec, který určuje formát výsledného řetězce odpovídající argument. Vynecháte-li formatString, odpovídající argument společnosti bez parametrů ToString je volána metoda pro vytvoření řetězcovou reprezentaci. Zadáte-li formatString, musí implementovat argument odkazuje položka formátu IFormattable rozhraní. Obsahuje typy, které podporují formát řetězce:

Uvědomte si však, že každý vlastní typ implementovat IFormattable nebo rozšířit existující typ IFormattable provedení.

V následujícím příkladu alignment a formatString argumenty pro vytvoření formátovaného výstupu.


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 %


Formátování argumentů

Formát položky jsou zpracovány sekvenčně od začátku řetězce. Každá položka formátu má index, který odpovídá objektu v seznamu argumentů metody. Format Metoda načte argument a je odvozena jeho řetězcové vyjádření následujícím způsobem:

Pro příklad, který zachycuje volání ICustomFormatter.Format metoda a umožňuje zjistit, které informace Format viz metoda průchodech metoda formátování pro každou položku formátu ve složeném formátovacím řetězci příklad 7: technologie intercept poskytovatele a formátovací modul římské číslo.

Položky formátu, které mají stejný index

Format Metoda vyvolá FormatException výjimka Pokud index položky indexu je větší než nebo rovno počet argumentů v seznamu argumentů. Nicméně format může obsahovat více položek formátu, než je počet argumentů, tak dlouho, dokud více položek formátu mají stejný index. Při volání Format(String, Object) metoda v příkladu následující seznam argumentů má jediný argument, ale formátovací řetězec obsahuje dvě položky formát: jedna zobrazí desítkové hodnoty čísla a druhá se zobrazí její hexadecimální hodnotu.


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


Formátování a jazyková verze

Obecně objekty v seznamu argumentů jsou převedeny na jejich řetězcová vyjádření pomocí konvence aktuální jazykové verze, která je vrácena CultureInfo.CurrentCulture vlastnost. Toto chování můžete řídit pomocí volání Format(IFormatProvider, String, Object[]) přetížení. Toto přetížení provider parametr je IFormatProvider procesu implementace, která poskytuje vlastní a jazykové informace o formátování sloužící k střední formátování.

IFormatProvider Rozhraní má jediný člen GetFormat, která je zodpovědná za vrácení objektu, který poskytuje informace o formátování. Rozhraní.NET Framework obsahuje tři IFormatProvider implementace, které poskytují formátování specifické pro jazykovou verzi:

Vlastní operace formátování

Můžete také volat Format(IFormatProvider, String, Object[]) přetížení provádět vlastní operace formátování. Například můžete naformátovat integer jako identifikační číslo nebo telefonní číslo. Provádět vlastní formátování vašeho provider argument musí implementovat i IFormatProvider a ICustomFormatter rozhraní. Při Format(IFormatProvider, String, Object[]) je metodě předán ICustomFormatter provedení jako provider argument, Format volání metody jeho IFormatProvider.GetFormat provedení a požádá o objekt typu ICustomFormatter. Potom zavolá vráceného ICustomFormatter objektu Format předány metoda pro každou položku formátu ve složeném řetězec formátování.

Další informace o poskytování vlastních řešení formátování naleznete v tématu Postupy: Definování a používání vlastních poskytovatelů číselného formátu a ICustomFormatter. Pro příklad, který převádí do vlastního formátu čísla celá čísla, viz příklad 6: vlastní operace formátování. Příklad převede bajtů bez znaménka na římské číslice, naleznete v tématu příklad 7: technologie intercept poskytovatele a formátovací modul římské číslo.

Příklad 1: Formátování jednoho argumentu

V následujícím příkladu Format(String, Object) metoda vložit věk osoby uvnitř řetězce.


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.


Příklad 2: Formátování dvou argumentů

V tomto příkladu Format(String, Object, Object) metoda zobrazení času a teploty data uložená v obecný Dictionary<TKey, TValue> objektu. Všimněte si, že řetězec formátu má tři položky formát, i když existují pouze dva objekty k formátování. Důvodem je, že první objekt v seznamu (hodnota data a času) používá dvě položky formát: první položka zobrazí formát čas a druhý zobrazí datum.


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


Příklad 3: Formátování tří argumentů

V tomto příkladu Format(String, Object, Object, Object) metoda vytvořit řetězec, který znázorňuje výsledek logickou hodnotu And operace s dvěma celočíselné hodnoty. Poznámka: formátovací řetězec obsahuje šest položek formátu, že metoda má pouze tři položky v jeho seznamu parametrů, protože každá položka formátována dvěma různými způsoby.


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)


Příklad 4: Formátování více než tří argumentů

Tento příklad vytvoří řetězec, který obsahuje údaje o vysoké a nízké teploty k určitému datu. Složený formátovací řetězec obsahuje pět položek formátu v příkladu C# a šest v příklad jazyka Visual Basic. Dvě položky formátu definovat šířku řetězcové vyjádření jejich odpovídající hodnotu a je první položka formátu je také standardní datum a čas formátovacího řetězce.


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)


Můžete také předat objekty, které chcete formátovat jako pole spíše než seznam argumentů.


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


Příklad 5: Formátování zohledňující jazykovou verzi

V tomto příkladu Format(IFormatProvider, String, Object[]) metoda zobrazení řetězcové vyjádření některých hodnot data a času a číselné hodnoty pomocí několika různých kultur.


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


Příklad 6: Vlastní operace formátování

Tento příklad definuje poskytovatele formátu, který naformátuje číslo účtu odběratele ve formuláři x-xxxxx-xx celočíselnou hodnotu.


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.


Příklad 7: Poskytovatel zachycení a formátovací modul římských číslic

Tento příklad definuje vlastní formát zprostředkovatele, který implementuje ICustomFormatter a IFormatProvider rozhraní, provést dvě věci:

  • Zobrazí parametry předány do jeho ICustomFormatter.Format provedení. Díky tomu nám chcete-li zjistit, jaké parametry Format(IFormatProvider, String, Object[]) metoda předává na vlastní implementaci formátování pro každý objekt, který se pokusí o formátování. To může být užitečné při ladění aplikace.

  • Je-li objekt, který má být formátován nepodepsané bajt, který má být formátován pomocí standardní formátovací řetězec "R", vlastní formátovací modul číselnou hodnotu formátu římských číslic.


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


Informace o verzi

.NET Framework

Verze s podporou všech přetížení: 4.5, 4, 3.5, 3.0, 2.0, 1.1, 1.0

Profil klienta rozhraní .NET Framework

Verze s podporou všech přetížení: 4, 3.5 SP1

Přenosná knihovna tříd

Pouze Format(String, Object[]) a Format(IFormatProvider, String, Object[]) jsou podporovány

Aplikace .NET pro Windows Store

Pouze Format(String, Object[]) a Format(IFormatProvider, String, Object[]) jsou podporovány v systému Windows 8

Obsah vytvořený komunitou

Přidat
Zobrazit:
© 2014 Microsoft