Dela via

Översikt: Formatera tal, datum, uppräkningar och andra typer i .NET

  • Artikel

Formatering är processen att konvertera en instans av en klass eller struktur, eller ett uppräkningsvärde, till en strängrepresentation. Syftet är att visa den resulterande strängen för användare eller att deserialisera den senare för att återställa den ursprungliga datatypen. Den här artikeln beskriver de formateringsmekanismer som .NET tillhandahåller.

Kommentar

Parsning är inverteringen av formatering. En parsningsåtgärd skapar en instans av en datatyp från dess strängrepresentation. Mer information finns i Parsa strängar. Information om serialisering och deserialisering finns i Serialisering i .NET.

Den grundläggande formateringsmekanismen är standardimplementeringen av metoden, som beskrivs i avsnittet Standardformatering med hjälp av Object.ToString ToString-metoden senare i det här avsnittet. .NET tillhandahåller dock flera sätt att ändra och utöka standardformateringsstödet. Dessa inkluderar följande:

  • Åsidosätta Object.ToString metoden för att definiera en anpassad strängrepresentation av ett objekts värde. Mer information finns i avsnittet Åsidosätt ToString-metoden senare i det här avsnittet.

  • Definiera formatspecificerare som gör det möjligt för strängrepresentationen av ett objekts värde att ta flera former. Formatspecificeraren "X" i följande instruktion konverterar till exempel ett heltal till strängrepresentationen av ett hexadecimalt värde.

    int integerValue = 60312;
Console.WriteLine(integerValue.ToString("X"));   // Displays EB98.

    Dim integerValue As Integer = 60312
Console.WriteLine(integerValue.ToString("X"))   ' Displays EB98.

    Mer information om formatspecificerare finns i avsnittet ToString-metod och formatsträngar .

  • Använda formatprovidrar för att implementera formateringskonventionerna för en viss kultur. Följande instruktion visar till exempel ett valutavärde med hjälp av formateringskonventionerna i en-US-kulturen.

    double cost = 1632.54;
Console.WriteLine(cost.ToString("C",
                  new System.Globalization.CultureInfo("en-US")));
// The example displays the following output:
//       $1,632.54

    Dim cost As Double = 1632.54
Console.WriteLine(cost.ToString("C", New System.Globalization.CultureInfo("en-US")))
' The example displays the following output:
'       $1,632.54

    Mer information om formatering med formatproviders finns i avsnittet Formatprovidrar .

  • IFormattable Implementera gränssnittet för att stödja både strängkonvertering med Convert klassen och sammansatt formatering. Mer information finns i avsnittet IFormattable Interface .

  • Använd sammansatt formatering för att bädda in strängrepresentationen av ett värde i en större sträng. Mer information finns i avsnittet Sammansatt formatering .

  • Med hjälp av stränginterpolation kan du bädda in en mer läsbar syntax för att bädda in strängrepresentationen av ett värde i en större sträng. Mer information finns i Stränginterpolation.

  • Implementera ICustomFormatter och IFormatProvider tillhandahålla en komplett anpassad formateringslösning. Mer information finns i avsnittet Anpassad formatering med ICustomFormatter .

Följande avsnitt undersöker dessa metoder för att konvertera ett objekt till dess strängrepresentation.

Standardformatering med metoden ToString

Varje typ som härleds från System.Object ärver automatiskt en parameterlös ToString metod som returnerar namnet på typen som standard. I följande exempel visas standardmetoden ToString . Den definierar en klass med namnet Automobile som inte har någon implementering. När klassen instansieras och dess ToString metod anropas visas dess typnamn. Observera att ToString metoden inte uttryckligen anropas i exemplet. Metoden Console.WriteLine(Object) anropar ToString implicit metoden för objektet som skickas till den som ett argument.

using System;

public class Automobile
{
   // No implementation. All members are inherited from Object.
}

public class Example9
{
   public static void Main()
   {
      Automobile firstAuto = new Automobile();
      Console.WriteLine(firstAuto);
   }
}
// The example displays the following output:
//       Automobile

Public Class Automobile
    ' No implementation. All members are inherited from Object.
End Class

Module Example9
    Public Sub Main9()
        Dim firstAuto As New Automobile()
        Console.WriteLine(firstAuto)
    End Sub
End Module
' The example displays the following output:
'       Automobile

Varning

Från och med Windows 8.1 innehåller Windows Runtime ett IStringable gränssnitt med en enda metod, IStringable.ToString, som tillhandahåller standardformateringsstöd. Vi rekommenderar dock att hanterade typer inte implementerar IStringable gränssnittet. Mer information finns i Windows Runtime och IStringable Interface.

Eftersom alla andra typer än gränssnitt härleds från Objecttillhandahålls den här funktionen automatiskt till dina anpassade klasser eller strukturer. De funktioner som erbjuds med standardmetoden ToString är dock begränsade: Även om den identifierar typen kan den inte ge någon information om en instans av typen. Om du vill tillhandahålla en strängrepresentation av ett objekt som innehåller information om objektet måste du åsidosätta ToString metoden.

Kommentar

Strukturer ärver från ValueType, som i sin tur härleds från Object. Även om ValueType åsidosättningar Object.ToStringär dess implementering identisk.

Åsidosätt metoden ToString

Att visa namnet på en typ är ofta av begränsad användning och tillåter inte att användare av dina typer särskiljer en instans från en annan. Du kan dock åsidosätta ToString metoden för att ge en mer användbar representation av ett objekts värde. I följande exempel definieras ett Temperature objekt och dess ToString metod åsidosätts för att visa temperaturen i grader Celsius.

public class Temperature
{
    private decimal temp;

    public Temperature(decimal temperature)
    {
        this.temp = temperature;
    }

    public override string ToString()
    {
        return this.temp.ToString("N1") + "°C";
    }
}

public class Example12
{
    public static void Main()
    {
        Temperature currentTemperature = new Temperature(23.6m);
        Console.WriteLine($"The current temperature is {currentTemperature}");
    }
}
// The example displays the following output:
//       The current temperature is 23.6°C.

Public Class Temperature
    Private temp As Decimal

    Public Sub New(temperature As Decimal)
        Me.temp = temperature
    End Sub

    Public Overrides Function ToString() As String
        Return Me.temp.ToString("N1") + "°C"
    End Function
End Class

Module Example13
    Public Sub Main13()
        Dim currentTemperature As New Temperature(23.6D)
        Console.WriteLine("The current temperature is " +
                          currentTemperature.ToString())
    End Sub
End Module
' The example displays the following output:
'       The current temperature is 23.6°C.

I .NET ToString har metoden för varje primitiv värdetyp åsidosatts för att visa objektets värde i stället för dess namn. I följande tabell visas åsidosättningen för varje primitiv typ. Observera att de flesta av de åsidosatta metoderna anropar en annan överlagring av ToString metoden och skickar den formatspecificeraren "G", som definierar det allmänna formatet för dess typ och ett IFormatProvider objekt som representerar den aktuella kulturen.

