Esporta (0) Stampa
Espandi tutto
Il presente articolo è stato tradotto automaticamente. Passare il puntatore sulle frasi nell'articolo per visualizzare il testo originale. Ulteriori informazioni.
Traduzione
Originale

Metodo String.Format

Consente di sostituire ogni elemento di formato presente in una stringa specificata con l'equivalente in forma di testo del valore di un oggetto corrispondente.

Si tratta di un membro di overload. Per informazioni complete su questo membro, inclusi la sintassi, l'utilizzo e gli esempi, fare clic su un nome nell'elenco degli overload.

  Nome Descrizione
Metodo pubblico Membro statico Format(String, Object) Consente di sostituire uno o più elementi di formato in una stringa specificata con la rappresentazione in forma di stringa di un oggetto specificato.
Metodo pubblico Membro statico Format(String, Object[]) Consente di sostituire l'elemento di formato presente in una stringa specificata con la rappresentazione in forma di stringa di un oggetto corrispondente in una matrice specificata.
Metodo pubblico Membro statico Format(IFormatProvider, String, Object[]) Consente di sostituire gli elementi di formato presenti in una stringa specificata con le rappresentazioni in forma di stringa di oggetti corrispondenti in una matrice specificata. Un parametro fornisce le informazioni di formattazione specifiche delle impostazioni cultura.
Metodo pubblico Membro statico Format(String, Object, Object) Consente di sostituire gli elementi di formato presenti in una stringa specificata con la rappresentazione di stringa di due oggetti specificati.
Metodo pubblico Membro statico Format(String, Object, Object, Object) Consente di sostituire gli elementi di formato in una stringa specificata con le rappresentazioni in forma di stringa di tre oggetti specificati.
In alto

Contenuto della sezione:

Sintassi di overload del metodo
Parametri
Valore restituito
Eccezioni
Quale metodo viene chiamato?
Il metodo Format in breve
L'oggetto Format
Come gli argomenti vengono formattati
Elementi di Format che hanno lo stesso indice
La formattazione e impostazioni cultura
Operazioni di formattazione personalizzata
Esempi:
       Formattare un singolo argomento
       Formattare due argomenti
       Formattare tre argomenti
       Formattare più di tre argomenti
       Formattazione dipendente dalle impostazioni cultura
       Un'operazione di formattazione personalizzata
       Un provider dell'intercettazione e un formattatore di un numero romano
Informazioni sulla versione

Sintassi di overload del metodo

Per ulteriori istruzioni sulla scelta di un overload, consultare Quale metodo viene chiamato?

String String.Format(String format , Object arg0 )

Sostituisce gli elementi di Format con la rappresentazione di una stringa di un oggetto specificato (esempio).

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

Sostituisce gli elementi di Format con la rappresentazione di una stringa di due oggetti specificati (esempio).

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

Sostituisce gli elementi di Format con la rappresentazione di una stringa di tre oggetti specificati (esempio).

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

Consente di sostituire gli elementi di Format presenti in una stringa specificata con le rappresentazioni di stringa di oggetti corrispondenti in un array specificato (esempio).

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

Sostituisce gli elementi di format con la rappresentazione di stringa degli oggetti corrispondenti in un array specificato e utilizza le informazioni specifiche delle impostazioni cultura specificate di formattazione (esempio) o le informazioni personalizzate di formattazione (esempio).

Parametri

Questo è un elenco completo dei parametri per il metodo Format; vedere la sintassi dell'overload precedente per i parametri utilizzati da ogni overload. Solo il parametro format viene utilizzato da tutti gli overload.

Parametro

Tipo

Descrizione

s

String

