FormatException Class (System) (original) (raw)

using System;  
public class Example  
{  
   public static void Main()  
   {  
      decimal price = 169.32m;  
      Console.WriteLine("The cost is {0:Q2}.", price);  
   }  
}  
// The example displays the following output:  
//    Unhandled Exception: System.FormatException: Format specifier was invalid.  
//       at System.Number.FormatDecimal(Decimal value, String format, NumberFormatInfo info)  
//       at System.Decimal.ToString(String format, IFormatProvider provider)  
//       at System.Text.StringBuilder.AppendFormat(IFormatProvider provider, String format, Object[] args)  
//       at System.IO.TextWriter.WriteLine(String format, Object arg0)  
//       at System.IO.TextWriter.SyncTextWriter.WriteLine(String format, Object arg0)  
//       at Example.Main()  
let price = 169.32m  
printfn $"The cost is {price:Q2}."  
// The example displays the following output:  
//    Unhandled Exception: System.FormatException: Format specifier was invalid.  
//       at System.Number.NumberToString(ValueStringBuilder& sb, NumberBuffer& number, Char format, Int32 nMaxDigits, NumberFormatInfo info)  
//       at System.Number.TryFormatDecimal(Decimal value, ReadOnlySpan`1 format, NumberFormatInfo info, Span`1 destination, Int32& charsWritten)  
//       at System.Decimal.TryFormat(Span`1 destination, Int32& charsWritten, ReadOnlySpan`1 format, IFormatProvider provider)  
//       at System.Text.ValueStringBuilder.AppendFormatHelper(IFormatProvider provider, String format, ParamsArray args)  
//       at System.String.FormatHelper(IFormatProvider provider, String format, ParamsArray args)  
//       at Microsoft.FSharp.Core.PrintfImpl.InterpolandToString@917.Invoke(Object vobj)  
//       at Microsoft.FSharp.Core.PrintfImpl.PrintfEnv`3.RunSteps(Object[] args, Type[] argTys, Step[] steps)  
//       at Microsoft.FSharp.Core.PrintfModule.gprintf[a,TState,TResidue,TResult,TPrinter](FSharpFunc`2 envf, PrintfFormat`4 format)  
//       at <StartupCode$fs>.$Example.main@()  
Module Example  
   Public Sub Main()  
      Dim price As Decimal = 169.32d  
      Console.WriteLine("The cost is {0:Q2}.", price)  
   End Sub  
End Module  
' The example displays the following output:  
'    Unhandled Exception: System.FormatException: Format specifier was invalid.  
'       at System.Number.FormatDecimal(Decimal value, String format, NumberFormatInfo info)  
'       at System.Decimal.ToString(String format, IFormatProvider provider)  
'       at System.Text.StringBuilder.AppendFormat(IFormatProvider provider, String format, Object[] args)  
'       at System.IO.TextWriter.WriteLine(String format, Object arg0)  
'       at System.IO.TextWriter.SyncTextWriter.WriteLine(String format, Object arg0)  
'       at Example.Main()  

This exception results from a coding error. To correct the error, either remove the format string or substitute a valid one. The following example corrects the error by replacing the invalid format string with the "C" (currency) format string.

using System;  
public class Example  
{  
   public static void Main()  
   {  
      decimal price = 169.32m;  
      Console.WriteLine("The cost is {0:C2}.", price);  
   }  
}  
// The example displays the following output:  
//    The cost is $169.32.  
let price = 169.32m  
printfn $"The cost is {price:C2}."  
// The example displays the following output:  
//    The cost is $169.32.  
Module Example  
   Public Sub Main()  
      Dim price As Decimal = 169.32d  
      Console.WriteLine("The cost is {0:C2}.", price)  
   End Sub  
End Module  
' The example displays the following output:  
'   The cost is $169.32.  