Typ Åsidosättning av ToString
Boolean Returnerar antingen Boolean.TrueString eller Boolean.FalseString.
Byte Anrop Byte.ToString("G", NumberFormatInfo.CurrentInfo) för att formatera Byte värdet för den aktuella kulturen.
Char Returnerar tecknet som en sträng.
DateTime Anrop DateTime.ToString("G", DatetimeFormatInfo.CurrentInfo) för att formatera datum- och tidsvärdet för den aktuella kulturen.
Decimal Anrop Decimal.ToString("G", NumberFormatInfo.CurrentInfo) för att formatera Decimal värdet för den aktuella kulturen.
Double Anrop Double.ToString("G", NumberFormatInfo.CurrentInfo) för att formatera Double värdet för den aktuella kulturen.
Int16 Anrop Int16.ToString("G", NumberFormatInfo.CurrentInfo) för att formatera Int16 värdet för den aktuella kulturen.
Int32 Anrop Int32.ToString("G", NumberFormatInfo.CurrentInfo) för att formatera Int32 värdet för den aktuella kulturen.
Int64 Anrop Int64.ToString("G", NumberFormatInfo.CurrentInfo) för att formatera Int64 värdet för den aktuella kulturen.
SByte Anrop SByte.ToString("G", NumberFormatInfo.CurrentInfo) för att formatera SByte värdet för den aktuella kulturen.
Single Anrop Single.ToString("G", NumberFormatInfo.CurrentInfo) för att formatera Single värdet för den aktuella kulturen.
UInt16 Anrop UInt16.ToString("G", NumberFormatInfo.CurrentInfo) för att formatera UInt16 värdet för den aktuella kulturen.
UInt32 Anrop UInt32.ToString("G", NumberFormatInfo.CurrentInfo) för att formatera UInt32 värdet för den aktuella kulturen.
UInt64 Anrop UInt64.ToString("G", NumberFormatInfo.CurrentInfo) för att formatera UInt64 värdet för den aktuella kulturen.

ToString-metoden och formatsträngarna

Det är lämpligt att förlita sig på standardmetoden ToString eller åsidosätta ToString när ett objekt har en enda strängrepresentation. Värdet för ett objekt har dock ofta flera representationer. Till exempel kan en temperatur uttryckas i grader Fahrenheit, grader Celsius eller kelvin. På samma sätt kan heltalsvärdet 10 representeras på flera olika sätt, inklusive 10, 10,0, 1,0e01 eller 10,00 USD.

Om du vill att ett enskilt värde ska ha flera strängrepresentationer använder .NET formatsträngar. En formatsträng är en sträng som innehåller en eller flera fördefinierade formatspecificerare, som är enskilda tecken eller grupper med tecken som definierar hur ToString metoden ska formatera sina utdata. Formatsträngen skickas sedan som en parameter till objektets ToString -metod och avgör hur strängrepresentationen av objektets värde ska visas.

Alla numeriska typer, datum- och tidstyper och uppräkningstyper i .NET stöder en fördefinierad uppsättning formatspecificerare. Du kan också använda formatsträngar för att definiera flera strängrepresentationer av dina programdefinierade datatyper.

Standardformatsträngar

En standardformatsträng innehåller en enskild formatspecificerare, vilket är ett alfabetiskt tecken som definierar strängrepresentationen av det objekt som det tillämpas på, tillsammans med en valfri precisionsspecificerare som påverkar hur många siffror som visas i resultatsträngen. Om precisionsspecificeraren utelämnas eller inte stöds motsvarar standardformatsspecificeraren en standardformatsträng.

.NET definierar en uppsättning standardformatsspecificerare för alla numeriska typer, alla datum- och tidstyper och alla uppräkningstyper. Till exempel stöder var och en av dessa kategorier en "G"-standardformatsspecificerare, som definierar en allmän strängrepresentation av ett värde av den typen.

Standardformatsträngar för uppräkningstyper styr direkt strängrepresentationen av ett värde. Formatsträngarna som skickas till ett uppräkningsvärdes ToString metod avgör om värdet visas med dess strängnamn (formatspecificerarna "G" och "F", dess underliggande integralvärde (formatspecificeraren D) eller dess hexadecimala värde (formatspecificeraren "X"). I följande exempel visas användningen av standardformatsträngar för att formatera ett DayOfWeek uppräkningsvärde.

DayOfWeek thisDay = DayOfWeek.Monday;
string[] formatStrings = {"G", "F", "D", "X"};

foreach (string formatString in formatStrings)
   Console.WriteLine(thisDay.ToString(formatString));
// The example displays the following output:
//       Monday
//       Monday
//       1
//       00000001

Dim thisDay As DayOfWeek = DayOfWeek.Monday
Dim formatStrings() As String = {"G", "F", "D", "X"}

For Each formatString As String In formatStrings
    Console.WriteLine(thisDay.ToString(formatString))
Next
' The example displays the following output:
'       Monday
'       Monday
'       1
'       00000001

Information om uppräkningsformatsträngar finns i Uppräkningsformatsträngar.

Standardformatsträngar för numeriska typer definierar vanligtvis en resultatsträng vars exakta utseende styrs av ett eller flera egenskapsvärden. Formatspecificeraren "C" formaterar till exempel ett tal som ett valutavärde. När du anropar ToString metoden med formatspecificeraren "C" som den enda parametern används följande egenskapsvärden från den aktuella kulturens NumberFormatInfo objekt för att definiera strängrepresentationen av det numeriska värdet:

  • Egenskapen CurrencySymbol , som anger den aktuella kulturens valutasymbol.

  • Egenskapen CurrencyNegativePattern eller CurrencyPositivePattern som returnerar ett heltal som avgör följande:

    • Valutasymbolens placering.

    • Om negativa värden indikeras av ett inledande negativt tecken, ett avslutande negativt tecken eller parenteser.

    • Om ett blanksteg visas mellan det numeriska värdet och valutasymbolen.

  • Egenskapen CurrencyDecimalDigits , som definierar antalet bråktalssiffror i resultatsträngen.

  • Egenskapen CurrencyDecimalSeparator som definierar decimaltecknet i resultatsträngen.

  • Egenskapen CurrencyGroupSeparator som definierar gruppavgränsarsymbolen.

  • Egenskapen CurrencyGroupSizes , som definierar antalet siffror i varje grupp till vänster om decimaltecknet.

  • Egenskapen NegativeSign som avgör det negativa tecken som används i resultatsträngen om parenteser inte används för att ange negativa värden.

Dessutom kan numeriska formatsträngar innehålla en precisionsspecificerare. Innebörden av den här specificeraren beror på formatsträngen som den används med, men den anger vanligtvis antingen det totala antalet siffror eller antalet bråktalssiffror som ska visas i resultatsträngen. I följande exempel används till exempel standardsträngen "X4" och en precisionsspecificerare för att skapa ett strängvärde som har fyra hexadecimala siffror.

byte[] byteValues = { 12, 163, 255 };
foreach (byte byteValue in byteValues)
   Console.WriteLine(byteValue.ToString("X4"));
// The example displays the following output:
//       000C
//       00A3
//       00FF

Dim byteValues() As Byte = {12, 163, 255}
For Each byteValue As Byte In byteValues
    Console.WriteLine(byteValue.ToString("X4"))
Next
' The example displays the following output:
'       000C
'       00A3
'       00FF

Mer information om numeriska standardformatsträngar finns i Standard numeriska formatsträngar.

Standardformatsträngar för datum- och tidsvärden är alias för anpassade formatsträngar som lagras av en viss DateTimeFormatInfo egenskap. Om du till exempel anropar ToString metoden för ett datum- och tidsvärde med formatspecificeraren "D" visas datum och tid med hjälp av den anpassade formatsträngen som lagras i den aktuella kulturens DateTimeFormatInfo.LongDatePattern egenskap. (Mer information om anpassade formatsträngar finns i nästa avsnitt.) I följande exempel visas den här relationen.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      DateTime date1 = new DateTime(2009, 6, 30);
      Console.WriteLine("D Format Specifier:     {0:D}", date1);
      string longPattern = CultureInfo.CurrentCulture.DateTimeFormat.LongDatePattern;
      Console.WriteLine("'{0}' custom format string:     {1}",
                        longPattern, date1.ToString(longPattern));
   }
}
// The example displays the following output when run on a system whose
// current culture is en-US:
//    D Format Specifier:     Tuesday, June 30, 2009
//    'dddd, MMMM dd, yyyy' custom format string:     Tuesday, June 30, 2009