Una stringa di format composto che include uno o più elementi di format (consultare L'elemento di format.

arg0

String

Il primo o l'unico oggetto da formattare.

arg1

String

Secondo oggetto da formattare.

arg2

String

Terzo oggetto da formattare.

args

String []

Zero o più oggetti da formattare, fornito in un elenco delimitato da virgole o array.

provider

IFormatProvider

Oggetto che fornisce informazioni personalizzate o sulla formattazione relative alle impostazioni cultura specificate.

Valore restituito

Tipo: String
Una copia di format in cui gli elementi di format sono stati sostituiti dalla rappresentazione della stringa nei corrispondenti argomenti.

Eccezioni

Exception

Condizione

Eccezione generata da

ArgumentNullException

format è null.

Tutti gli overload.

FormatException

format non è valido.

- oppure -

L'indice di un elemento di format è minore di 0 (zero) o maggiore o uguale al numero degli argomenti nella lista di quest'ultimi.

Tutti gli overload.

Quale metodo viene chiamato?

A

Call

Formattare uno o più oggetti utilizzando le convenzioni delle impostazioni cultura correnti.

Ad eccezione dell'overload che include un parametro provider, tutti gli overload Format includono un parametro String seguito da uno o più parametri dell'oggetto. Per questo motivo, non è necessario determinare quali overload Format si desidera chiamare. Il compilatore del proprio linguaggio selezionerà l'overload appropriato tra quelli che non dispongono di un parametro provider, in base all'elenco di argomenti. Ad esempio, se il proprio elenco di argomenti ne contiene cinque, il compilatore chiamerà il metodo Format(String, Object[]).

Formattare uno o più oggetti utilizzando le convenzioni di una specifica impostazioni cultura.

Format(IFormatProvider, String, Object[])

Eseguire un'operazione di formattazione personalizzata con un'implementazione ICustomFormatter o un'implementazione IFormattable.

Format(IFormatProvider, String, Object[])

Il metodo Format in breve

Ogni overload del metodo Format utilizza funzionalità di formattazione composta per includere segnaposti indicizzati in base zero, denominati elementi di format, in una stringa di format composto. In fase di esecuzione, ogni elemento di format viene sostituito con una rappresentazione in stringa dell'oggetto corrispondente nell'elenco. Se il valore dell'argomento è null, l'elemento di format viene sostituito con String.Empty. Ad esempio, la seguente chiamata al metodo Format(String, Object, Object, Object) include una stringa di format con tre elementi di format, {0} {1,} e {2} e un elenco di argomenti con tre elementi.


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.   


L'elemento format

Un elemento format con questa sintassi:

{ index[,alignment][ :formatString] }

Le parentesi indicano gli elementi facoltativi. Le parentesi graffe di apertura e chiusura sono richieste. (Per includere un letterale do apertura o una parentesi graffa di chiusura nella stringa di format, consultare la sezione"Parentesi Graffe" nell'articolo Formattazione composta ).

Ad esempio, un elemento di format per formattare una limitazione dei valori di valuta appare come segue:


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


Un elemento di format presenta gli elementi seguenti:

indice

L'indice in base zero dell'argomento della rappresentazione di stringa deve essere inclusa in questa posizione nella stringa. Se questo argomento è null, una stringa vuota verrà inclusa in questa posizione nella stringa.

allineamento

Facoltativa. Un intero signed che indica la lunghezza totale del campo in cui l'argomento è inserito e se è allineato a destra (intero positivo) o allineato a sinistra (intero negativo). Se si omette allineamento, la rappresentazione di stringa dell'argomento corrispondente viene inserita in un campo senza spazi iniziali o finali.

:formatString

Facoltativa. Una stringa che specifica il formato della stringa di risultato corrispondente dell'argomento. Se si omette formatString, il metodo senza parametri ToString dell'argomento corrispondente viene chiamato per produrre la rappresentazione di stringa. Se si specifica formatString, l'argomento referenziato dall'elemento di format deve implementare l'interfaccia IFormattable. I tipi che supportano le stringhe di format sono:

Tuttavia, si noti che qualsiasi tipo personalizzato può implementare IFormattable o estendere l'implementazione esistente IFormattable di un tipo.

Nell'esempio seguente vengono utilizzati gli argomenti formatString e alignment per generare l'output formattato.


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 %


Come gli argomenti vengono formattati

Gli elementi di format vengono elaborati in sequenza dall'inizio della stringa. Ogni elemento di format è un indice corrispondente a un oggetto nell'elenco di argomenti del metodo. Il metodo Format recupera l'argomento e deriva la relativa rappresentazione di stringa seguente:

Per un esempio in cui si intercettano le chiamate al metodo ICustomFormatter.Format e consente di visualizzare quali informazioni il metodo Format passa a un metodo di formattazione per ogni elemento di format in una stringa di format composto, consultare Esempio 7: Un provider dell'intercettazione e un formattatore di numero romano.

Elementi di Format che hanno lo stesso indice

Il metodo Format genera un'eccezione FormatException se l'indice di un elemento dell'indice è maggiore o uguale al numero di argomenti dell'elenco di argomenti. Tuttavia, format può includere più elementi di format dove sono presenti argomenti, purché gli elementi di format abbiano lo stesso indice. Nella chiamata al metodo Format(String, Object) nell'esempio seguente, l'elenco di argomenti dispone di un unico argomento, ma la stringa di format include due elementi di format: uno visualizza il valore decimale di un numero e l'altro visualizza il relativo valore esadecimale.


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


La formattazione e impostazioni cultura

In genere, gli oggetti nell'elenco di argomenti vengono convertiti in rappresentazioni di stringa utilizzando le convenzioni delle impostazioni cultura correnti, restituiti dalla proprietà CultureInfo.CurrentCulture. È possibile controllare questo comportamento chiamando l'overload Format(IFormatProvider, String, Object[]). Il parametro provider di questo overload è un'implementazione IFormatProvider che fornisce le informazioni personalizzate e la formattazione specifica delle impostazioni cultura utilizzate per moderare il processo di formattazione.

L'interfaccia IFormatProvider dispone di un singolo membro, GetFormat, responsabile della restituzione dell'oggetto che fornisce informazioni di formattazione. .NET Framework presenta le implementazioni IFormatProvider che forniscono la formattazione delle impostazioni cultura:

  • CultureInfo . Il metodo GetFormat restituisce un determinato oggetto delle impostazioni cultura NumberFormatInfo per formattare valori numerici e un oggetto specifico delle impostazioni cultura DateTimeFormatInfo per formattare valori di data e ora.

  • DateTimeFormatInfo , utilizzato per la formattazione specifica delle impostazioni cultura di valori di data e ora. Il metodo GetFormat restituisce sé stesso.

  • NumberFormatInfo , utilizzato per la formattazione specifica delle impostazioni cultura di valori numerici. La proprietà GetFormat restituisce sé stesso.

Operazioni di formattazione personalizzata

È inoltre possibile chiamare l'overload Format(IFormatProvider, String, Object[]) per eseguire operazioni di formattazione personalizzata. Ad esempio, è possibile formattare un integer come un numero di identificazione o come un numero di telefono. Per eseguire la formattazione personalizzata, l'argomento provider deve implementare le interfacce ICustomFormatter che IFormatProvider. Quando il metodo Format(IFormatProvider, String, Object[]) viene passato a un'implementazione ICustomFormatter come argomento provider, il metodo Format chiama la propria implementazione IFormatProvider.GetFormat e richiede un oggetto di tipo ICustomFormatter. Chiama quindi il metodo Format dell'oggetto restituito ICustomFormatter per formattare ogni elemento di format nella stringa passata.

Per ulteriori informazioni sulla creazione di soluzioni di formattazione personalizzata, consultare Procedura: definire e utilizzare provider di formati numerici personalizzati e ICustomFormatter. Per un esempio con converta interi in numeri personalizzati formattati, consultare Esempio 6: Un'operazione di formattazione personalizzata. Per un esempio in cui si convertono byte unsigned in numeri romani, consultare Esempio 7: Un provider dell'intercettazione e un formattatore di numeri romani.

Esempio 1: Formattare un singolo argomento

Nell'esempio riportato di seguito viene utilizzato il metodo Format(String, Object) per incorporare l'età di un individuo nel centro di una stringa.


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.


Esempio 2: Formattare due argomenti

Nell'esempio seguente viene utilizzato il metodo Format(String, Object, Object) per visualizzare i dati relativi all'ora e alla temperatura archiviati in un oggetto Dictionary<TKey, TValue> generico. Notare che la stringa di format dispone di tre elementi di format, mentre ci sono solo due oggetti da formattare. Questo perché il primo oggetto nell'elenco (un valore di data e ora) viene utilizzato da due elementi di format: il primo elemento di format visualizza l'ora e il secondo visualizza la 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


Esempio 3: Formattare tre argomenti

Nell'esempio seguente viene utilizzato il metodo Format(String, Object, Object, Object) per creare una stringa che illustra il risultato di un'operazione And booleana con due Integer. Notare che la stringa di formato include sei elementi di formato, ma il metodo dispone di solo tre elementi nell'elenco di parametri, perché ogni elemento viene formattato in due modalità diverse.


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)


Esempio 4: Formattare più di tre argomenti

Nell'esempio seguente viene creata una stringa che contiene dati sulla temperatura massima e minima di una determinata data. La stringa di formato composto dispone di cinque elementi di formato nell'esempio in C# e di sei nell'esempio in Visual Basic. Due degli elementi di formato definiscono la larghezza delle rispettive rappresentazioni in forma di stringa del valore corrispondente, mentre il primo elemento di formato include anche una stringa di formato per la data e l'ora standard.


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)


