Eksportuj (0) Drukuj
Rozwiń wszystko
Ten artykuł był przetłumaczony komputerowo. Oryginalny tekst zobaczysz, umieszczając wskaźnik myszy nad zdaniami w artykule. Więcej informacji.
Tłumaczenie
Oryginał

Metoda String.Format —

.NET Framework 4.5

Zastępuje każdy element formatu w podanym wyrażeniu formatowania, tekstem odpowiadającym wartości odpowiedniego obiektu.

Ten element członkowski jest przeciążony. Aby uzyskać pełne informacje dotyczące tego elementu członkowskiego, w tym informacje o jego składni i zastosowaniu oraz odpowiednie przykłady, kliknij nazwę na liście przeciążeń.

  Nazwa Opis
Metoda publiczna Statyczny element członkowski Format(String, Object) Zastępuje jeden lub więcej elementów formatu w ciągu określonego ciągu reprezentującego określonego obiektu.
Metoda publiczna Statyczny element członkowski Format(String, Object[]) Zastępuje element formatu w ciągu określonego ciągu reprezentującego odpowiedniego obiektu w określonej tablicy.
Metoda publiczna Statyczny element członkowski Format(IFormatProvider, String, Object[]) Zastępuje formatowanie elementu w ciągu określonego ciągu znaków reprezentującego odpowiadających im obiektów w określonej tablicy. Parametr dostarcza informacji o formatowaniu specyficzne dla kultury.
Metoda publiczna Statyczny element członkowski Format(String, Object, Object) Zastępuje formatowanie elementu w ciągu określonego ciągu reprezentującego dwóch określonych obiektów.
Metoda publiczna Statyczny element członkowski Format(String, Object, Object, Object) Zastępuje formatowanie elementu w ciągu określonego ciągu reprezentującego trzech określonych obiektów.
Początek

W tej sekcji:

Przeciążona metoda składni
Parametry
Wartość zwrócona
Wyjątki
Którą metodę należy wywołać?
Metoda formatowania w skrócie
Element formatu
Sposób formatowania argumentów
Elementy formatu o tym samym indeksie
Formatowanie i kultura
Niestandardowe formatowanie operacji
Przykłady:
       Formatowanie jednego argumentu
       Formatowanie dwóch argumentów
       Formatowanie trzy argumenty
       Formatowanie więcej niż trzy argumenty
       Formatowanie hodowli wrażliwych
       Operacja formatowania niestandardowego
       Dostawca punktu przecięcia z osią i liczby rzymskiej formatter
Informacje o wersji

Przeciążona metoda składni

Aby uzyskać dodatkowe wskazówki na temat wyboru przeciążenia, zobacz temat: Jakiej metody użyć do wywołania?

String String.Format(String format , Object arg0 )

Zamienia elementy formatu ciągu reprezentującego określony obiekt (przykład).

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

Zastępuje formatowanie elementu z reprezentacją ciągu dwóch określonych obiektów (przykład).

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

Zastępuje formatowanie elementu z reprezentacją ciągu trzech określonych obiektów (przykład).

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

Zastępuje formatowanie elementu z ciągu znaków reprezentującego odpowiadających im obiektów w określonej tablicy (przykład).

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

Zamienia elementy formatu ciągu reprezentującego odpowiadających im obiektów w określonej tablicy i używa określonego formatowania informacje specyficzne dla kultury (przykład) lub niestandardowe informacje o formatowaniu (przykład).

Parametry

To kompletna lista parametrów dla Format metody; zobacz Składnia przeciążenie powyżej parametry używane przez każdego przeciążenie. Tylko format parametr jest używany przez wszystkie przeciążenia.

Parametr

Typ

Opis

s

String

Ciąg formatu kompozytowe, która zawiera jeden lub więcej elementów formatu (zobacz element formatu).

arg0

String

Pierwszy lub tylko obiekt do sformatowania.

arg1