Imports System.Globalization

Module Example
    Public Sub Main0()
        Dim date1 As Date = #6/30/2009#
        Console.WriteLine("D Format Specifier:     {0:D}", date1)
        Dim longPattern As String = CultureInfo.CurrentCulture.DateTimeFormat.LongDatePattern
        Console.WriteLine("'{0}' custom format string:     {1}",
                          longPattern, date1.ToString(longPattern))
    End Sub
End Module
' The example displays the following output when run on a system whose
' current culture is en-US:
'    D Format Specifier:     Tuesday, June 30, 2009
'    'dddd, MMMM dd, yyyy' custom format string:     Tuesday, June 30, 2009

Mer information om standardformatsträngar för datum och tid finns i Standardformatsträngar för datum och tid.

Du kan också använda standardformatsträngar för att definiera strängrepresentationen av ett programdefinierat objekt som skapas av objektets ToString(String) metod. Du kan definiera de specifika standardformatsspecificerare som objektet stöder och du kan avgöra om de är skiftlägeskänsliga eller skiftlägeskänsliga. Implementeringen av ToString(String) metoden bör ha stöd för följande:

  • En G-formatspecificerare som representerar ett vanligt eller vanligt format för objektet. Den parameterlösa överlagringen av objektets ToString -metod bör anropa dess ToString(String) överlagring och skicka den till standardformatsträngen "G".

  • Stöd för en formatspecificerare som är lika med en null-referens (Nothing i Visual Basic). En formatspecificerare som är lika med en null-referens bör anses motsvara formatspecificeraren "G".

En klass kan till exempel Temperature internt lagra temperaturen i grader Celsius och använda formatspecificerare för att representera värdet för Temperature objektet i grader Celsius, grader Fahrenheit och kelvin. I följande exempel visas en bild.

using System;

public class Temperature
{
   private decimal m_Temp;

   public Temperature(decimal temperature)
   {
      this.m_Temp = temperature;
   }

   public decimal Celsius
   {
      get { return this.m_Temp; }
   }

   public decimal Kelvin
   {
      get { return this.m_Temp + 273.15m; }
   }

   public decimal Fahrenheit
   {
      get { return Math.Round(((decimal) (this.m_Temp * 9 / 5 + 32)), 2); }
   }

   public override string ToString()
   {
      return this.ToString("C");
   }

   public string ToString(string format)
   {
      // Handle null or empty string.
      if (String.IsNullOrEmpty(format)) format = "C";
      // Remove spaces and convert to uppercase.
      format = format.Trim().ToUpperInvariant();

      // Convert temperature to Fahrenheit and return string.
      switch (format)
      {
         // Convert temperature to Fahrenheit and return string.
         case "F":
            return this.Fahrenheit.ToString("N2") + " °F";
         // Convert temperature to Kelvin and return string.
         case "K":
            return this.Kelvin.ToString("N2") + " K";
         // return temperature in Celsius.
         case "G":
         case "C":
            return this.Celsius.ToString("N2") + " °C";
         default:
            throw new FormatException(String.Format("The '{0}' format string is not supported.", format));
      }
   }
}

public class Example1
{
   public static void Main()
   {
      Temperature temp1 = new Temperature(0m);
      Console.WriteLine(temp1.ToString());
      Console.WriteLine(temp1.ToString("G"));
      Console.WriteLine(temp1.ToString("C"));
      Console.WriteLine(temp1.ToString("F"));
      Console.WriteLine(temp1.ToString("K"));

      Temperature temp2 = new Temperature(-40m);
      Console.WriteLine(temp2.ToString());
      Console.WriteLine(temp2.ToString("G"));
      Console.WriteLine(temp2.ToString("C"));
      Console.WriteLine(temp2.ToString("F"));
      Console.WriteLine(temp2.ToString("K"));

      Temperature temp3 = new Temperature(16m);
      Console.WriteLine(temp3.ToString());
      Console.WriteLine(temp3.ToString("G"));
      Console.WriteLine(temp3.ToString("C"));
      Console.WriteLine(temp3.ToString("F"));
      Console.WriteLine(temp3.ToString("K"));

      Console.WriteLine(String.Format("The temperature is now {0:F}.", temp3));
   }
}
// The example displays the following output:
//       0.00 °C
//       0.00 °C
//       0.00 °C
//       32.00 °F
//       273.15 K
//       -40.00 °C
//       -40.00 °C
//       -40.00 °C
//       -40.00 °F
//       233.15 K
//       16.00 °C
//       16.00 °C
//       16.00 °C
//       60.80 °F
//       289.15 K
//       The temperature is now 16.00 °C.

Public Class Temperature
    Private m_Temp As Decimal

    Public Sub New(temperature As Decimal)
        Me.m_Temp = temperature
    End Sub

    Public ReadOnly Property Celsius() As Decimal
        Get
            Return Me.m_Temp
        End Get
    End Property

    Public ReadOnly Property Kelvin() As Decimal
        Get
            Return Me.m_Temp + 273.15D
        End Get
    End Property

    Public ReadOnly Property Fahrenheit() As Decimal
        Get
            Return Math.Round(CDec(Me.m_Temp * 9 / 5 + 32), 2)
        End Get
    End Property

    Public Overrides Function ToString() As String
        Return Me.ToString("C")
    End Function

    Public Overloads Function ToString(format As String) As String
        ' Handle null or empty string.
        If String.IsNullOrEmpty(format) Then format = "C"
        ' Remove spaces and convert to uppercase.
        format = format.Trim().ToUpperInvariant()

        Select Case format
            Case "F"
                ' Convert temperature to Fahrenheit and return string.
                Return Me.Fahrenheit.ToString("N2") & " °F"
            Case "K"
                ' Convert temperature to Kelvin and return string.
                Return Me.Kelvin.ToString("N2") & " K"
            Case "C", "G"
                ' Return temperature in Celsius.
                Return Me.Celsius.ToString("N2") & " °C"
            Case Else
                Throw New FormatException(String.Format("The '{0}' format string is not supported.", format))
        End Select
    End Function
End Class