È anche possibile passare oggetti da formattare come array anziché un elenco di argomenti.


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


Esempio 5: Formattazione dipendente dalle impostazioni cultura

Nell'esempio seguente viene utilizzato il metodo Format(IFormatProvider, String, Object[]) per visualizzare la rappresentazione in forma di stringa di valori numerici e di data e ora utilizzando varie impostazioni cultura differenti.


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


Esempio 6: Un'operazione di formattazione personalizzata

Nell'esempio seguente è definito un provider di formato del numero cliente che formatta un intero come account cliente esprimendolo come 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.


Esempio 7: Un provider dell'intercettazione e un formattatore di numeri romani

In questo esempio viene definito un provider di format personalizzato che implementa le interfacce IFormatProvider e ICustomFormatter per effettuare quanto segue:

  • Consente di visualizzare i parametri passati all'implementazione ICustomFormatter.Format. Ciò consente di visualizzare quali parametri il metodo Format(IFormatProvider, String, Object[]) passa all'implementazione di formattazione personalizzata per ogni oggetto che tenta di formattare. Questa operazione può essere utile quando si esegue il debug dell'applicazione.

  • Se l'oggetto da formattare è un valore byte unsigned che deve essere formattato utilizzando la stringa di formato standard "R", il formattatore personalizzato consente di formattare il valore numerico come numero 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


Informazioni sulla versione

.NET Framework

Tutte gli overload sono supportati in: 4.5, 4, 3.5, 3.0, 2.0, 1.1, 1.0.

.NET Framework Client Profile

Tutti gli overload sono supportati in: 4.5, 4, 3.5 SP1

Libreria di classi portabile

Sono supportati solo Format(String, Object[]) e Format(IFormatProvider, String, Object[])

.NET per applicazioni Windows Store

Solo Format(String, Object[]) e Format(IFormatProvider, String, Object[]) sono supportati in Windows 8

Aggiunte alla community

AGGIUNGI
Mostra:
© 2014 Microsoft