Overview: How to format numbers, dates, enums, and other types in .NET

// <Snippet1>
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
// </Snippet1>

' Visual Basic .NET Document
Option Strict On

' <Snippet1>
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
' </Snippet1>

namespace HotAndCold2
{
    // <Snippet2>
    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.
    // </Snippet2>
}

' Visual Basic .NET Document
Option Strict On

' <Snippet2>
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.
' </Snippet2>

using System;

public class Example16
{
   public static void Main()
   {
      // <Snippet4>
      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
      // </Snippet4>
   }
}

' Visual Basic .NET Document
Option Strict On

Module Example17
    Public Sub Main17()
        ' <Snippet4>
        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
        ' </Snippet4>
    End Sub
End Module

using System;

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

' Visual Basic .NET Document
Option Strict On

Module Example14
    Public Sub Main14()
        ' <Snippet6>
        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
        ' </Snippet6>
    End Sub
End Module

// <Snippet5>
using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      DateTime date1 = new DateTime(2009, 6, 30);
      Console.WriteLine($"D Format Specifier:     {date1:D}");
      string longPattern = CultureInfo.CurrentCulture.DateTimeFormat.LongDatePattern;
      Console.WriteLine($"'{longPattern}' custom format string:     {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
// </Snippet5>

' Visual Basic .NET Document
Option Strict On

' <Snippet5>
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
' </Snippet5>

// <Snippet7>
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.
// </Snippet7>

Option Strict On

Namespace HotAndCold

    ' <Snippet7>
    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.
    ' </Snippet7>

End Namespace

using System;

public class Example14
{
   public static void Main()
   {
      // <Snippet8>
      DateTime date1 = new DateTime(2009, 9, 8);
      Console.WriteLine(date1.ToString("%M"));       // Displays 9
      // </Snippet8>
   }
}

' Visual Basic .NET Document
Option Strict On

Module Example15
    Public Sub Main15()
        ' <Snippet8>
        Dim date1 As Date = #09/08/2009#
        Console.WriteLine(date1.ToString("%M"))      ' Displays 9
        ' </Snippet8>
    End Sub
End Module

using System;

public class Example8
{
   public static void Main()
   {
      // <Snippet9>
      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)
      // </Snippet9>
   }
}

' Visual Basic .NET Document
Option Strict On

Module Example8
    Public Sub Main8()
        ' <Snippet9>
        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)      
        ' </Snippet9>
    End Sub
End Module

// <Snippet21>
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
// </Snippet21>

' Visual Basic .NET Document
Option Strict On

' <Snippet21>
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
' </Snippet21>

// <Snippet11>
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 €
// </Snippet11>

Option Strict On

' <Snippet11>
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 €
' </Snippet11>

// <Snippet19>
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 €
// </Snippet19>

' Visual Basic .NET Document
Option Strict On

' <Snippet19>
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 €
' </Snippet19>

// <Snippet20>
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
// </Snippet20>

' Visual Basic .NET Document
Option Strict On

' <Snippet20>
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
' </Snippet20>

// <Snippet17>
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
// </Snippet17>

' Visual Basic .NET Document
Option Strict On

' <Snippet17>
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 
' </Snippet17>

// <Snippet18>
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
// </Snippet18>

' Visual Basic .NET Document
Option Strict On

' <Snippet18>
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
' </Snippet18>

// <Snippet12>
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));
            }
        }
    }
    // </Snippet12>

    // <Snippet13>
    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: {temp:K}");
            Console.WriteLine($"Temperature: {temp:F}");
            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
    // </Snippet13>
}

Option Strict On
Imports System.Globalization

Namespace HotAndCold2

    ' <Snippet12>
    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
    ' </Snippet12>

    ' <Snippet13>
    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
    ' </Snippet13>

End Namespace

// <Snippet12>
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));
            }
        }
    }
    // </Snippet12>

    // <Snippet13>
    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: {temp:K}");
            Console.WriteLine($"Temperature: {temp:F}");
            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
    // </Snippet13>
}

Option Strict On
Imports System.Globalization

Namespace HotAndCold2

    ' <Snippet12>
    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
    ' </Snippet12>

    ' <Snippet13>
    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
    ' </Snippet13>

End Namespace

using System;

public class Product
{
   private string productName;
   private int onHand;
   private decimal cost;

   public Product(string name)
   {
      this.productName = name;
   }

   public int Quantity
   {
      get { return this.onHand; }
      set { this.onHand = value; }
   }

   public decimal Price
   {
      get { return this.cost; }
      set { this.cost = value; }
   }

   public decimal Value
   {
      get { return this.cost * this.onHand; }
   }

   public string Name
   {
      get { return this.productName; }
   }

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

public class Example2
{
   public static void Main()
   {
      Product item1 = new Product("WidgetA");
      item1.Quantity = 17;
      item1.Price = 6.32m;
      DateTime thatDate = new DateTime(2009, 5, 1);
      string result;
      // <Snippet14>
      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.
      // </Snippet14>
   }
}

' Visual Basic .NET Document
Option Strict On

Public Class Product
    Private productName As String
    Private onHand As Integer
    Private cost As Decimal

    Public Sub New(name As String)
        Me.productName = name
    End Sub

    Public Property Quantity As Integer
        Get
            Return Me.onHand
        End Get
        Set
            Me.onHand = value
        End Set
    End Property

    Public Property Price As Decimal
        Get
            Return Me.cost
        End Get
        Set
            Me.cost = value
        End Set
    End Property

    Public ReadOnly Property Value As Decimal
        Get
            Return Me.cost * Me.onHand
        End Get
    End Property

    Public ReadOnly Property Name As String
        Get
            Return Me.productName
        End Get
    End Property

    Public Overrides Function ToString() As String
        Return Me.productName
    End Function
End Class

Module Example2
    Public Sub Main2()
        Dim item1 As New Product("WidgetA")
        item1.Quantity = 17
        item1.Price = 6.32D
        Dim thatDate As DateTime = #5/1/2009#
        Dim result As String
        ' <Snippet14>
        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.
        ' </Snippet14>
    End Sub
End Module

// <Snippet15>
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 is not null) && !formatProvider.Equals(this)) return "";

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

        byte[] bytes;

        // Handle only integral types.
        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 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 "";

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

        return output.Trim();
    }
}
// </Snippet15>

// <Snippet16>
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
// </Snippet16>

' <Snippet15>
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
' </Snippet15>

' <Snippet16>
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
' </Snippet16>

// <Snippet15>
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 is not null) && !formatProvider.Equals(this)) return "";

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

        byte[] bytes;

        // Handle only integral types.
        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 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 "";

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

        return output.Trim();
    }
}
// </Snippet15>

// <Snippet16>
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
// </Snippet16>

' <Snippet15>
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
' </Snippet15>

' <Snippet16>
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
' </Snippet16>