Public Module Example1
    Public Sub Main1()
        Dim temp1 As New Temperature(0D)
        Console.WriteLine(temp1.ToString())
        Console.WriteLine(temp1.ToString("G"))
        Console.WriteLine(temp1.ToString("C"))
        Console.WriteLine(temp1.ToString("F"))
        Console.WriteLine(temp1.ToString("K"))

        Dim temp2 As New Temperature(-40D)
        Console.WriteLine(temp2.ToString())
        Console.WriteLine(temp2.ToString("G"))
        Console.WriteLine(temp2.ToString("C"))
        Console.WriteLine(temp2.ToString("F"))
        Console.WriteLine(temp2.ToString("K"))

        Dim temp3 As New Temperature(16D)
        Console.WriteLine(temp3.ToString())
        Console.WriteLine(temp3.ToString("G"))
        Console.WriteLine(temp3.ToString("C"))
        Console.WriteLine(temp3.ToString("F"))
        Console.WriteLine(temp3.ToString("K"))

        Console.WriteLine(String.Format("The temperature is now {0:F}.", temp3))
    End Sub
End Module
' The example displays the following output:
'       0.00 °C
'       0.00 °C
'       0.00 °C
'       32.00 °F
'       273.15 K
'       -40.00 °C
'       -40.00 °C
'       -40.00 °C
'       -40.00 °F
'       233.15 K
'       16.00 °C
'       16.00 °C
'       16.00 °C
'       60.80 °F
'       289.15 K
'       The temperature is now 16.00 °C.

Anpassade formatsträngar

Förutom standardformatsträngarna definierar .NET anpassade formatsträngar för både numeriska värden och datum- och tidsvärden. En anpassad formatsträng består av en eller flera anpassade formatspecificerare som definierar strängrepresentationen av ett värde. Till exempel konverterar den anpassade datum- och tidsformatsträngen "åååå/mm/dd hh:mm:ss.ffff t zzz" ett datum till dess strängrepresentation i formuläret "2008/11/15 07:45:00.0000 P -08:00" för en-US-kulturen. På samma sätt konverterar den anpassade formatsträngen "0000" heltalsvärdet 12 till "0012". En fullständig lista över anpassade formatsträngar finns i Anpassade datum- och tidsformatsträngar och anpassade numeriska formatsträngar.

Om en formatsträng består av en enda anpassad formatspecificerare bör formatspecificeraren föregås av symbolen procent (%) för att undvika förvirring med en standardformatsspecificerare. I följande exempel används den anpassade formatspecificeraren "M" för att visa ett ensiffrigt eller tvåsiffrigt nummer för månaden för ett visst datum.

DateTime date1 = new DateTime(2009, 9, 8);
Console.WriteLine(date1.ToString("%M"));       // Displays 9

Dim date1 As Date = #09/08/2009#
Console.WriteLine(date1.ToString("%M"))      ' Displays 9

Många standardformatsträngar för datum- och tidsvärden är alias för anpassade formatsträngar som definieras av objektets DateTimeFormatInfo egenskaper. Anpassade formatsträngar ger också stor flexibilitet när det gäller att tillhandahålla programdefinierad formatering för numeriska värden eller datum- och tidsvärden. Du kan definiera egna anpassade resultatsträngar för både numeriska värden och datum- och tidsvärden genom att kombinera flera anpassade formatspecificerare till en enda anpassad formatsträng. I följande exempel definieras en anpassad formatsträng som visar veckodagen inom parenteser efter månadens namn, dag och år.

string customFormat = "MMMM dd, yyyy (dddd)";
DateTime date1 = new DateTime(2009, 8, 28);
Console.WriteLine(date1.ToString(customFormat));
// The example displays the following output if run on a system
// whose language is English:
//       August 28, 2009 (Friday)

Dim customFormat As String = "MMMM dd, yyyy (dddd)"
Dim date1 As Date = #8/28/2009#
Console.WriteLine(date1.ToString(customFormat))
' The example displays the following output if run on a system
' whose language is English:
'       August 28, 2009 (Friday)

I följande exempel definieras en sträng i anpassat format som visar ett Int64 värde som ett standard, sjusiffrigt amerikanskt telefonnummer tillsammans med dess riktnummer.

using System;

public class Example17
{
   public static void Main()
   {
      long number = 8009999999;
      string fmt = "000-000-0000";
      Console.WriteLine(number.ToString(fmt));
   }
}
// The example displays the following output:
//        800-999-9999

Module Example18
    Public Sub Main18()
        Dim number As Long = 8009999999
        Dim fmt As String = "000-000-0000"
        Console.WriteLine(number.ToString(fmt))
    End Sub
End Module
' The example displays the following output:

' The example displays the following output:
'       800-999-9999

Även om standardformatsträngar vanligtvis kan hantera de flesta formateringsbehoven för dina programdefinierade typer, kan du också definiera anpassade formatspecificerare för att formatera dina typer.

Formatera strängar och .NET-typer

Alla numeriska typer (dvs. Byte, Decimal, Double, Int16, Int32, Int64, SByte, Single, , UInt16, UInt32, , UInt64och BigInteger typer) samt DateTime, DateTimeOffset, , TimeSpan, Guidoch alla uppräkningstyper, stöder formatering med formatsträngar. Information om de specifika formatsträngar som stöds av varje typ finns i följande avsnitt:

Title Definition
Standardsträngar med numeriskt format Beskriver standardformatsträngar som skapar vanliga strängrepresentationer av numeriska värden.
Anpassade numeriska formatsträngar Beskriver anpassade formatsträngar som skapar programspecifika format för numeriska värden.
Standardformatsträngar för datum och tid Beskriver standardformatsträngar som skapar vanliga strängrepresentationer av DateTime och DateTimeOffset värden.
Anpassade formatsträngar för datum och tid Beskriver anpassade formatsträngar som skapar programspecifika format för DateTime och DateTimeOffset värden.
Standard TimeSpan-formatsträngar Beskriver standardformatsträngar som skapar vanliga strängrepresentationer av tidsintervall.
Anpassade timeSpan-formatsträngar Beskriver anpassade formatsträngar som skapar programspecifika format för tidsintervall.
Uppräkningsformatsträngar Beskriver standardformatsträngar som används för att skapa strängrepresentationer av uppräkningsvärden.
Guid.ToString(String) Beskriver standardformatsträngar för Guid värden.

Kulturkänslig formatering med formatprovidrar

Även om formatspecificerare kan du anpassa formateringen av objekt, men för att skapa en meningsfull strängrepresentation av objekt krävs ofta ytterligare formateringsinformation. Om du till exempel formaterar ett tal som ett valutavärde med hjälp av standardformatsträngen "C" eller en anpassad formatsträng som "$ #,#.00" krävs minst information om rätt valutasymbol, gruppavgränsare och decimaltecken som ska vara tillgänglig för att inkluderas i den formaterade strängen. I .NET görs den här ytterligare formateringsinformationen IFormatProvider tillgänglig via gränssnittet, som tillhandahålls som en parameter till en eller flera överlagringar av ToString metoden för numeriska typer och datum- och tidstyper. IFormatProvider implementeringar används i .NET för att stödja kulturspecifik formatering. I följande exempel visas hur strängrepresentationen av ett objekt ändras när det formateras med tre IFormatProvider objekt som representerar olika kulturer.

using System;
using System.Globalization;