A FormatException exception can also be thrown by parsing methods, such as DateTime.ParseExact and Guid.ParseExact, that require the string to be parsed to conform exactly to the pattern specified by a format string. In the following example, the string representation of a GUID is expected to conform to the pattern specified by the "G" standard format string. However, the Guid structure's implementation of IFormattable does not support the "G" format string.

using System;  
public class Example  
{  
   public static void Main()  
   {  
      string guidString = "ba748d5c-ae5f-4cca-84e5-1ac5291c38cb";  
      Console.WriteLine(Guid.ParseExact(guidString, "G"));  
   }  
}  
// The example displays the following output:  
//    Unhandled Exception: System.FormatException:  
//       Format String can be only "D", "d", "N", "n", "P", "p", "B", "b", "X" or "x".  
//       at System.Guid.ParseExact(String input, String format)  
//       at Example.Main()  
open System  
let guidString = "ba748d5c-ae5f-4cca-84e5-1ac5291c38cb"  
printfn $"""{Guid.ParseExact(guidString, "G")}"""  
// The example displays the following output:  
//    Unhandled Exception: System.FormatException:  
//       Format String can be only "D", "d", "N", "n", "P", "p", "B", "b", "X" or "x".  
//       at System.Guid.ParseExact(String input, String format)  
//       at <StartupCode$fs>.$Example.main@()  
Module Example  
   Public Sub Main()  
      Dim guidString As String = "ba748d5c-ae5f-4cca-84e5-1ac5291c38cb"  
      Console.WriteLine(Guid.ParseExact(guidString, "G"))  
   End Sub  
End Module  
' The example displays the following output:  
'    Unhandled Exception: System.FormatException:  
'       Format String can be only "D", "d", "N", "n", "P", "p", "B", "b", "X" or "x".  
'       at System.Guid.ParseExact(String input, String format)  
'       at Example.Main()  

This exception also results from a coding error. To correct it, call a parsing method that doesn't require a precise format, such as DateTime.Parse or Guid.Parse, or substitute a valid format string. The following example corrects the error by calling the Guid.Parse method.

using System;  
public class Example  
{  
   public static void Main()  
   {  
      string guidString = "ba748d5c-ae5f-4cca-84e5-1ac5291c38cb";  
      Console.WriteLine(Guid.Parse(guidString));  
   }  
}  
// The example displays the following output:  
//    ba748d5c-ae5f-4cca-84e5-1ac5291c38cb  
open System  
let guidString = "ba748d5c-ae5f-4cca-84e5-1ac5291c38cb"  
printfn $"{Guid.Parse guidString}"  
// The example displays the following output:  
//    ba748d5c-ae5f-4cca-84e5-1ac5291c38cb  
Module Example  
   Public Sub Main()  
      Dim guidString As String = "ba748d5c-ae5f-4cca-84e5-1ac5291c38cb"  
      Console.WriteLine(Guid.Parse(guidString))  
   End Sub  
End Module  
' The example displays the following output:  
'   ba748d5c-ae5f-4cca-84e5-1ac5291c38cb  
using System;  
public class Example  
{  
   public enum TemperatureScale  
   { Celsius, Fahrenheit, Kelvin }  
   public static void Main()  
   {  
      String info = GetCurrentTemperature();  
      Console.WriteLine(info);  
   }  
   private static String GetCurrentTemperature()  
   {  
      DateTime dat = DateTime.Now;  
      Decimal temp = 20.6m;  
      TemperatureScale scale = TemperatureScale.Celsius;  
      String result;  
      result = String.Format("At {0:t} on {1:D}, the temperature is {2:F1} {3:G}",  
                             dat, temp, scale);  
      return result;  
   }  
}  
// The example displays output like the following:  
//    Unhandled Exception: System.FormatException: Format specifier was invalid.  
//       at System.Number.FormatDecimal(Decimal value, String format, NumberFormatInfo info)  
//       at System.Decimal.ToString(String format, IFormatProvider provider)  
//       at System.Text.StringBuilder.AppendFormat(IFormatProvider provider, String format, Object[] args)  
//       at System.String.Format(IFormatProvider provider, String format, Object[] args)  
//       at Example.Main()  
open System  
type TemperatureScale =  
    | Celsius = 0  
    | Fahrenheit = 1  
    | Kelvin = 2  
