FormatException Klasse
Definition
Wichtig
Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.
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
- Vererbung
- 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 eineTryParse
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
,temp
undscale
, 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 diedat
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) |