String

Drugi obiekt do sformatowania.

arg2

String

Trzeci obiekt do sformatowania.

args

String []

Zero lub więcej obiektów, aby sformatować, dostarczane w listę rozdzielaną przecinkami lub jako tablicę.

provider

IFormatProvider

Obiekt, który dostarcza informacji o formatowaniu niestandardowych lub specyficzne dla kultury.

Wartość zwrócona

Typ: String
Kopię format w którym elementy formatu zostały zastąpione ciągi znaków reprezentujące odpowiednie argumenty.

Wyjątki

Wyjątek

Warunek

Generowane przez

ArgumentNullException

format wynosi null.

Wszystkie przeciążenia.

FormatException

format jest nieprawidłowe.

-lub-

Indeks elementu format jest mniejsza niż zero, lub w większą lub równą liczbie argumentów na liście argumentów.

Wszystkie przeciążenia.

Którą metodę należy wywołać?

Do

Wywołanie

Sformatować jeden lub więcej obiektów przy użyciu konwencji bieżącej kultury.

Z wyjątkiem przeciążenie, który zawiera provider parametru, wszystkie Format obejmują overloads String parametr następuje jeden lub więcej parametrów obiektu. W związku z tym, trzeba określić, które Format przeciążenie zamierzasz wywołać. Twój kompilatora języka wybierze odpowiednie przeciążenie spośród overloads, które nie mają provider parametru, opartych na liście argumentów. Na przykład, jeśli lista argumentów obejmuje pięć argumentów, kompilator zgłosi się Format(String, Object[]) metody.

Sformatować jeden lub więcej obiektów przy użyciu Konwencji określonej kultury.

Format(IFormatProvider, String, Object[])

Wykonaj operację formatowania niestandardowego, albo z ICustomFormatter wykonania lub IFormattable wykonania.

Format(IFormatProvider, String, Object[])

Metoda formatowania w skrócie

Przeciążenie każdego z Format używa metody złożonego formatowania funkcji uwzględnienie zera indeksowanych symboli zastępczych, zwanych formatowania elementów w ciągu formatu kompozytowe. W czasie wykonywania każdy element formatu jest zastępowany ciąg reprezentujący odpowiedni argument na liście parametrów. Jeśli wartość argumentu jest null, jest zastępowany przez element formatu String.Empty. Na przykład, następujące wywołanie do Format(String, Object, Object, Object) metoda zawiera ciąg formatu z formatu trzy elementy, {0}, {1} i {2} a trzema elementami listy argumentów.


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.   


Element formatu

Element formatu ma następującej składni:

{ index[,alignment][ :formatString] }

Nawiasy oznaczają elementy opcjonalne. Otwieranie i zamykanie nawiasy klamrowe są wymagane. (Aby uwzględnić literału otwarcia lub zamykający nawias klamrowy w ciągu formatu, zobacz sekcję "Ucieczce nawiasy klamrowe" w Złożone formatowanie art.)

Na przykład element formatu na format, który może być wartość waluty wygląda następująco:


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


Element formatu składają się następujące elementy:

Indeks

Wartość indeksu argument, którego reprezentację ciąg ma być uwzględnione w tej pozycji w ciągu. Jeśli ten argument jest null, ciąg pusty, zostaną uwzględnione w tej pozycji w ciągu.

Wyrównanie

Opcjonalnie. Całkowita wskazująca całkowita długość pola, do którego dodaje się argument i czy jest wyrównany do prawej (dodatnia liczba całkowita) lub wyrównany do lewej (ujemną liczbą całkowitą). Jeżeli pominięto Wyrównanie, dodaje się ciąg reprezentujący odpowiedni argument w polu bez spacji wiodących i końcowych.

formatString

