FormatException FormatException FormatException FormatException Class

Definition

Die Ausnahme, die ausgelöst wird, wenn das Format eines Arguments ungültig ist, oder wenn eine kombinierte Formatierungszeichenfolge nicht wohlgeformt ist.The exception that is thrown when the format of an argument is invalid, or when a composite format string is not well formed.

public ref class FormatException : SystemException
[System.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
public class FormatException : SystemException
type FormatException = class
    inherit SystemException
Public Class FormatException
Inherits SystemException
Vererbung
Abgeleitet
Attribute

Hinweise

Eine FormatException -Ausnahme kann aus einem der folgenden Gründe ausgelöst werden:A FormatException exception can be thrown for one of the following reasons:

  • Beim Abrufen einer Methode, die eine Zeichenfolge in einen anderen Datentyp konvertiert, entspricht die Zeichenfolge nicht dem erforderlichen Muster.In a call to a method that converts a string to some other data type, the string doesn't conform to the required pattern. Dies tritt normalerweise auf, wenn einige Methoden Convert der-Klasse Parse und ParseExact die-Methode und die-Methode einiger Typen aufgerufen werden.This typically occurs when calling some methods of the Convert class and the Parse and ParseExact methods of some types.

    In den meisten Fällen, insbesondere wenn die Zeichenfolge, die Sie konvertieren, von einem Benutzer eingegeben oder aus einer Datei gelesen wird, sollten try/catch Sie einen-Block FormatException verwenden und die Ausnahme behandeln, wenn die Konvertierung nicht erfolgreich ist.In most cases, particularly if the string that you're converting is input by a user or read from a file, you should use a try/catch block and handle the FormatException exception if the conversion is unsuccessful. Sie können den-Befehl auch durch einen TryParse -oder TryParseExact eine-Methode ersetzen, sofern vorhanden.You can also replace the call to the conversion method with a call to a TryParse or TryParseExact method, if one exists. Eine FormatException -Ausnahme, die ausgelöst wird, wenn Sie versuchen, eine vordefinierte oder hart codierte Zeichenfolge zu analysieren, weist jedoch auf einen Programmfehler hin.However, a FormatException exception that is thrown when you're trying to parse a predefined or hard-coded string indicates a program error. In diesem Fall sollten Sie den Fehler korrigieren und die Ausnahme nicht behandeln.In this case, you should correct the error rather than handle the exception.

    Die Konvertierung einer Zeichenfolge in die folgenden Typen im System -Namespace kann eine FormatException -Ausnahme auslösen:The conversion of a string to the following types in the System namespace can throw a FormatException exception:

    • Boolean.Boolean. Die Boolean.Parse(String) - Convert.ToBoolean(String) Methode und die-Methode erfordern, dass die Zeichenfolge in "true", "true", "false" oder "false" konvertiert wird.The Boolean.Parse(String) and Convert.ToBoolean(String) methods require the string to be converted to be "True", "true", "False", or "false". Jeder andere Wert löst eine FormatException -Ausnahme aus.Any other value throws a FormatException exception.

    • DateTime und DateTimeOffset.DateTime and DateTimeOffset. Alle Datums-und Uhrzeit Daten werden basierend auf den Formatierungs Konventionen einer bestimmten Kultur interpretiert: entweder die aktuelle Thread Kultur (oder in einigen Fällen die Kultur der aktuellen Anwendungsdomäne), die invariante Kultur oder eine angegebene Kultur.All date and time data is interpreted based on the formatting conventions of a particular culture: either the current thread culture (or, in some cases, the current application domain culture), the invariant culture, or a specified culture. Wenn Sie die- DateTime.ParseExact(String, String, IFormatProvider, DateTimeStyles) Methode DateTimeOffset.ParseExact(String, String[], IFormatProvider, DateTimeStyles) und die-Methode aufzurufen, müssen Datums-und Uhrzeitangaben auch genau einem Muster entsprechen, das von einer oder mehreren Standardformat Zeichenfolgen oder benutzerdefinierten Format Zeichenfolgen, die als Argumente im Methoden aufzurufen.When you call the DateTime.ParseExact(String, String, IFormatProvider, DateTimeStyles) and DateTimeOffset.ParseExact(String, String[], IFormatProvider, DateTimeStyles) methods, date and time data must also conform exactly to a pattern specified by one or more standard format strings or custom format strings that are provided as arguments in the method call. Wenn Sie keinem erwarteten kulturspezifischen Muster entspricht, wird eine FormatException -Ausnahme ausgelöst.If it doesn't conform to an expected culture-specific pattern, a FormatException exception is thrown. Dies bedeutet, dass Datums-und Uhrzeit Daten, die in einem kulturspezifischen Format auf einem System gespeichert sind, möglicherweise nicht erfolgreich auf einem anderen System analysiert werden.This means that date and time data saved in a culture-specific format on one system might not parse successfully on another system.

      Weitere Informationen zum Überprüfen von Datums-und Uhrzeitangaben finden Sie unter "Auswerten von Datums-und Uhrzeit Zeichenfolgen und der Dokumentation für die Methode, die die Ausnahme ausgelöst hatFor more information about parsing dates and times, see Parsing Date and Time Strings and the documentation for the method that threw the exception.

    • GUIDs.GUIDs. Die Zeichen folgen Darstellung einer GUID muss aus 32 hexadezimalen Ziffern (0-F) bestehen, und Sie muss in einem der fünf Formate vorliegen, die Guid.ToString von der-Methode ausgegeben werden.The string representation of a GUID must consist of 32 hexadecimal digits (0-F), and must be in one of the five formats output by the Guid.ToString method. Weitere Informationen finden Sie unter der Methode Guid.Parse.For more information, see the Guid.Parse method.

    • Numerische Typen, einschließlich aller ganzzahligen Ganzzahlen, ganzzahlige Ganzzahlen und Gleit Komma Typen.Numeric types, including all signed integers, unsigned integers, and floating-point types. Die Zeichenfolge, die analysiert werden soll, muss aus den lateinischen Ziffern 0-9 bestehen.The string to be parsed must consist of the Latin digits 0-9. Möglicherweise sind auch positive oder negative Vorzeichen, Dezimaltrennzeichen, Gruppen Trennzeichen und Währungssymbole zulässig.A positive or negative sign, decimal separator, group separators, and currency symbol may also be permitted. Wenn Sie versuchen, eine Zeichenfolge zu analysieren, die ein anderes Zeichen FormatException enthält, wird immer eine-Ausnahme ausgelöst.Trying to parse a string that contains any other character always throws a FormatException exception.

      Alle numerischen Zeichen folgen werden basierend auf den Formatierungs Konventionen einer bestimmten Kultur interpretiert: entweder die aktuelle Thread Kultur (oder in einigen Fällen die Kultur der aktuellen Anwendungsdomäne), die invariante Kultur oder eine angegebene Kultur.All numeric strings are interpreted based on the formatting conventions of a particular culture: either the current thread culture (or, in some cases, the current application domain culture), the invariant culture, or a specified culture. Demzufolge kann eine numerische Zeichenfolge, die mithilfe der Konventionen einer Kultur analysiert wird, fehlschlagen, wenn die Konventionen einer anderen verwendet werden.As a result, a numeric string that is parsed by using the conventions of one culture might fail when using the conventions of another.

      Weitere Informationen zum Auswerten numerischer Zeichen folgen finden Sie unter "auswerten numerischer Zeichen folgen" und in der Dokumentation für die jeweilige Methode, die die Ausnahme ausgelöst hat.For more information about parsing numeric strings, see Parsing Numeric Strings and the documentation for the specific method that threw the exception.

    • Zeitintervalle.Time intervals. Die zu analysierende Zeichenfolge muss entweder das festgelegte Kultur unabhängige Format oder in einem Kultur abhängigen Format aufweisen, das von der aktuellen Thread Kultur (oder in einigen Fällen der aktuellen Anwendungs Domänen Kultur), der invarianten Kultur oder einer angegebenen Kultur definiert wird.The string to be parsed must be either in fixed culture-insensitive format or in a culture-sensitive format defined by the current thread culture (or, in some cases, the current application domain culture), the invariant culture, or a specified culture. Wenn die Zeichenfolge nicht in einem geeigneten Format vorliegt oder wenn die Komponenten der Tage, Stunden und Minuten des Zeitintervalls nicht vorhanden sind, löst die-Methode eine FormatException -Ausnahme aus.If the string isn't in an appropriate format, or if, at the minimum, the days, hours, and minutes components of the time interval aren't present, the parsing method throws a FormatException exception. Weitere Informationen finden Sie in der Dokumentation für die TimeSpan -Methode, die die Ausnahme ausgelöst hat.For more information, see the documentation for the TimeSpan parsing method that threw the exception.

  • Ein Typ implementiert die IFormattable -Schnittstelle, die Format Zeichenfolgen unterstützt, die definieren, wie ein Objekt in seine Zeichen folgen Darstellung konvertiert wird, und eine ungültige Format Zeichenfolge wird verwendetA type implements the IFormattable interface, which supports format strings that define how an object is converted to its string representation, and an invalid format string is used. Dies wird am häufigsten bei einem Formatierungs Vorgang durchläuft.This is most common in a formatting operation. Im folgenden Beispiel wird die Standardformat Zeichenfolge "Q" in einer zusammengesetzten Format Zeichenfolge verwendet, um eine Zahl zu formatieren.In the following example, the "Q" standard format string is used in a composite format string to format a number. "Q" ist jedoch keine gültige Standardformat Zeichenfolge.However, "Q" is not a valid standard format string.

    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()
    
    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 resultiert aus einem Codierungsfehler.This exception results from a coding error. Um den Fehler zu beheben, entfernen Sie entweder die Format Zeichenfolge, oder ersetzen Sie einen gültigen.To correct the error, either remove the format string or substitute a valid one. Im folgenden Beispiel wird der Fehler korrigiert, indem die ungültige Format Zeichenfolge durch die Format Zeichenfolge "C" (Currency) ersetzt wird.The following example corrects the error by replacing the invalid format string with the "C" (currency) format string.

    using System;
    
    public class Example
    {
       public static void Main()
       {
          decimal price = 169.32m;
          Console.WriteLine("The cost is {0:C2}.", price);
       }
    }
    // The example displays the following output:
    //    The cost is $169.32.
    
    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 DateTime.ParseExact das Analysieren von Methoden ausgelöst werden, z Guid.ParseExact. b. und, bei denen die Zeichenfolge analysiert werden muss, damit Sie exakt dem durch eine Format Zeichenfolge angegebenen Muster entspricht.A FormatException exception can also be thrown by parsing methods, such as DateTime.ParseExact and Guid.ParseExact, that require the string to be parsed to conform exactly to the pattern specified by a format string. Im folgenden Beispiel wird erwartet, dass die Zeichen folgen Darstellung einer GUID dem Muster entspricht, das von der Standardformat Zeichenfolge "G" angegeben wird.In the following example, the string representation of a GUID is expected to conform to the pattern specified by the "G" standard format string. Die -IFormattable Implementierung der- StrukturunterstütztjedochnichtdieFormatZeichenfolgeGuid "G".However, the Guid structure's implementation of IFormattable does not support the "G" format string.

    using System;
    
    public class Example
    {
       public static void Main()
       {
          string guidString = "ba748d5c-ae5f-4cca-84e5-1ac5291c38cb";
          Console.WriteLine(Guid.ParseExact(guidString, "G"));
       }
    }
    // The example displays the following output:
    //    Unhandled Exception: System.FormatException: 
    //       Format String can be only "D", "d", "N", "n", "P", "p", "B", "b", "X" or "x".
    //       at System.Guid.ParseExact(String input, String format)
    //       at Example.Main()
    
    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.This exception also results from a coding error. Um dies zu korrigieren, geben Sie eine-Methode für die-Methode an, die kein DateTime.Parse genaues Guid.ParseFormat erfordert, wie z. b. oder.To correct it, call a parsing method that doesn't require a precise format, such as DateTime.Parse or Guid.Parse, or substitute a valid format string. Im folgenden Beispiel wird der Fehler korrigiert, indem Guid.Parse die-Methode aufgerufen wird.The following example corrects the error by calling the Guid.Parse method.

    using System;
    
    public class Example
    {
       public static void Main()
       {
          string guidString = "ba748d5c-ae5f-4cca-84e5-1ac5291c38cb";
          Console.WriteLine(Guid.Parse(guidString));
       }
    }
    // The example displays the following output:
    //    ba748d5c-ae5f-4cca-84e5-1ac5291c38cb
    
    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 ein Index der Format Elemente in einer zusammen gesetzten Format Zeichenfolge ist größer als die Indizes der Elemente in der Objektliste oder im Parameter Array.One or more of the indexes of the format items in a composite format string is greater than the indexes of the items in the object list or parameter array. Im folgenden Beispiel ist der größte Index eines Format Elements in der Format Zeichenfolge 3.In the following example, the largest index of a format item in the format string is 3. Da die Indizes der Elemente in der Objektliste Null basiert sind, erfordert diese Format Zeichenfolge, dass die Objektliste vier Elemente aufweist.Because the indexes of items in the object list are zero-based, this format string would require the object list to have four items. Stattdessen enthält Sie nur drei dat,, tempund scale, sodass der Code zur Laufzeit zu einer FormatException -Ausnahme führt:.Instead, it has only three, dat, temp, and scale, so the code results in a FormatException exception at run time:.

    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()
    
    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 Entwickler Fehlers.In this case, the FormatException exception is a result of developer error. Er sollte korrigiert und nicht in einem try/catch -Block behandelt werden, indem sichergestellt wird, dass jedes Element in der Objektliste dem Index eines Format Elements entspricht.It should be corrected rather than handled in a try/catch block by making sure that each item in the object list corresponds to the index of a format item. Um dieses Beispiel zu korrigieren, ändern Sie den Index des zweiten Format Elements, um auf dat die Variable zu verweisen, und verringern Sie den Index der einzelnen nachfolgenden Formatierungs Elemente um 1.To correct this example, change the index of the second format item to refer to the dat variable, and decrement the index of each subsequent format item by one.

    using System;
    
    public class Example
    {
       public enum TemperatureScale 
       { Celsius, Fahrenheit, Kelvin }
    
       public static void Main()
       {
          String info = GetCurrentTemperature();
          Console.WriteLine(info);
       }
    
       private static String GetCurrentTemperature()
       {
          DateTime dat = DateTime.Now;
          Decimal temp = 20.6m;
          TemperatureScale scale = TemperatureScale.Celsius;
          String result;
          
          result = String.Format("At {0:t} on {0:D}, the temperature is {1:F1} {2:G}",
                                 dat, temp, scale);    
          return result;
       }
    }
    // The example displays output like the following:
    //    At 10:40 AM on Wednesday, June 04, 2014, the temperature is 20.6 Celsius
    
    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 kombinierte Format Zeichenfolge ist nicht wohl geformt.The composite format string isn't well-formed. In diesem Fall ist die FormatException Ausnahme immer das Ergebnis eines Entwickler Fehlers.When this happens, the FormatException exception is always a result of developer error. Er sollte korrigiert und nicht in einem try/catch -Block behandelt werden.It should be corrected rather than handled in a try/catch block.

    Wenn Sie versuchen, Literale geschweifte Klammern in eine Zeichenfolge einzubeziehen, wie im folgenden Beispiel dargestellt, wird die Ausnahme ausgelöst.Trying to include literal braces in a string, as the following example does, will throw the exception.

    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 Vorgehensweise zum Einschließen von literalklammern in einer zusammengesetzten Format Zeichenfolge besteht darin, Sie in die Objektliste einzubeziehen und Format Elemente zu verwenden, um Sie in die Ergebnis Zeichenfolge einzufügen.The recommended technique for including literal braces in a composite format string is to include them in the object list and use format items to insert them into the result string. Beispielsweise können Sie die vorherige kombinierte Format Zeichenfolge ändern, wie hier gezeigt.For example, you can modify the previous composite format string as shown here.

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

    Die Ausnahme wird auch ausgelöst, wenn die Format Zeichenfolge ein Typo enthält.The exception is also thrown if your format string contains a typo. Der folgende String.Format -Befehl gibt eine schließende geschweifte Klammer aus und verbindet eine öffnende geschweifte Klammer mit einer schließenden Klammer.The following call to the String.Format method omits a closing brace and pairs an opening brace with a closing bracket.

    int n1 = 10;
    int n2 = 20;
    String result = String.Format("{0 + {1] = {2}", 
                                  n1, n2, n1 + n2);
    
    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 behebenTo correct the error, ensure that all opening and closing braces correspond.

    String 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 Formatierungs Methode als stark typisiertes Parameter Array bereitgestellt FormatException , und die Ausnahme gibt an, dass der Index von einem oder mehreren Format Elementen die Anzahl der Argumente in der Objektliste überschreitet.You've supplied the object list in a composite formatting method as a strongly typed parameter array, and the FormatException exception indicates that the index of one or more format items exceeds the number of arguments in the object list. Dies liegt daran, dass keine explizite Konvertierung zwischen Array Typen vorhanden ist. Daher behandelt der Compiler das Array nicht als Parameter Array, sondern als einzelnes Argument.This occurs because no explicit conversion between array types exists, so instead the compiler treats the array as a single argument rather than as a parameter array. Beispielsweise löst der folgende Aufrufen der Console.WriteLine(String, Object[]) -Methode eine FormatException -Ausnahme aus, obwohl der höchste Index der Format Elemente 3 ist und das Parameter Array vom Typ Int32 vier Elemente aufweist.For example, the following call to the Console.WriteLine(String, Object[]) method throws a FormatException exception, although the highest index of the format items is 3, and the parameter array of type Int32 has four elements.

    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()
    
    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.Instead of handling this exception, you should eliminate its cause. Da Visual Basic weder noch C# ein ganzzahliges Array in ein Objekt Array konvertiert werden kann, müssen Sie die Konvertierung selbst durchführen, bevor Sie die Methode für die kombinierte Formatierung aufrufen.Because neither Visual Basic nor C# can convert an integer array to an object array, you have to perform the conversion yourself before calling the composite formatting method. Im folgenden Beispiel wird eine-Implementierung bereitstellt.The following example provides one implementation.

    using System;
    using System.Collections.Generic;
    
    public class Example
    {
       public static void Main()
       {
          Random rnd = new Random();
          int[]  numbers = new int[4];
          int total = 0;
          for (int ctr = 0; ctr <= 2; ctr++) {
             int number = rnd.Next(1001);
             numbers[ctr] = number;
             total += number;
          }   
          numbers[3] = total;
          object[] values = new object[numbers.Length];
          numbers.CopyTo(values, 0);
          Console.WriteLine("{0} + {1} + {2} = {3}", values);   
       }
    }
    // The example displays output like the following:
    //        477 + 956 + 901 = 2334
    
    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
    

FormatExceptionverwendet das HRESULT-COR_E_FORMAT, das den Wert 0x80131537 aufweist.FormatException uses the HRESULT COR_E_FORMAT, which has the value 0x80131537.

Die FormatException -Klasse wird Exception von abgeleitet und fügt keine eindeutigen Member hinzu.The FormatException class derives from Exception and adds no unique members. Eine Liste der anfänglichen Eigenschaftswerte für eine Instanz von FormatException, finden Sie unter den FormatException Konstruktoren.For a list of initial property values for an instance of FormatException, see the FormatException constructors.

Konstruktoren

FormatException() FormatException() FormatException() FormatException()

Initialisiert eine neue Instanz der FormatException-Klasse.Initializes a new instance of the FormatException class.

FormatException(SerializationInfo, StreamingContext) FormatException(SerializationInfo, StreamingContext) FormatException(SerializationInfo, StreamingContext) FormatException(SerializationInfo, StreamingContext)

Initialisiert eine neue Instanz der FormatException-Klasse mit serialisierten Daten.Initializes a new instance of the FormatException class with serialized data.

FormatException(String) FormatException(String) FormatException(String) FormatException(String)

Initialisiert eine neue Instanz der FormatException-Klasse mit einer angegebenen Fehlermeldung.Initializes a new instance of the FormatException class with a specified error message.

FormatException(String, Exception) FormatException(String, Exception) FormatException(String, Exception) 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.Initializes a new instance of the FormatException class with a specified error message and a reference to the inner exception that is the cause of this exception.

Eigenschaften

Data Data Data Data

Ruft eine Auflistung von Schlüssel-Wert-Paaren ab, die zusätzliche benutzerdefinierte Informationen über die Ausnahme bereitstellen.Gets a collection of key/value pairs that provide additional user-defined information about the exception.

(Inherited from Exception)
HelpLink HelpLink HelpLink HelpLink

Ruft einen Link zur Hilfedatei ab, die dieser Ausnahme zugeordnet ist, oder legt einen Link fest.Gets or sets a link to the help file associated with this exception.

(Inherited from Exception)
HResult HResult HResult HResult

Ruft HRESULT ab oder legt HRESULT fest. Dies ist ein codierter Wert, der einer bestimmten Ausnahme zugeordnet ist.Gets or sets HRESULT, a coded numerical value that is assigned to a specific exception.

(Inherited from Exception)
InnerException InnerException InnerException InnerException

Ruft die Exception-Instanz ab, die die aktuelle Ausnahme verursacht hat.Gets the Exception instance that caused the current exception.

(Inherited from Exception)
Message Message Message Message

Ruft eine Meldung ab, die die aktuelle Ausnahme beschreibt.Gets a message that describes the current exception.

(Inherited from Exception)
Source Source Source Source

Gibt den Namen der Anwendung oder des Objekts zurück, die bzw. das den Fehler verursacht hat, oder legt diesen fest.Gets or sets the name of the application or the object that causes the error.

(Inherited from Exception)
StackTrace StackTrace StackTrace StackTrace

Ruft eine Zeichenfolgendarstellung der unmittelbaren Frames in der Aufrufliste ab.Gets a string representation of the immediate frames on the call stack.

(Inherited from Exception)
TargetSite TargetSite TargetSite TargetSite

Ruft die Methode ab, die die aktuelle Ausnahme auslöst.Gets the method that throws the current exception.

(Inherited from Exception)

Methoden

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Bestimmt, ob das angegebene Objekt mit dem aktuellen Objekt identisch ist.Determines whether the specified object is equal to the current object.

(Inherited from Object)
GetBaseException() GetBaseException() GetBaseException() GetBaseException()

Gibt beim Überschreiben in einer abgeleiteten Klasse eine Exception zurück, die die ursprüngliche Ursache für eine oder mehrere nachfolgende Ausnahmen ist.When overridden in a derived class, returns the Exception that is the root cause of one or more subsequent exceptions.

(Inherited from Exception)
GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Fungiert als Standardhashfunktion.Serves as the default hash function.

(Inherited from Object)
GetObjectData(SerializationInfo, StreamingContext) GetObjectData(SerializationInfo, StreamingContext) GetObjectData(SerializationInfo, StreamingContext) GetObjectData(SerializationInfo, StreamingContext)

Legt beim Überschreiben in einer abgeleiteten Klasse die SerializationInfo mit Informationen über die Ausnahme fest.When overridden in a derived class, sets the SerializationInfo with information about the exception.

(Inherited from Exception)
GetType() GetType() GetType() GetType()

Ruft den Laufzeittyp der aktuellen Instanz ab.Gets the runtime type of the current instance.

(Inherited from Exception)
MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Erstellt eine flache Kopie des aktuellen Object.Creates a shallow copy of the current Object.

(Inherited from Object)
ToString() ToString() ToString() ToString()

Erstellt eine Zeichenfolgendarstellung der aktuellen Ausnahme und gibt diese zurück.Creates and returns a string representation of the current exception.

(Inherited from Exception)

Ereignisse

SerializeObjectState SerializeObjectState SerializeObjectState SerializeObjectState

Tritt auf, wenn eine Ausnahme serialisiert wird, um ein Ausnahmezustandsobjekt mit serialisierten Daten über die Ausnahme zu erstellen.Occurs when an exception is serialized to create an exception state object that contains serialized data about the exception.

(Inherited from Exception)

Gilt für:

Siehe auch