FormatException Klasse

Definition

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 : Exception
public ref class FormatException : SystemException
public class FormatException : Exception
public class FormatException : SystemException
[System.Serializable]
public class FormatException : SystemException
[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public class FormatException : SystemException
type FormatException = class
    inherit Exception
type FormatException = class
    inherit SystemException
[<System.Serializable>]
type FormatException = class
    inherit SystemException
[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type FormatException = class
    inherit SystemException
Public Class FormatException
Inherits Exception
Public Class FormatException
Inherits SystemException
Vererbung
FormatException
Vererbung
FormatException
Abgeleitet
Attribute

Hinweise

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

  • In einem Aufruf einer Methode, die eine Zeichenfolge in einen anderen Datentyp konvertiert, entspricht die Zeichenfolge nicht dem erforderlichen Muster. Dies tritt in der Regel beim Aufrufen einiger Methoden der Convert Klasse und der Parse ParseExact Methoden einiger Typen auf.

    In den meisten Fällen sollten Sie einen try/catch (try/with in F#)-Block verwenden und die Ausnahme behandeln, wenn die FormatException Konvertierung nicht erfolgreich ist. Sie können den Aufruf der Konvertierungsmethode auch durch einen Aufruf an eine TryParse TryParseExact oder Methode ersetzen, sofern vorhanden. Eine FormatException Ausnahme, die ausgelöst wird, wenn Sie versuchen, eine vordefinierte oder hart codierte Zeichenfolge zu analysieren, gibt einen Programmfehler an. 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. Convert.ToBoolean(String) Die Boolean.Parse(String) Methoden erfordern, dass die Zeichenfolge in "True", "true", "false" oder "false" konvertiert werden soll. Jeder andere Wert löst eine FormatException Ausnahme aus.

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

      Weitere Informationen zum Analysieren von Datums- und Uhrzeitangaben finden Sie unter Parsing Date and Time Strings und die Dokumentation für die Methode, die die Ausnahme ausgelöst hat.

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

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

      Alle numerischen Zeichenfolgen werden basierend auf den Formatierungskonventionen einer bestimmten Kultur interpretiert: entweder die aktuelle Kultur, die invariante Kultur oder eine angegebene Kultur. Daher kann eine numerische Zeichenfolge, die mithilfe der Konventionen einer Kultur analysiert wird, beim Verwenden der Konventionen einer anderen fehlschlagen.

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

    • Zeitintervalle. Die zu analysierende Zeichenfolge muss entweder in einem fest definierten Kultur-Insensitive-Format oder in einem durch die aktuelle Kultur, der invarianten Kultur oder einer angegebenen Kultur definierten Kultur sein. Wenn sich die Zeichenfolge nicht in einem geeigneten Format befindet oder wenn mindestens die Tage, Stunden und Minutenkomponenten des Zeitintervalls nicht vorhanden sind, löst die Analysemethode eine FormatException Ausnahme aus. Weitere Informationen finden Sie in der TimeSpan Dokumentation zur 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 wird verwendet. Dies ist am häufigsten in einem Formatierungsvorgang. 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 führt zu einem Codierungsfehler. Um den Fehler zu korrigieren, 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 Zeichenfolge "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 ausgelöst werden, indem Methoden wie z. B. und Guid.ParseExact, die die Zeichenfolge analysieren müssen, um genau dem muster zu entsprechen, DateTime.ParseExact das durch eine Formatzeichenfolge angegeben wird. Im folgenden Beispiel wird die Zeichenfolgendarstellung einer GUID voraussichtlich dem Muster entsprechen, das durch die Standardformatzeichenfolge "G" angegeben ist. Die Guid Implementierung der IFormattable Struktur unterstützt jedoch nicht die Zeichenfolge "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 führt auch zu einem Codierungsfehler. Um es zu korrigieren, rufen Sie eine Analysemethode auf, die kein präzises 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 eine der Indizes der Formatelemente in einer zusammengesetzten Formatzeichenfolge ist größer als die Indizes der Elemente in der Objektliste oder parameterarray. Im folgenden Beispiel ist der größte Index eines Formatelements in der Formatzeichenfolge 3. Da die Indizes von Elementen in der Objektliste nullbasiert sind, erfordert diese Formatzeichenfolge die Objektliste vier Elemente. Stattdessen verfügt es nur über drei, dat, tempund scale, daher führt der Code zu einer FormatException Ausnahme zur Laufzeit:.

    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 ein Ergebnis des Entwicklerfehlers. Es sollte 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 ändern Sie den Index der einzelnen nachfolgenden Formatelemente nach einem.

    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 zusammengesetzte Formatzeichenfolge ist nicht gut gebildet. Wenn dies geschieht, ist die FormatException Ausnahme immer ein Ergebnis des Entwicklerfehlers. Es sollte nicht in einem try/catch Block behandelt werden, sondern korrigiert werden.

    Wenn Sie versuchen, Literalklammern 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 Methode zum Einschließen von Literalklammern in einer zusammengesetzten Formatzeichenfolge besteht darin, sie in die Objektliste einzuschließen und Formatelemente zum Einfügen in die Ergebniszeichenfolge zu verwenden. Sie können beispielsweise die vorherige zusammengesetzte Formatzeichenfolge wie hier gezeigt ändern.

    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 Ihre Formatzeichenfolge einen Typ enthält. Im folgenden Aufruf der String.Format Methode wird eine schließende Klammer ausgelassen und eine öffnende 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)
    

    Um den Fehler zu korrigieren, stellen Sie sicher, dass alle öffnenden und schließenden Klammern übereinstimmen.

    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 eingegebenes Parameterarray bereitgestellt, und die FormatException Ausnahme gibt an, dass der Index eines oder mehrerer Formatelemente die Anzahl der Argumente in der Objektliste überschreitet. Dies tritt auf, da keine explizite Konvertierung zwischen Arraytypen vorhanden ist. Stattdessen behandelt der Compiler das Array als einzelnes Argument statt als Parameterarray. Der folgende Aufruf der Console.WriteLine(String, Object[]) Methode löst beispielsweise eine FormatException Ausnahme aus, obwohl der höchste Index der Formatelemente 3 ist, und das Parameterarray des Typs Int32 verfügt über vier Elemente.

    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 die Ursache beseitigen. Da weder Visual Basic noch C# ein ganzzahliges Array in ein Objektarray konvertieren können, müssen Sie die Konvertierung selbst ausfü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 abgeleitet und fügt keine eindeutigen Exception 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)

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)

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)

Gilt für

Siehe auch