Opcjonalnie. Ciąg, który określa format odpowiedni argument ciąg wyniku. Jeżeli pominięto formatString, odpowiedni argument jest bez parametrów ToString do produkcji jego reprezentację ciąg wywoływana jest metoda. Jeśli określisz formatString, muszą implementować argument odwołuje się element formatu IFormattable interfejsu. Typy, które obsługują format ciągów:

Jednakże należy zauważyć, że każdy typ niestandardowy można zaimplementować IFormattable lub rozszerzyć istniejący typ IFormattable wykonania.

W poniższym przykładzie użyto alignment i formatString argumentów do utworzenia sformatowane dane wyjściowe.


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 %


Sposób formatowania argumentów

Elementy formatu są przetwarzane sekwencyjnie od początku ciągu znaków. Każdy element formatu ma indeks, który odnosi się do obiektu na liście argumentów metoda. Format Metoda pobiera argument i jego reprezentację ciąg wywodzi się w następujący sposób:

Dla przykładu, który przechwytuje wywołania ICustomFormatter.Format metody i pozwala zobaczyć, jakie informacje Format metoda przechodzi do formatowania metody dla każdego elementu format ciągu formatu kompozytowe zobacz przykład 7: Dostawca punktu przecięcia z osią i liczby rzymskiej formatter.

Elementy formatu o tym samym indeksie

Format Wyrzuca metoda FormatException wyjątek, jeśli indeks elementu indeksu jest większa niż lub równa liczbie argumentów na liście argumentów. Jednakże format mogą zawierać więcej elementów formatu niż argumentów, tak długo, jak wiele elementów formatu mają ten sam indeks. W wywołaniu Format(String, Object) metoda w poniższym przykładzie, lista argumentów ma jeden argument, ale ciąg formatu zawiera dwa elementy formatu: jeden Wyświetla wartość dziesiętną liczbę i wyświetla inne jego wartość szesnastkową.


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


Formatowanie i kultura

Ogólnie rzecz biorąc, obiekty na liście argumentów są konwertowane na ich oświadczenia ciąg przy użyciu konwencji bieżącej kultury, który jest zwracany przez CultureInfo.CurrentCulture właściwości. To zachowanie można kontrolować poprzez wywołanie Format(IFormatProvider, String, Object[]) przeciążenia. Tego przeciążenia provider jest parametr IFormatProvider proces wdrażania, dostarczający niestandardowe i specyficzne dla kultury informacje o formatowaniu, używanego do umiarkowanego formatowanie.

IFormatProvider Interfejs ma jeden element członkowski, GetFormat, który jest odpowiedzialny za zwrócenie obiekt, który zawiera informacje o formatowaniu. .NET Framework ma trzy IFormatProvider implementacji, które zapewniają specyficzne dla kultury formatowania:

Niestandardowe formatowanie operacji

Można również wywołać Format(IFormatProvider, String, Object[]) przeciążenie do wykonywania operacji formatowania niestandardowego. Można na przykład sformatować liczbę całkowitą jako numer identyfikacyjny lub numer telefonu. Aby wykonać formatowanie niestandardowe, Twój provider argument musi implementować zarówno IFormatProvider i ICustomFormatter interfejsów. Gdy Format(IFormatProvider, String, Object[]) metody jest przekazywany ICustomFormatter wykonania jako provider argument, Format wywołania metody jego IFormatProvider.GetFormat wdrażania i żąda obiektu typu ICustomFormatter. Następnie wywołuje zwracane ICustomFormatter obiektu Format metoda, aby formatować każdy element formatu w ciągu złożonego przekazywanych do niej.

Aby uzyskać więcej informacji o zapewnianiu niestandardowych rozwiązań formatowania, zobacz Porady: definiowanie i użycie niestandardowych dostawców formatu liczbowego i ICustomFormatter. Na przykład konwertuje liczby całkowite na sformatowany liczby niestandardowych, zobacz przykład 6: operację formatowania niestandardowego. Na przykład konwertuje bajtów bez znaku na cyfry rzymskie, zobacz przykład 7: Dostawca punktu przecięcia z osią i liczby rzymskiej formatter.