public class Example18
{
   public static void Main()
   {
      decimal value = 1603.42m;
      Console.WriteLine(value.ToString("C3", new CultureInfo("en-US")));
      Console.WriteLine(value.ToString("C3", new CultureInfo("fr-FR")));
      Console.WriteLine(value.ToString("C3", new CultureInfo("de-DE")));
   }
}
// The example displays the following output:
//       $1,603.420
//       1 603,420 €
//       1.603,420 €

Imports System.Globalization

Public Module Example11
    Public Sub Main11()
        Dim value As Decimal = 1603.42D
        Console.WriteLine(value.ToString("C3", New CultureInfo("en-US")))
        Console.WriteLine(value.ToString("C3", New CultureInfo("fr-FR")))
        Console.WriteLine(value.ToString("C3", New CultureInfo("de-DE")))
    End Sub
End Module
' The example displays the following output:
'       $1,603.420
'       1 603,420 €
'       1.603,420 €

Gränssnittet IFormatProvider innehåller en metod, GetFormat(Type), som har en enda parameter som anger vilken typ av objekt som innehåller formateringsinformation. Om metoden kan tillhandahålla ett objekt av den typen returneras den. Annars returneras en null-referens (Nothing i Visual Basic).

IFormatProvider.GetFormat är en motringningsmetod. När du anropar en ToString metodöverlagring som innehåller en IFormatProvider parameter anropas metoden för GetFormat objektet IFormatProvider . Metoden GetFormat ansvarar för att returnera ett objekt som tillhandahåller nödvändig formateringsinformation, enligt parametern formatType , till ToString metoden.

Ett antal metoder för formatering eller strängkonvertering innehåller en parameter av typen IFormatProvider, men i många fall ignoreras värdet för parametern när metoden anropas. I följande tabell visas några av formateringsmetoderna som använder parametern och typen av Type objekt som de skickar till IFormatProvider.GetFormat metoden.

Metod Typ av formatType parameter
ToString metod för numeriska typer System.Globalization.NumberFormatInfo
ToString metod för datum- och tidstyper System.Globalization.DateTimeFormatInfo
String.Format System.ICustomFormatter
StringBuilder.AppendFormat System.ICustomFormatter

Kommentar

Metoderna ToString för de numeriska typerna och datum- och tidstyperna är överbelastade, och endast några av överlagringarna innehåller en IFormatProvider parameter. Om en metod inte har någon parameter av typen IFormatProviderskickas objektet som returneras av CultureInfo.CurrentCulture egenskapen i stället. Ett anrop till standardmetoden Int32.ToString() resulterar till exempel i ett metodanrop, till exempel följande: Int32.ToString("G", System.Globalization.CultureInfo.CurrentCulture).

.NET tillhandahåller tre klasser som implementerar IFormatProvider:

Du kan också implementera en egen formatprovider för att ersätta någon av dessa klasser. Implementeringsmetoden GetFormat måste dock returnera ett objekt av den typ som anges i föregående tabell om den måste ange formateringsinformation för ToString metoden.

Kulturkänslig formatering av numeriska värden

Som standard är formateringen av numeriska värden kulturkänslig. Om du inte anger en kultur när du anropar en formateringsmetod används formateringskonventionerna för den aktuella kulturen. Detta illustreras i följande exempel, som ändrar den aktuella kulturen fyra gånger och sedan anropar Decimal.ToString(String) metoden. I varje fall återspeglar resultatsträngen formateringskonventionerna för den aktuella kulturen. Det beror på att ToString metoderna och ToString(String) omsluter anrop till varje numerisk typs ToString(String, IFormatProvider) metod.

using System.Globalization;

public class Example6
{
   public static void Main()
   {
      string[] cultureNames = { "en-US", "fr-FR", "es-MX", "de-DE" };
      Decimal value = 1043.17m;

      foreach (var cultureName in cultureNames) {
         // Change the current culture.
         CultureInfo.CurrentCulture = CultureInfo.CreateSpecificCulture(cultureName);
         Console.WriteLine($"The current culture is {CultureInfo.CurrentCulture.Name}");
         Console.WriteLine(value.ToString("C2"));
         Console.WriteLine();
      }
   }
}
// The example displays the following output:
//       The current culture is en-US
//       $1,043.17
//
//       The current culture is fr-FR
//       1 043,17 €
//
//       The current culture is es-MX
//       $1,043.17
//
//       The current culture is de-DE
//       1.043,17 €

Imports System.Globalization

Module Example6
    Public Sub Main6()
        Dim cultureNames() As String = {"en-US", "fr-FR", "es-MX", "de-DE"}
        Dim value As Decimal = 1043.17D

        For Each cultureName In cultureNames
            ' Change the current culture.
            CultureInfo.CurrentCulture = CultureInfo.CreateSpecificCulture(cultureName)
            Console.WriteLine($"The current culture is {CultureInfo.CurrentCulture.Name}")
            Console.WriteLine(value.ToString("C2"))
            Console.WriteLine()
        Next
    End Sub
End Module
' The example displays the following output:
'       The current culture is en-US
'       $1,043.17
'       
'       The current culture is fr-FR
'       1 043,17 €
'       
'       The current culture is es-MX
'       $1,043.17
'       
'       The current culture is de-DE
'       1.043,17 €

Du kan också formatera ett numeriskt värde för en specifik kultur genom att anropa en ToString överlagring som har en provider parameter och skicka den något av följande:

I följande exempel används NumberFormatInfo objekt som representerar den engelska (USA) och engelska (Storbritannien) och de franska och ryska neutrala kulturerna för att formatera ett flyttalsnummer.

using System.Globalization;

public class Example7
{
    public static void Main()
    {
        double value = 1043.62957;
        string[] cultureNames = { "en-US", "en-GB", "ru", "fr" };

        foreach (string? name in cultureNames)
        {
            NumberFormatInfo nfi = CultureInfo.CreateSpecificCulture(name).NumberFormat;
            Console.WriteLine("{0,-6} {1}", name + ":", value.ToString("N3", nfi));
        }
    }
}
// The example displays the following output:
//       en-US: 1,043.630
//       en-GB: 1,043.630
//       ru:    1 043,630
//       fr:    1 043,630

Imports System.Globalization

Module Example7
    Public Sub Main7()
        Dim value As Double = 1043.62957
        Dim cultureNames() As String = {"en-US", "en-GB", "ru", "fr"}

        For Each name In cultureNames
            Dim nfi As NumberFormatInfo = CultureInfo.CreateSpecificCulture(name).NumberFormat
            Console.WriteLine("{0,-6} {1}", name + ":", value.ToString("N3", nfi))
        Next
    End Sub
End Module
' The example displays the following output:
'       en-US: 1,043.630
'       en-GB: 1,043.630
'       ru:    1 043,630
'       fr:    1 043,630

Kulturkänslig formatering av datum- och tidsvärden

Som standard är formateringen av datum- och tidsvärden kulturkänslig. Om du inte anger en kultur när du anropar en formateringsmetod används formateringskonventionerna för den aktuella kulturen. Detta illustreras i följande exempel, som ändrar den aktuella kulturen fyra gånger och sedan anropar DateTime.ToString(String) metoden. I varje fall återspeglar resultatsträngen formateringskonventionerna för den aktuella kulturen. Det beror på att DateTime.ToString()metoderna , DateTime.ToString(String), DateTimeOffset.ToString()och DateTimeOffset.ToString(String) omsluter anrop till DateTime.ToString(String, IFormatProvider) metoderna och DateTimeOffset.ToString(String, IFormatProvider) .