let getCurrentTemperature () =  
    let dat = DateTime.Now  
    let temp = 20.6m  
    let scale = TemperatureScale.Celsius  
    String.Format("At {0:t} on {1:D}, the temperature is {2:F1} {3:G}", dat, temp, scale)  
getCurrentTemperature ()  
|> printfn "%s"  
// The example displays output like the following:  
//    Unhandled Exception: System.FormatException: Format specifier was invalid.  
//       at System.Number.NumberToString(ValueStringBuilder& sb, NumberBuffer& number, Char format, Int32 nMaxDigits, NumberFormatInfo info)  
//       at System.Number.TryFormatDecimal(Decimal value, ReadOnlySpan`1 format, NumberFormatInfo info, Span`1 destination, Int32& charsWritten)  
//       at System.Decimal.TryFormat(Span`1 destination, Int32& charsWritten, ReadOnlySpan`1 format, IFormatProvider provider)  
//       at System.Text.ValueStringBuilder.AppendFormatHelper(IFormatProvider provider, String format, ParamsArray args)  
//       at System.String.FormatHelper(IFormatProvider provider, String format, ParamsArray args)  
//       at System.String.Format(String format, Object arg0, Object arg1, Object arg2)  
//       at Example.getCurrentTemperature()  
//       at <StartupCode$fs>.$Example.main@()  
Module Example  
   Public Enum TemperatureScale As Integer  
      Celsius  
      Fahrenheit  
      Kelvin  
   End Enum  
   Public Sub Main()  
      Dim info As String = GetCurrentTemperature()  
      Console.WriteLine(info)  
   End Sub  
   Private Function GetCurrentTemperature() As String  
      Dim dat As Date = Date.Now  
      Dim temp As Decimal = 20.6d  
      Dim scale As TemperatureScale = TemperatureScale.Celsius  
      Dim result As String  
        
      result = String.Format("At {0:t} on {1:D}, the temperature is {2:F1} {3:G}",  
                             dat, temp, scale)  
      Return result  
   End Function  
End Module  
' The example displays output like the following:  
'    Unhandled Exception: System.FormatException: Format specifier was invalid.  
'       at System.Number.FormatDecimal(Decimal value, String format, NumberFormatInfo info)  
'       at System.Decimal.ToString(String format, IFormatProvider provider)  
'       at System.Text.StringBuilder.AppendFormat(IFormatProvider provider, String format, Object[] args)  
'       at System.String.Format(IFormatProvider provider, String format, Object[] args)  
'       at Example.Main()  

In this case, the FormatException exception is a result of developer error. It should be corrected rather than handled in a try/catch block by making sure that each item in the object list corresponds to the index of a format item. To correct this example, change the index of the second format item to refer to the dat variable, and decrement the index of each subsequent format item by one.

using System;  
public class Example  
{  
   public enum TemperatureScale  
   { Celsius, Fahrenheit, Kelvin }  
   public static void Main()  
   {  
      String info = GetCurrentTemperature();  
      Console.WriteLine(info);  
   }  
   private static String GetCurrentTemperature()  
   {  
      DateTime dat = DateTime.Now;  
      Decimal temp = 20.6m;  
      TemperatureScale scale = TemperatureScale.Celsius;  
      String result;  
      result = String.Format("At {0:t} on {0:D}, the temperature is {1:F1} {2:G}",  
                             dat, temp, scale);  
      return result;  
   }  
}  
// The example displays output like the following:  
//    At 10:40 AM on Wednesday, June 04, 2014, the temperature is 20.6 Celsius  
open System  
type TemperatureScale =  
    | Celsius = 0  
    | Fahrenheit = 1  
    | Kelvin = 2  
