FormatException Klasse

Definition

Namespace:

System

Assembly:

System.Runtime.dll

Quelle:

FormatException.cs

Die Ausnahme, die ausgelöst wird, wenn das Format eines Arguments ungültig ist, oder wenn eine kombinierte Formatierungszeichenfolge nicht wohlgeformt ist.

public ref class FormatException : SystemException

public class FormatException : SystemException

type FormatException = class
    inherit SystemException

Public Class FormatException
Inherits SystemException

Vererbung

Object

Exception

SystemException

FormatException

Abgeleitet

System.IO.FileFormatException

System.Net.CookieException

System.Reflection.CustomAttributeFormatException

System.UriFormatException

Hinweise

Eine FormatException Ausnahme kann aus einem der folgenden Gründe ausgelöst werden:

• Bei einem Aufruf einer Methode, die eine Zeichenfolge in einen anderen Datentyp konvertiert, entspricht die Zeichenfolge nicht dem erforderlichen Muster. Dies tritt in der Regel auf, wenn einige Methoden der Convert -Klasse und die Parse Methoden und ParseExact einiger Typen aufgerufen werden.

  In den meisten Fällen, insbesondere wenn die von Ihnen konvertierte Zeichenfolge von einem Benutzer eingegeben oder aus einer Datei gelesen wird, sollten Sie einen try/catch (try/with in F#)-Block verwenden und die FormatException Ausnahme behandeln, wenn die Konvertierung nicht erfolgreich ist. Sie können den Aufruf der Konvertierungsmethode auch durch einen Aufruf einer TryParse - oder TryParseExact -Methode ersetzen, sofern vorhanden. Eine Ausnahme, die ausgelöst wird, wenn Sie versuchen, FormatException eine vordefinierte oder hartcodierte Zeichenfolge zu analysieren, weist jedoch auf einen Programmfehler hin. In diesem Fall sollten Sie den Fehler korrigieren, anstatt die Ausnahme zu behandeln.

  Die Konvertierung einer Zeichenfolge in die folgenden Typen im System Namespace kann eine FormatException Ausnahme auslösen:

  • Boolean. Für Boolean.Parse(String) die Methoden und Convert.ToBoolean(String) muss die Zeichenfolge in "True", "true", "False" oder "false" konvertiert werden. Jeder andere Wert löst eine Ausnahme aus FormatException .

  • DateTime und DateTimeOffset. Alle Datums- und Uhrzeitdaten werden basierend auf den Formatierungskonventionen einer bestimmten Kultur interpretiert: entweder der aktuellen Kultur (oder in einigen Fällen der aktuellen Anwendungsdomänenkultur), der invarianten Kultur oder einer angegebenen Kultur. Wenn Sie die DateTime.ParseExact(String, String, IFormatProvider, DateTimeStyles) Methoden und DateTimeOffset.ParseExact(String, String[], IFormatProvider, DateTimeStyles) aufrufen, müssen Datums- und Uhrzeitdaten auch genau mit einem Muster übereinstimmen, das durch eine oder mehrere Standardformatzeichenfolgen oder benutzerdefinierte Formatzeichenfolgen angegeben wird, die als Argumente im Methodenaufruf bereitgestellt werden. Wenn es nicht einem erwarteten kulturspezifischen Muster entspricht, wird eine FormatException Ausnahme ausgelöst. Dies bedeutet, dass Datums- und Uhrzeitdaten, die in einem kulturspezifischen Format auf einem System gespeichert werden, möglicherweise nicht erfolgreich auf einem anderen System analysiert werden.

    Weitere Informationen zum Analysieren von Datums- und Uhrzeitangaben finden Sie unter Analysieren von Datums- und Uhrzeitzeichenfolgen und in der Dokumentation für die Methode, die die Ausnahme ausgelöst hat.

  • GUIDs. Die Zeichenfolgendarstellung einer GUID muss aus 32 Hexadezimalziffern (0-F) bestehen und in einem der fünf Formate vorliegen, die von der Guid.ToString -Methode ausgegeben werden. Weitere Informationen finden Sie unter der Methode Guid.Parse.

  • Numerische Typen, einschließlich aller ganzzahligen Vorzeichen, Ganzzahlen ohne Vorzeichen und Gleitkommatypen. Die zu analysierende Zeichenfolge muss aus den lateinischen Ziffern 0-9 bestehen. Ein positives oder negatives Vorzeichen, Dezimaltrennzeichen, Gruppentrennzeichen und Währungssymbol können ebenfalls zulässig sein. Wenn Sie versuchen, eine Zeichenfolge zu analysieren, die ein anderes Zeichen enthält, wird immer eine FormatException Ausnahme ausgelöst.

    Alle numerischen Zeichenfolgen werden basierend auf den Formatierungskonventionen einer bestimmten Kultur interpretiert: entweder der aktuellen Kultur, der invarianten Kultur oder einer angegebenen Kultur. Daher kann eine numerische Zeichenfolge, die mithilfe der Konventionen einer Kultur analysiert wird, fehlschlagen, wenn die Konventionen einer anderen Kultur verwendet werden.

    Weitere Informationen zum Analysieren numerischer Zeichenfolgen finden Sie unter Analysieren numerischer Zeichenfolgen und in der Dokumentation für die spezifische Methode, die die Ausnahme ausgelöst hat.

  • Zeitintervalle. Die zu analysierende Zeichenfolge muss entweder in einem festen kulturunabhängigen Format oder in einem kulturabhängigen Format vorliegen, das von der aktuellen Kultur, der invarianten Kultur oder einer angegebenen Kultur definiert wird. Wenn die Zeichenfolge nicht in einem geeigneten Format vorliegt oder mindestens die Komponenten tage, stunden und minuten des Zeitintervalls nicht vorhanden sind, löst die Analysemethode eine Ausnahme aus FormatException . Weitere Informationen finden Sie in der Dokumentation zur TimeSpan Analysemethode, die die Ausnahme ausgelöst hat.

• Ein Typ implementiert die IFormattable -Schnittstelle, die Formatzeichenfolgen unterstützt, die definieren, wie ein Objekt in seine Zeichenfolgendarstellung konvertiert wird, und eine ungültige Formatzeichenfolge verwendet wird. Dies ist am häufigsten bei einem Formatierungsvorgang der Fall. Im folgenden Beispiel wird die Standardformatzeichenfolge "Q" in einer zusammengesetzten Formatzeichenfolge verwendet, um eine Zahl zu formatieren. "Q" ist jedoch keine gültige Standardformatzeichenfolge.

  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()
  

  Diese Ausnahme ergibt sich aus einem Codierungsfehler. Um den Fehler zu beheben, entfernen Sie entweder die Formatzeichenfolge, oder ersetzen Sie eine gültige. Im folgenden Beispiel wird der Fehler korrigiert, indem die ungültige Formatzeichenfolge durch die Formatzeichenfolge "C" (Währung) ersetzt wird.

  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.
  

  Eine FormatException Ausnahme kann auch durch Analysemethoden wie DateTime.ParseExact und Guid.ParseExactausgelöst werden, bei denen die Zeichenfolge analysiert werden muss, damit sie genau dem muster entspricht, das von einer Formatzeichenfolge angegeben wird. Im folgenden Beispiel wird erwartet, dass die Zeichenfolgendarstellung einer GUID dem Muster entspricht, das durch die Standardformatzeichenfolge "G" angegeben wird. Die Guid -Implementierung der IFormattable -Struktur unterstützt jedoch nicht die Formatzeichenfolge "G".

  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()
  

  Diese Ausnahme resultiert auch aus einem Codierungsfehler. Um dies zu korrigieren, rufen Sie eine Analysemethode auf, die kein genaues Format erfordert, z DateTime.Parse . B. oder Guid.Parse, oder ersetzen Sie eine gültige Formatzeichenfolge. Im folgenden Beispiel wird der Fehler durch Aufrufen der Guid.Parse -Methode korrigiert.

  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
  

• Mindestens einer der Indizes der Formatelemente in einer zusammengesetzten Formatzeichenfolge ist größer als die Indizes der Elemente in der Objektliste oder dem Parameterarray. Im folgenden Beispiel ist der größte Index eines Formatelements in der Formatzeichenfolge 3. Da die Indizes der Elemente in der Objektliste nullbasiert sind, muss die Objektliste für diese Formatzeichenfolge vier Elemente enthalten. Stattdessen enthält sie nur die drei, dat, tempund scale, sodass der Code zur Laufzeit eine FormatException Ausnahme ergibt: .

  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 diesem Fall ist die FormatException Ausnahme das Ergebnis eines Entwicklerfehlers. Es sollte korrigiert und nicht in einem try/catch -Block behandelt werden, indem sichergestellt wird, dass jedes Element in der Objektliste dem Index eines Formatelements entspricht. Um dieses Beispiel zu korrigieren, ändern Sie den Index des zweiten Formatelements, um auf die dat Variable zu verweisen, und verringern Sie den Index jedes nachfolgenden Formatelements um eins.

  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
  

• Die Zeichenfolge im zusammengesetzten Format ist nicht wohlgeformt. In diesem Fall ist die FormatException Ausnahme immer das Ergebnis eines Entwicklerfehlers. Es sollte korrigiert werden, anstatt in einem try/catch -Block behandelt zu werden.

  Wenn Sie versuchen, literale Klammern in eine Zeichenfolge einzuschließen, wie im folgenden Beispiel, wird die Ausnahme ausgelöst.

  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)
  

  Die empfohlene Technik zum Einschließen von Literalklammern in eine zusammengesetzte Formatzeichenfolge besteht darin, sie in die Objektliste einzuschließen und Formatelemente zu verwenden, um sie in die Ergebniszeichenfolge einzufügen. Sie können z. B. die vorherige zusammengesetzte Formatzeichenfolge ändern, wie hier gezeigt.

  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)
  

  Die Ausnahme wird auch ausgelöst, wenn die Formatzeichenfolge einen Tippfehler enthält. Beim folgenden Aufruf der String.Format -Methode wird eine schließende Klammer weggelassen und eine öffnende geschweifte Klammer mit einer schließenden Klammer gekoppelt.

  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)
  

  Stellen Sie sicher, dass alle öffnenden und schließenden Klammern übereinstimmen, um den Fehler zu beheben.

  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)
  