using System.Globalization;

public class Example4
{
   public static void Main()
   {
      string[] cultureNames = { "en-US", "fr-FR", "es-MX", "de-DE" };
      DateTime dateToFormat = new DateTime(2012, 5, 28, 11, 30, 0);

      foreach (var cultureName in cultureNames) {
         // Change the current culture.
         CultureInfo.CurrentCulture = CultureInfo.CreateSpecificCulture(cultureName);
         Console.WriteLine($"The current culture is {CultureInfo.CurrentCulture.Name}");
         Console.WriteLine(dateToFormat.ToString("F"));
         Console.WriteLine();
      }
   }
}
// The example displays the following output:
//       The current culture is en-US
//       Monday, May 28, 2012 11:30:00 AM
//
//       The current culture is fr-FR
//       lundi 28 mai 2012 11:30:00
//
//       The current culture is es-MX
//       lunes, 28 de mayo de 2012 11:30:00 a.m.
//
//       The current culture is de-DE
//       Montag, 28. Mai 2012 11:30:00

Imports System.Globalization
Imports System.Threading

Module Example4
    Public Sub Main4()
        Dim cultureNames() As String = {"en-US", "fr-FR", "es-MX", "de-DE"}
        Dim dateToFormat As Date = #5/28/2012 11:30AM#

        For Each cultureName In cultureNames
            ' Change the current culture.
            CultureInfo.CurrentCulture = CultureInfo.CreateSpecificCulture(cultureName)
            Console.WriteLine($"The current culture is {CultureInfo.CurrentCulture.Name}")
            Console.WriteLine(dateToFormat.ToString("F"))
            Console.WriteLine()
        Next
    End Sub
End Module
' The example displays the following output:
'       The current culture is en-US
'       Monday, May 28, 2012 11:30:00 AM
'       
'       The current culture is fr-FR
'       lundi 28 mai 2012 11:30:00
'       
'       The current culture is es-MX
'       lunes, 28 de mayo de 2012 11:30:00 a.m.
'       
'       The current culture is de-DE
'       Montag, 28. Mai 2012 11:30:00

Du kan också formatera ett datum- och tidsvärde för en viss kultur genom att anropa en DateTime.ToString eller DateTimeOffset.ToString överlagring som har en provider parameter och skicka den något av följande:

I följande exempel används DateTimeFormatInfo objekt som representerar kulturerna engelska (USA) och engelska (Storbritannien) och de franska och ryska neutrala kulturerna för att formatera ett datum.

using System.Globalization;

public class Example5
{
   public static void Main()
   {
      DateTime dat1 = new(2012, 5, 28, 11, 30, 0);
      string[] cultureNames = { "en-US", "en-GB", "ru", "fr" };

      foreach (var name in cultureNames) {
         DateTimeFormatInfo dtfi = CultureInfo.CreateSpecificCulture(name).DateTimeFormat;
         Console.WriteLine($"{name}: {dat1.ToString(dtfi)}");
      }
   }
}
// The example displays the following output:
//       en-US: 5/28/2012 11:30:00 AM
//       en-GB: 28/05/2012 11:30:00
//       ru: 28.05.2012 11:30:00
//       fr: 28/05/2012 11:30:00

Imports System.Globalization

Module Example5
    Public Sub Main5()
        Dim dat1 As Date = #5/28/2012 11:30AM#
        Dim cultureNames() As String = {"en-US", "en-GB", "ru", "fr"}

        For Each name In cultureNames
            Dim dtfi As DateTimeFormatInfo = CultureInfo.CreateSpecificCulture(name).DateTimeFormat
            Console.WriteLine($"{name}: {dat1.ToString(dtfi)}")
        Next
    End Sub
End Module
' The example displays the following output:
'       en-US: 5/28/2012 11:30:00 AM
'       en-GB: 28/05/2012 11:30:00
'       ru: 28.05.2012 11:30:00
'       fr: 28/05/2012 11:30:00

IFormattable-gränssnittet

Vanligtvis implementerar IFormattable typer som överbelastar ToString metoden med en formatsträng och en IFormatProvider parameter även gränssnittet. Det här gränssnittet har en enda medlem, IFormattable.ToString(String, IFormatProvider), som innehåller både en formatsträng och en formatprovider som parametrar.

Det finns två fördelar med att IFormattable implementera gränssnittet för din programdefinierade klass:

I följande exempel definieras en Temperature klass som implementerar IFormattable gränssnittet. Den stöder formatspecificerarna "C" eller "G" för att visa temperaturen i Celsius, formatspecificeraren "F" för att visa temperaturen i Fahrenheit och formatspecificeraren "K" för att visa temperaturen i Kelvin.

using System;
using System.Globalization;

namespace HotAndCold
{

    public class Temperature : IFormattable
    {
        private decimal m_Temp;

        public Temperature(decimal temperature)
        {
            this.m_Temp = temperature;
        }

        public decimal Celsius
        {
            get { return this.m_Temp; }
        }

        public decimal Kelvin
        {
            get { return this.m_Temp + 273.15m; }
        }

        public decimal Fahrenheit
        {
            get { return Math.Round((decimal)this.m_Temp * 9 / 5 + 32, 2); }
        }

        public override string ToString()
        {
            return this.ToString("G", null);
        }

        public string ToString(string format)
        {
            return this.ToString(format, null);
        }

        public string ToString(string format, IFormatProvider provider)
        {
            // Handle null or empty arguments.
            if (String.IsNullOrEmpty(format))
                format = "G";
            // Remove any white space and covert to uppercase.
            format = format.Trim().ToUpperInvariant();

            if (provider == null)
                provider = NumberFormatInfo.CurrentInfo;

            switch (format)
            {
                // Convert temperature to Fahrenheit and return string.
                case "F":
                    return this.Fahrenheit.ToString("N2", provider) + "°F";
                // Convert temperature to Kelvin and return string.
                case "K":
                    return this.Kelvin.ToString("N2", provider) + "K";
                // Return temperature in Celsius.
                case "C":
                case "G":
                    return this.Celsius.ToString("N2", provider) + "°C";
                default:
                    throw new FormatException(String.Format("The '{0}' format string is not supported.", format));
            }
        }
    }

Public Class Temperature : Implements IFormattable
    Private m_Temp As Decimal

    Public Sub New(temperature As Decimal)
        Me.m_Temp = temperature
    End Sub

    Public ReadOnly Property Celsius() As Decimal
        Get
            Return Me.m_Temp
        End Get
    End Property

    Public ReadOnly Property Kelvin() As Decimal
        Get
            Return Me.m_Temp + 273.15D
        End Get
    End Property

    Public ReadOnly Property Fahrenheit() As Decimal
        Get
            Return Math.Round(CDec(Me.m_Temp * 9 / 5 + 32), 2)
        End Get
    End Property

    Public Overrides Function ToString() As String
        Return Me.ToString("G", Nothing)
    End Function

    Public Overloads Function ToString(format As String) As String
        Return Me.ToString(format, Nothing)
    End Function