let getCurrentTemperature () =  
    let dat = DateTime.Now  
    let temp = 20.6m  
    let scale = TemperatureScale.Celsius  
    String.Format("At {0:t} on {0:D}, the temperature is {1:F1} {2:G}", dat, temp, scale)  
getCurrentTemperature ()  
|> printfn "%s"  
// The example displays output like the following:  
//    At 10:40 AM on Wednesday, June 04, 2014, the temperature is 20.6 Celsius  
Module Example  
   Public Enum TemperatureScale As Integer  
      Celsius  
      Fahrenheit  
      Kelvin  
   End Enum  
   Public Sub Main()  
      Dim info As String = GetCurrentTemperature()  
      Console.WriteLine(info)  
   End Sub  
   Private Function GetCurrentTemperature() As String  
      Dim dat As Date = Date.Now  
      Dim temp As Decimal = 20.6d  
      Dim scale As TemperatureScale = TemperatureScale.Celsius  
      Dim result As String  
        
      result = String.Format("At {0:t} on {0:D}, the temperature is {1:F1} {2:G}",  
                             dat, temp, scale)  
      Return result  
   End Function  
End Module  
' The example displays output like the following:  
'       At 10:40 AM on Wednesday, June 04, 2014, the temperature is 20.6 Celsius  
result = String.Format("The text has {0} '{' characters and {1} '}' characters.",  
                       nOpen, nClose);  
let result =  
    String.Format("The text has {0} '{' characters and {1} '}' characters.", nOpen, nClose)  
result = String.Format("The text has {0} '{' characters and {1} '}' characters.",  
                       nOpen, nClose)  

The recommended technique for including literal braces in a composite format string is to include them in the object list and use format items to insert them into the result string. For example, you can modify the previous composite format string as shown here.

string result;  
int nOpen = 1;  
int nClose = 2;  
result = String.Format("The text has {0} '{{' characters and {1} '}}' characters.",  
                       nOpen, nClose);  
Console.WriteLine(result);  
let result =  
    String.Format("The text has {0} '{{' characters and {1} '}}' characters.", nOpen, nClose)  
result = String.Format("The text has {0} '{{' characters and {1} '}}' characters.",  
                       nOpen, nClose)  

The exception is also thrown if your format string contains a typo. The following call to the String.Format method omits a closing brace and pairs an opening brace with a closing bracket.

int n1 = 10;  
int n2 = 20;  
String result = String.Format("{0 + {1] = {2}",  
                              n1, n2, n1 + n2);  
let n1 = 10  
let n2 = 20  
String result = String.Format("{0 + {1] = {2}",  
                            n1, n2, n1 + n2)  
Dim n1 As Integer = 10  
Dim n2 As Integer = 20  
Dim result As String = String.Format("{0 + {1] = {2}",  
                                     n1, n2, n1 + n2)  

To correct the error, ensure that all opening and closing braces correspond.

String result = String.Format("{0} + {1} = {2}",  
                              n1, n2, n1 + n2);  
let result = String.Format("{0} + {1} = {2}", n1, n2, n1 + n2)  
Dim result As String = String.Format("{0} + {1} = {2}",  
                                     n1, n2, n1 + n2)  
using System;  
using System.Collections.Generic;  
public class Example  
{  
   public static void Main()  
   {  
      Random rnd = new Random();  
      int[]  numbers = new int[4];  
      int total = 0;  
      for (int ctr = 0; ctr <= 2; ctr++) {  
         int number = rnd.Next(1001);  
         numbers[ctr] = number;  
         total += number;  
      }  
      numbers[3] = total;  
      Console.WriteLine("{0} + {1} + {2} = {3}", numbers);  
   }  
}  
// The example displays the following output:  
//    Unhandled Exception:  
//    System.FormatException:  
//       Index (zero based) must be greater than or equal to zero and less than the size of the argument list.  
//       at System.Text.StringBuilder.AppendFormat(IFormatProvider provider, String format, Object[] args)  
//       at System.IO.TextWriter.WriteLine(String format, Object arg0)  
//       at System.IO.TextWriter.SyncTextWriter.WriteLine(String format, Object arg0)  
//       at Example.Main()  
open System  
let rnd = Random()  
let numbers = Array.zeroCreate<int> 4  
let mutable total = 0  
for i = 0 to 2 do  
    let number = rnd.Next 1001  
    numbers[i] <- number  
    total <- total + number  