Przykład 1: Formatowanie jednego argumentu

W poniższym przykładzie użyto Format(String, Object) metoda osadzania wieku osoby w środku ciągu.


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.


Przykład 2: Formatowanie dwóch argumentów

W poniższym przykładzie użyto Format(String, Object, Object) metodę wyświetlania czasu i temperatury dane przechowywane w ogólnym Dictionary<TKey, TValue> obiektu. Należy zauważyć, że ciąg formatu, który ma trzy elementy formatu, chociaż istnieją tylko dwa obiekty, aby sformatować. To dlatego pierwszy obiekt na liście (wartość daty i godziny) jest używany przez dwa elementy formatu: pierwszy wyświetla element formatu czasu, a drugi służy do wyświetlania daty.


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


Przykład 3: Formatowanie trzech argumentów

W poniższym przykładzie użyto Format(String, Object, Object, Object) metoda, aby utworzyć ciąg, który pokazuje wynik wartość logiczna And operacji z dwóch wartości całkowitych. Pamiętaj, że ciąg formatu zawiera sześć elementów formatu, ale metoda ma tylko trzy pozycje w liście parametrów, ponieważ każdy element jest sformatowany na dwa różne sposoby.


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)


Przykład 4: Formatowanie więcej niż trzech argumentów

W tym przykładzie tworzony ciąg, który zawiera dane dotyczące wysokich i niskich temperatur w danym dniu. Ciąg formatu kompozytowe ma pięć elementów formatu w przykładzie C# i sześć w przykładzie Visual Basic. Dwa elementy formatu określić szerokość ich odpowiedniej wartości ciągu reprezentującego, a pierwszy element formatu zawiera także standardowy format daty i czasu ciąg formatu.


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)


Można również przekazać obiekty, które mają być sformatowane w postaci tablicy zamiast listy argumentów.


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


Przykład 5: Formatowanie z uwzględnieniem kultury

W poniższym przykładzie użyto Format(IFormatProvider, String, Object[]) metoda wyświetlania ciągu reprezentującego pewne wartości daty i godziny oraz wartości liczbowych przy użyciu kilku różnych 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


Przykład 6: Niestandardowe formatowanie operacji

W tym przykładzie definiuje format dostawca, który formatuje wartość całkowitą jako konta odbiorcy w formularzu 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.


Przykład 7: Intercept provider i program formatujący cyfry rzymskie

W tym przykładzie definiuje dostawcę formatu niestandardowego, który implementuje ICustomFormatter i IFormatProvider interfejsy, aby wykonać dwie czynności:

  • Wyświetla parametry przekazywane do jego ICustomFormatter.Format wykonania. Umożliwia nam to zobaczyć, jakie parametry Format(IFormatProvider, String, Object[]) metoda przechodzi do niestandardowej implementacji formatowania dla każdego obiektu, który próbuje sformatować. Może to być przydatne podczas debugowania aplikacji.

  • Jeśli obiekt ma być sformatowany jest wartość bajtu bez znaku, który jest sformatowany przy użyciu standardowego formatu ciągu "R", niestandardowego formatowania formatuje wartość numeryczną jako cyfr rzymskich.


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


Informacje o wersji

.NET Framework

Wszystkie przeciążenia są obsługiwane w wersjach: 4.5, 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile

Wszystkie przeciążenia są obsługiwane w wersjach: 4, 3.5 z dodatkiem SP1

Przenośne biblioteki klas

Tylko Format(String, Object[]) i Format(IFormatProvider, String, Object[]) są obsługiwane

Środowisko .NET dla aplikacji do Sklepu Windows

Tylko Format(String, Object[]) i Format(IFormatProvider, String, Object[]) są obsługiwane w systemie Windows 8

Zawartość społeczności

Dodaj
Pokaż:
© 2014 Microsoft