    Public Overloads Function ToString(format As String, provider As IFormatProvider) As String _
       Implements IFormattable.ToString

        ' Handle null or empty arguments.
        If String.IsNullOrEmpty(format) Then format = "G"
        ' Remove any white space and convert to uppercase.
        format = format.Trim().ToUpperInvariant()

        If provider Is Nothing Then provider = NumberFormatInfo.CurrentInfo

        Select Case format
     ' Convert temperature to Fahrenheit and return string.
            Case "F"
                Return Me.Fahrenheit.ToString("N2", provider) & "°F"
     ' Convert temperature to Kelvin and return string.
            Case "K"
                Return Me.Kelvin.ToString("N2", provider) & "K"
     ' Return temperature in Celsius.
            Case "C", "G"
                Return Me.Celsius.ToString("N2", provider) & "°C"
            Case Else
                Throw New FormatException(String.Format($"The '{format}' format string is not supported."))
        End Select
    End Function
End Class

I följande exempel instansieras ett Temperature objekt. Den anropar ToString sedan metoden och använder flera sammansatta formatsträngar för att hämta olika strängrepresentationer av ett Temperature objekt. Var och en av dessa metodanrop anropar i sin tur implementeringen IFormattable av Temperature klassen.

public class Example11
{
    public static void Main()
    {
        CultureInfo.CurrentCulture = CultureInfo.GetCultureInfo("en-US");
        Temperature temp = new Temperature(22m);
        Console.WriteLine(Convert.ToString(temp, new CultureInfo("ja-JP")));
        Console.WriteLine("Temperature: {0:K}", temp);
        Console.WriteLine("Temperature: {0:F}", temp);
        Console.WriteLine(String.Format(new CultureInfo("fr-FR"), "Temperature: {0:F}", temp));
    }
}
// The example displays the following output:
//       22.00°C
//       Temperature: 295.15K
//       Temperature: 71.60°F
//       Temperature: 71,60°F

Public Module Example12
    Public Sub Main12()
        Dim temp As New Temperature(22D)
        CultureInfo.CurrentCulture = CultureInfo.GetCultureInfo("en-US")
        Console.WriteLine(Convert.ToString(temp, New CultureInfo("ja-JP")))
        Console.WriteLine($"Temperature: {temp:K}")
        Console.WriteLine($"Temperature: {temp:F}")
        Console.WriteLine(String.Format(New CultureInfo("fr-FR"), $"Temperature: {temp:F}"))
    End Sub
End Module
' The example displays the following output:
'       22.00°C
'       Temperature: 295.15K
'       Temperature: 71.60°F
'       Temperature: 71,60°F

Sammansatt formatering

Vissa metoder, till exempel String.Format och StringBuilder.AppendFormat, stöder sammansatt formatering. En sammansatt formatsträng är en typ av mall som returnerar en enskild sträng som innehåller strängrepresentationen av noll, ett eller flera objekt. Varje objekt representeras i den sammansatta formatsträngen av ett indexerat formatobjekt. Indexet för formatobjektet motsvarar positionen för det objekt som det representerar i metodens parameterlista. Index är nollbaserade. I följande anrop till metoden ersätts till String.Format exempel det första formatobjektet, , {0:D}av strängrepresentationen av thatDate; det andra formatobjektet, , {1}ersätts av strängrepresentationen av item1; och det tredje formatobjektet, {2:C2}, ersätts av strängrepresentationen av item1.Value.

result = String.Format("On {0:d}, the inventory of {1} was worth {2:C2}.",
                       thatDate, item1, item1.Value);
Console.WriteLine(result);
// The example displays output like the following if run on a system
// whose current culture is en-US:
//       On 5/1/2009, the inventory of WidgetA was worth $107.44.

result = String.Format("On {0:d}, the inventory of {1} was worth {2:C2}.",
                       thatDate, item1, item1.Value)
Console.WriteLine(result)
' The example displays output like the following if run on a system
' whose current culture is en-US:
'       On 5/1/2009, the inventory of WidgetA was worth $107.44.

Förutom att ersätta ett formatobjekt med strängrepresentationen av motsvarande objekt kan du även styra följande genom att formatera objekt:

  • Det specifika sätt på vilket ett objekt representeras som en sträng, om objektet implementerar IFormattable gränssnittet och stöder formatsträngar. Det gör du genom att följa formatobjektets index med ett : (kolon) följt av en giltig formatsträng. Föregående exempel gjorde detta genom att formatera ett datumvärde med formatsträngen "d" (kort datummönster) (till exempel {0:d}) och genom att formatera ett numeriskt värde med formatsträngen "C2" (till exempel {2:C2} för att representera talet som ett valutavärde med två decimaltal.

  • Bredden på det fält som innehåller objektets strängrepresentation och justeringen av strängrepresentationen i fältet. Det gör du genom att följa formatobjektets index med ett , (kommatecken) följt av fältbredden. Strängen är högerjusterad i fältet om fältbredden är ett positivt värde och den är vänsterjusterad om fältbredden är ett negativt värde. I följande exempel vänsterjusterar datumvärden i ett fält med 20 tecken, och det högerjusterar decimalvärden med en bråktalssiffra i ett fält med 11 tecken.

    DateTime startDate = new DateTime(2015, 8, 28, 6, 0, 0);
decimal[] temps = { 73.452m, 68.98m, 72.6m, 69.24563m,
                   74.1m, 72.156m, 72.228m };
Console.WriteLine("{0,-20} {1,11}\n", "Date", "Temperature");
for (int ctr = 0; ctr < temps.Length; ctr++)
   Console.WriteLine("{0,-20:g} {1,11:N1}", startDate.AddDays(ctr), temps[ctr]);

// The example displays the following output:
//       Date                 Temperature
//
//       8/28/2015 6:00 AM           73.5
//       8/29/2015 6:00 AM           69.0
//       8/30/2015 6:00 AM           72.6
//       8/31/2015 6:00 AM           69.2
//       9/1/2015 6:00 AM            74.1
//       9/2/2015 6:00 AM            72.2
//       9/3/2015 6:00 AM            72.2

    Dim startDate As New Date(2015, 8, 28, 6, 0, 0)
Dim temps() As Decimal = {73.452, 68.98, 72.6, 69.24563,
                           74.1, 72.156, 72.228}
Console.WriteLine("{0,-20} {1,11}", "Date", "Temperature")
Console.WriteLine()
For ctr As Integer = 0 To temps.Length - 1
    Console.WriteLine("{0,-20:g} {1,11:N1}", startDate.AddDays(ctr), temps(ctr))
Next
' The example displays the following output:
'       Date                 Temperature
'
'       8/28/2015 6:00 AM           73.5
'       8/29/2015 6:00 AM           69.0
'       8/30/2015 6:00 AM           72.6
'       8/31/2015 6:00 AM           69.2
'       9/1/2015 6:00 AM            74.1
'       9/2/2015 6:00 AM            72.2
'       9/3/2015 6:00 AM            72.2

    Observera att om både justeringssträngkomponenten och formatsträngskomponenten finns föregår den förstnämnda den senare (till exempel {0,-20:g}.

Mer information om sammansatt formatering finns i Sammansatt formatering.

Anpassad formatering med ICustomFormatter

Två sammansatta formateringsmetoder, String.Format(IFormatProvider, String, Object[]) och StringBuilder.AppendFormat(IFormatProvider, String, Object[]), innehåller en formatproviderparameter som stöder anpassad formatering. När någon av dessa formateringsmetoder anropas skickas ett Type objekt som representerar ett ICustomFormatter gränssnitt till formatproviderns GetFormat metod. Metoden GetFormat ansvarar sedan för att returnera implementeringen ICustomFormatter som tillhandahåller anpassad formatering.

Gränssnittet ICustomFormatter har en enda metod, Format(String, Object, IFormatProvider), som anropas automatiskt av en sammansatt formateringsmetod, en gång för varje formatobjekt i en sammansatt formatsträng. Metoden Format(String, Object, IFormatProvider) har tre parametrar: en formatsträng som representerar formatString argumentet i ett formatobjekt, ett objekt att formatera och ett IFormatProvider objekt som tillhandahåller formateringstjänster. Vanligtvis implementerar IFormatProviderklassen som implementerar ICustomFormatter också , så den här sista parametern är en referens till själva den anpassade formateringsklassen. Metoden returnerar en anpassad formaterad strängrepresentation av objektet som ska formateras. Om metoden inte kan formatera objektet ska den returnera en null-referens (Nothing i Visual Basic).

I följande exempel finns en ICustomFormatter implementering med namnet ByteByByteFormatter som visar heltalsvärden som en sekvens med tvåsiffriga hexadecimala värden följt av ett blanksteg.

public class ByteByByteFormatter : 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 (! formatProvider.Equals(this)) return null;

      // Handle only hexadecimal format string.
      if (! format.StartsWith("X")) return null;

      byte[] bytes;
      string output = null;

      // Handle only integral types.
      if (arg is Byte)
         bytes = BitConverter.GetBytes((Byte) arg);
      else if (arg is Int16)
         bytes = BitConverter.GetBytes((Int16) arg);
      else if (arg is Int32)
         bytes = BitConverter.GetBytes((Int32) arg);
      else if (arg is Int64)
         bytes = BitConverter.GetBytes((Int64) arg);
      else if (arg is SByte)
         bytes = BitConverter.GetBytes((SByte) arg);
      else if (arg is UInt16)
         bytes = BitConverter.GetBytes((UInt16) arg);
      else if (arg is UInt32)
         bytes = BitConverter.GetBytes((UInt32) arg);
      else if (arg is UInt64)
         bytes = BitConverter.GetBytes((UInt64) arg);
      else
         return null;

      for (int ctr = bytes.Length - 1; ctr >= 0; ctr--)
         output += String.Format("{0:X2} ", bytes[ctr]);

      return output.Trim();
   }
}

Public Class ByteByByteFormatter : Implements IFormatProvider, ICustomFormatter
    Public Function GetFormat(formatType As Type) As Object _
                    Implements IFormatProvider.GetFormat
        If formatType Is GetType(ICustomFormatter) Then
            Return Me
        Else
            Return Nothing
        End If
    End Function