• Sie haben die Objektliste in einer zusammengesetzten Formatierungsmethode als stark typisiertes Parameterarray angegeben, und die FormatException Ausnahme gibt an, dass der Index eines oder mehrerer Formatelemente die Anzahl der Argumente in der Objektliste überschreitet. Dies liegt daran, dass keine explizite Konvertierung zwischen Arraytypen vorhanden ist. Stattdessen behandelt der Compiler das Array als einzelnes Argument und nicht als Parameterarray. Der folgende Aufruf der Console.WriteLine(String, Object[]) -Methode löst beispielsweise eine Ausnahme aus FormatException , obwohl der höchste Index der Formatelemente 3 ist und das Parameterarray vom Typ Int32 vier Elemente aufweist.

  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()
  

  Anstatt diese Ausnahme zu behandeln, sollten Sie deren Ursache beseitigen. Da weder Visual Basic noch C# ein ganzzahliges Array in ein Objektarray konvertieren können, müssen Sie die Konvertierung selbst durchführen, bevor Sie die zusammengesetzte Formatierungsmethode aufrufen. Der folgende Code zeigt ein Implementierungsbeispiel.

  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
  

FormatException verwendet das HRESULT-COR_E_FORMAT, das den Wert 0x80131537 hat.

Die FormatException -Klasse wird von Exception abgeleitet und fügt keine eindeutigen Member hinzu. Eine Liste der anfänglichen Eigenschaftswerte für eine Instanz von FormatException, finden Sie unter den FormatException Konstruktoren.