numbers[3] <- total  
Console.WriteLine("{0} + {1} + {2} = {3}", numbers)  
// The example displays the following output:  
//    Unhandled Exception:  
//    System.FormatException:  
//       Index (zero based) must be greater than or equal to zero and less than the size of the argument list.  
//       at System.Text.StringBuilder.AppendFormat(IFormatProvider provider, String format, Object[] args)  
//       at System.IO.TextWriter.WriteLine(String format, Object arg0)  
//       at System.IO.TextWriter.SyncTextWriter.WriteLine(String format, Object arg0)  
//       at <StartupCode$fs>.$Example.main@()  
Imports System.Collections.Generic  
Module Example  
   Public Sub Main()  
      Dim rnd As New Random()  
      Dim numbers(3) As Integer  
      Dim total As Integer = 0  
      For ctr = 0 To 2  
         Dim number As Integer = rnd.Next(1001)  
         numbers(ctr) = number  
         total += number  
      Next  
      numbers(3) = total  
      Console.WriteLine("{0} + {1} + {2} = {3}", numbers)  
   End Sub  
End Module  
' The example displays the following output:  
'    Unhandled Exception:  
'    System.FormatException:  
'       Index (zero based) must be greater than or equal to zero and less than the size of the argument list.  
'       at System.Text.StringBuilder.AppendFormat(IFormatProvider provider, String format, Object[] args)  
'       at System.IO.TextWriter.WriteLine(String format, Object arg0)  
'       at System.IO.TextWriter.SyncTextWriter.WriteLine(String format, Object arg0)  
'       at Example.Main()  

Instead of handling this exception, you should eliminate its cause. Because neither Visual Basic nor C# can convert an integer array to an object array, you have to perform the conversion yourself before calling the composite formatting method. The following example provides one implementation.

using System;  
using System.Collections.Generic;  
public class Example  
{  
   public static void Main()  
   {  
      Random rnd = new Random();  
      int[]  numbers = new int[4];  
      int total = 0;  
      for (int ctr = 0; ctr <= 2; ctr++) {  
         int number = rnd.Next(1001);  
         numbers[ctr] = number;  
         total += number;  
      }  
      numbers[3] = total;  
      object[] values = new object[numbers.Length];  
      numbers.CopyTo(values, 0);  
      Console.WriteLine("{0} + {1} + {2} = {3}", values);  
   }  
}  
// The example displays output like the following:  
//        477 + 956 + 901 = 2334  
open System  
let rnd = Random()  
let numbers = Array.zeroCreate<int> 4  
let mutable total = 0  
for i = 0 to 2 do  
    let number = rnd.Next 1001  
    numbers[i] <- number  
    total <- total + number  
numbers[3] <- total  
let values = Array.zeroCreate<obj> numbers.Length  
numbers.CopyTo(values, 0)  
Console.WriteLine("{0} + {1} + {2} = {3}", values)  
// The example displays output like the following:  
//        477 + 956 + 901 = 2334  
Imports System.Collections.Generic  
Module Example  
   Public Sub Main()  
      Dim rnd As New Random()  
      Dim numbers(3) As Integer  
      Dim total As Integer = 0  
      For ctr = 0 To 2  
         Dim number As Integer = rnd.Next(1001)  
         numbers(ctr) = number  
         total += number  
      Next  
      numbers(3) = total  
      Dim values(numbers.Length - 1) As Object  
      numbers.CopyTo(values, 0)  
      Console.WriteLine("{0} + {1} + {2} = {3}", values)  
   End Sub  
End Module  
' The example displays output like the following:  
'       477 + 956 + 901 = 2334