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:

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

Gilt für:

Weitere Informationen