Konstruktoren

FormatException()	Initialisiert eine neue Instanz der FormatException-Klasse.
FormatException(SerializationInfo, StreamingContext)	Veraltet. Initialisiert eine neue Instanz der FormatException-Klasse mit serialisierten Daten.
FormatException(String)	Initialisiert eine neue Instanz der FormatException-Klasse mit einer angegebenen Fehlermeldung.
FormatException(String, Exception)	Initialisiert eine neue Instanz der FormatException-Klasse mit einer angegebenen Fehlermeldung und einem Verweis auf die innere Ausnahme, die diese Ausnahme ausgelöst hat.

Eigenschaften

Data	Ruft eine Auflistung von Schlüssel-Wert-Paaren ab, die zusätzliche benutzerdefinierte Informationen zur Ausnahme bereitstellen. (Geerbt von Exception)
HelpLink	Ruft einen Link zur Hilfedatei ab, die dieser Ausnahme zugeordnet ist, oder legt einen Link fest. (Geerbt von Exception)
HResult	Ruft HRESULT ab oder legt HRESULT fest. Dies ist ein codierter Wert, der einer bestimmten Ausnahme zugeordnet ist. (Geerbt von Exception)
InnerException	Ruft die Exception-Instanz ab, die die aktuelle Ausnahme verursacht hat. (Geerbt von Exception)
Message	Ruft eine Meldung ab, mit der die aktuelle Ausnahme beschrieben wird. (Geerbt von Exception)
Source	Gibt den Namen der Anwendung oder des Objekts zurück, die bzw. das den Fehler verursacht hat, oder legt diesen fest. (Geerbt von Exception)
StackTrace	Ruft eine Zeichenfolgendarstellung der unmittelbaren Frames in der Aufrufliste ab. (Geerbt von Exception)
TargetSite	Ruft die Methode ab, die die aktuelle Ausnahme auslöst. (Geerbt von Exception)

Methoden

Equals(Object)	Bestimmt, ob das angegebene Objekt gleich dem aktuellen Objekt ist. (Geerbt von Object)
GetBaseException()	Gibt beim Überschreiben in einer abgeleiteten Klasse eine Exception zurück, die die Grundursache für eine oder mehrere nachfolgende Ausnahmen ist. (Geerbt von Exception)
GetHashCode()	Fungiert als Standardhashfunktion. (Geerbt von Object)
GetObjectData(SerializationInfo, StreamingContext)	Veraltet. Legt beim Überschreiben in einer abgeleiteten Klasse die SerializationInfo mit Informationen über die Ausnahme fest. (Geerbt von Exception)
GetType()	Ruft den Laufzeittyp der aktuellen Instanz ab. (Geerbt von Exception)
MemberwiseClone()	Erstellt eine flache Kopie des aktuellen Object. (Geerbt von Object)
ToString()	Erstellt eine Zeichenfolgendarstellung der aktuellen Ausnahme und gibt diese zurück. (Geerbt von Exception)

Ereignisse

SerializeObjectState

Veraltet. Tritt auf, wenn eine Ausnahme serialisiert wird, um ein Ausnahmezustandsobjekt mit serialisierten Daten über die Ausnahme zu erstellen. (Geerbt von Exception)

Weitere Informationen

• Exception
• Behandeln und Auslösen von Ausnahmen