    Public Function Format(fmt As String, arg As Object,
                           formatProvider As IFormatProvider) As String _
                           Implements ICustomFormatter.Format

        If Not formatProvider.Equals(Me) Then Return Nothing

        ' Handle only hexadecimal format string.
        If Not fmt.StartsWith("X") Then
            Return Nothing
        End If

        ' Handle only integral types.
        If Not typeof arg Is Byte AndAlso
           Not typeof arg Is Int16 AndAlso
           Not typeof arg Is Int32 AndAlso
           Not typeof arg Is Int64 AndAlso
           Not typeof arg Is SByte AndAlso
           Not typeof arg Is UInt16 AndAlso
           Not typeof arg Is UInt32 AndAlso
           Not typeof arg Is UInt64 Then _
              Return Nothing

        Dim bytes() As Byte = BitConverter.GetBytes(arg)
        Dim output As String = Nothing

        For ctr As Integer = bytes.Length - 1 To 0 Step -1
            output += String.Format("{0:X2} ", bytes(ctr))
        Next

        Return output.Trim()
    End Function
End Class

I följande exempel används ByteByByteFormatter klassen för att formatera heltalsvärden. Observera att ICustomFormatter.Format metoden anropas mer än en gång i det andra String.Format(IFormatProvider, String, Object[]) metodanropet och att standardprovidern NumberFormatInfo används i det tredje metodanropet eftersom .ByteByByteFormatter.Format -metoden känner inte igen formatsträngen "N0" och returnerar en null-referens (Nothing i Visual Basic).

public class Example10
{
   public static void Main()
   {
      long value = 3210662321;
      byte value1 = 214;
      byte value2 = 19;

      Console.WriteLine(String.Format(new ByteByByteFormatter(), "{0:X}", value));
      Console.WriteLine(String.Format(new ByteByByteFormatter(), "{0:X} And {1:X} = {2:X} ({2:000})",
                                      value1, value2, value1 & value2));
      Console.WriteLine(String.Format(new ByteByByteFormatter(), "{0,10:N0}", value));
   }
}
// The example displays the following output:
//       00 00 00 00 BF 5E D1 B1
//       00 D6 And 00 13 = 00 12 (018)
//       3,210,662,321

Public Module Example10
    Public Sub Main10()
        Dim value As Long = 3210662321
        Dim value1 As Byte = 214
        Dim value2 As Byte = 19

        Console.WriteLine((String.Format(New ByteByByteFormatter(), "{0:X}", value)))
        Console.WriteLine((String.Format(New ByteByByteFormatter(), "{0:X} And {1:X} = {2:X} ({2:000})",
                                        value1, value2, value1 And value2)))
        Console.WriteLine(String.Format(New ByteByByteFormatter(), "{0,10:N0}", value))
    End Sub
End Module
' The example displays the following output:
'       00 00 00 00 BF 5E D1 B1
'       00 D6 And 00 13 = 00 12 (018)
'       3,210,662,321

Se även

Title Definition
Standardsträngar med numeriskt format Beskriver standardformatsträngar som skapar vanliga strängrepresentationer av numeriska värden.
Anpassade numeriska formatsträngar Beskriver anpassade formatsträngar som skapar programspecifika format för numeriska värden.
Standardformatsträngar för datum och tid Beskriver standardformatsträngar som skapar vanliga strängrepresentationer av DateTime värden.
Anpassade formatsträngar för datum och tid Beskriver anpassade formatsträngar som skapar programspecifika format för DateTime värden.
Standard TimeSpan-formatsträngar Beskriver standardformatsträngar som skapar vanliga strängrepresentationer av tidsintervall.
Anpassade timeSpan-formatsträngar Beskriver anpassade formatsträngar som skapar programspecifika format för tidsintervall.
Uppräkningsformatsträngar Beskriver standardformatsträngar som används för att skapa strängrepresentationer av uppräkningsvärden.
Sammansatt formatering Beskriver hur du bäddar in ett eller flera formaterade värden i en sträng. Strängen kan sedan visas i konsolen eller skrivas till en dataström.
Parsa strängar Beskriver hur du initierar objekt till de värden som beskrivs av strängrepresentationer av dessa objekt. Parsning är den omvända formateringsåtgärden.

Referens