FormatException FormatException FormatException FormatException Class

Definice

Výjimka, která je vyvolána, když je formát argumentu neplatný nebo když je složený řetězec formátu ve správném tvaru.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
Dědičnost
Odvozené
Atributy

Poznámky

FormatException Výjimka může být vyvolána z jednoho z následujících důvodů:A FormatException exception can be thrown for one of the following reasons:

  • V volání metody, která převede řetězec na jiný datový typ, řetězec neodpovídá požadovanému vzoru.In a call to a method that converts a string to some other data type, the string doesn't conform to the required pattern. K tomu obvykle dochází při volání některých metod Convert třídy a metod a Parse ParseExact v některých typech.This typically occurs when calling some methods of the Convert class and the Parse and ParseExact methods of some types.

    Ve většině případů, zejména pokud řetězec, který převádíte, je vstupem uživatelem nebo načten ze souboru, měli byste použít try/catch blok a FormatException zpracovat výjimku, pokud je převod neúspěšný.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. Můžete také nahradit volání metody převodu voláním TryParse metody nebo TryParseExact , pokud jedna existuje.You can also replace the call to the conversion method with a call to a TryParse or TryParseExact method, if one exists. FormatException Výjimka, která je vyvolána při pokusu o analýzu předdefinovaného nebo pevně zakódovaného řetězce, však indikuje chybu programu.However, a FormatException exception that is thrown when you're trying to parse a predefined or hard-coded string indicates a program error. V takovém případě byste měli opravit chybu namísto zpracování výjimky.In this case, you should correct the error rather than handle the exception.

    Převod řetězce na následující typy v System oboru názvů může FormatException vyvolat výjimku:The conversion of a string to the following types in the System namespace can throw a FormatException exception:

    • Boolean.Boolean. Metody Boolean.Parse(String) aConvert.ToBoolean(String) vyžadují, aby byl řetězec převeden tak, aby byl "true", "true", "false" nebo "false".The Boolean.Parse(String) and Convert.ToBoolean(String) methods require the string to be converted to be "True", "true", "False", or "false". Jakákoli jiná hodnota vyvolá FormatException výjimku.Any other value throws a FormatException exception.

    • DateTimea DateTimeOffset.DateTime and DateTimeOffset. Všechna data data a času jsou interpretována v závislosti na konvencích formátování konkrétní jazykové verze: buď aktuální jazyková verze vlákna (nebo, v některých případech aktuální jazyková verze domény aplikace), invariantní jazyková verze nebo zadaná jazyková verze.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. Při volání DateTime.ParseExact(String, String, IFormatProvider, DateTimeStyles) DateTimeOffset.ParseExact(String, String[], IFormatProvider, DateTimeStyles) metod a musí data data a času odpovídat přesně vzoru určenému jedním nebo několika standardním formátovacím řetězcem nebo řetězci vlastního formátu , které jsou zadány jako argumenty v volání metody.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. Pokud se neshoduje s očekávaným vzorkem specifickým pro FormatException jazykovou verzi, je vyvolána výjimka.If it doesn't conform to an expected culture-specific pattern, a FormatException exception is thrown. To znamená, že data data a času uložená ve formátu specifického pro jazykovou verzi v jednom systému se nemusí v jiném systému úspěšně analyzovat.This means that date and time data saved in a culture-specific format on one system might not parse successfully on another system.

      Další informace o analýze dat a časů naleznete v tématu Analýza řetězců data a času a dokumentace k metodě, která výjimku vyvolala.For 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. Řetězcová reprezentace identifikátoru GUID musí být tvořena 32 šestnáctkovými číslicemi (0-F) a musí být v jednom z pěti výstupů Guid.ToString formátu metodou.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. Další informace naleznete Guid.Parse v metodě.For more information, see the Guid.Parse method.

    • Číselné typy, včetně všech podepsaných celých čísel, celých čísel bez znaménka a typů s plovoucí desetinnou čárkou.Numeric types, including all signed integers, unsigned integers, and floating-point types. Řetězec, který se má analyzovat, musí obsahovat číslice latinky 0-9.The string to be parsed must consist of the Latin digits 0-9. Mohou být povoleny také kladné nebo záporné znaménko, oddělovač desetinných míst, oddělovače skupin a symbol měny.A positive or negative sign, decimal separator, group separators, and currency symbol may also be permitted. Pokus o analýzu řetězce, který obsahuje jakýkoliv jiný znak, vždy vyvolá FormatException výjimku.Trying to parse a string that contains any other character always throws a FormatException exception.

      Všechny číselné řetězce jsou interpretovány na základě konvencí formátování konkrétní jazykové verze: buď aktuální jazyková verze vlákna (nebo, v některých případech aktuální jazyková verze domény aplikace), invariantní jazyková verze nebo zadaná jazyková verze.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. Výsledkem je, že číselný řetězec, který je analyzován pomocí konvence jedné jazykové verze, může selhat při použití konvencí jiné.As a result, a numeric string that is parsed by using the conventions of one culture might fail when using the conventions of another.

      Další informace o analýze číselných řetězců naleznete v tématu Analýza číselných řetězců a dokumentace pro konkrétní metodu, která výjimku vyvolala.For more information about parsing numeric strings, see Parsing Numeric Strings and the documentation for the specific method that threw the exception.

    • Časové intervaly.Time intervals. Řetězec, který má být analyzován, musí být buď ve formátu nezávisle na jazykové verzi, nebo v formátu nezávislém na jazykové verzi definovaném aktuální jazykovou verzí vlákna (nebo v některých případech aktuální jazyková verze domény aplikace), invariantní jazyková verze nebo zadaná jazyková verze.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. Pokud řetězec není v příslušném formátu, nebo pokud v časovém intervalu nejsou přítomny komponenty pro dny, hodiny a minuty, metoda analýzy vyvolá FormatException výjimku.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. Další informace naleznete v dokumentaci k TimeSpan metodě analýzy, která výjimku vyvolala.For more information, see the documentation for the TimeSpan parsing method that threw the exception.

  • Typ implementuje IFormattable rozhraní, které podporuje řetězce formátu, které definují, jak je objekt převeden na jeho řetězcovou reprezentaci a je použit neplatný řetězec formátu.A 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. Toto je nejběžnější v operaci formátování.This is most common in a formatting operation. V následujícím příkladu je řetězec standardního formátu "Q" použit ve složeném formátovacím řetězci k formátování čísla.In the following example, the "Q" standard format string is used in a composite format string to format a number. "Q" však není platný standardní řetězec formátu.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()
    

    Tato výjimka je výsledkem chyby kódování.This exception results from a coding error. Chcete-li chybu opravit, buď odeberte formátovací řetězec, nebo nahraďte jeho platnou.To correct the error, either remove the format string or substitute a valid one. Následující příklad opravuje chybu nahrazením neplatného formátovacího řetězce řetězcem formátu "C" (měna).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.
    

    Výjimka může být také vyvolána analýzou metod, jako jsou DateTime.ParseExact a Guid.ParseExact, které vyžadují, aby byl řetězec analyzován tak, aby odpovídal přesně vzoru určenému formátovacím řetězcem. FormatExceptionA 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. V následujícím příkladu se očekává, že řetězcová reprezentace identifikátoru GUID odpovídá vzoru určenému pomocí standardního formátovacího řetězce "G".In the following example, the string representation of a GUID is expected to conform to the pattern specified by the "G" standard format string. Nicméně implementace IFormattable struktury pro nepodporuje formátovací řetězec "G". GuidHowever, 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()
    

    Tato výjimka také vede k chybě kódování.This exception also results from a coding error. Chcete-li ji opravit, zavolejte metodu analýzy, která nevyžaduje přesný formát, například DateTime.Parse nebo Guid.Parse, nebo nahraďte platný řetězec formátu.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. Následující příklad opravuje chybu voláním Guid.Parse metody.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
    
  • Jeden nebo více indexů formátovacích položek ve složeném formátovacím řetězci je větší než indexy položek v seznamu objektů nebo v poli parametrů.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. V následujícím příkladu je největší index položky formátu ve formátovacím řetězci 3.In the following example, the largest index of a format item in the format string is 3. Vzhledem k tomu, že indexy položek v seznamu objektů jsou počítány od nuly, tento řetězec formátu by vyžadoval, aby seznam objektů měl čtyři položky.Because the indexes of items in the object list are zero-based, this format string would require the object list to have four items. Místo toho má pouze tři dat,, temp scalea, takže kód za FormatException běhu vyvolá výjimku za běhu:.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()
    

    V tomto případě FormatException je výjimka výsledkem chyby vývojáře.In this case, the FormatException exception is a result of developer error. Měla by být opravena místo zpracování v try/catch bloku tím, že zajistí, že každá položka v seznamu objektů odpovídá indexu položky formátu.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. Chcete-li tento příklad opravit, změňte index druhé položky formátu tak, aby odkazoval na dat proměnnou, a snížit index každé následné položky formátu o jednu.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
    
  • Složený řetězec formátu nemá správný formát.The composite format string isn't well-formed. Pokud k FormatException tomu dojde, výjimka je vždy výsledkem chyby vývojáře.When this happens, the FormatException exception is always a result of developer error. Měla by být opravena místo zpracování v try/catch bloku.It should be corrected rather than handled in a try/catch block.

    Při pokusu o zahrnutí literálních složených závorek do řetězce, jak je znázorněno v následujícím příkladu, vyvolá výjimku.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)
    

    Doporučený postup pro zahrnutí literálních složených závorek do složeného formátovacího řetězce je zahrnout do seznamu objektů a použít položky formátu k jejich vložení do výsledného řetězce.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. Můžete například upravit předchozí složený řetězec formátu, jak je znázorněno zde.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)
    

    Výjimka je vyvolána také v případě, že formátovací řetězec obsahuje překlep.The exception is also thrown if your format string contains a typo. Následující volání String.Format metody vynechá pravou složenou závorku a spáruje levou složenou závorku s pravou závorkou.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)
    

    Chcete-li chybu opravit, zajistěte, aby odpovídaly všechny počáteční a pravé složené závorky.To 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)
    
  • Zadali jste seznam objektů v metodě složeného formátování jako pole s parametrem silného typu a FormatException výjimka označuje, že index jedné nebo více položek formátu překračuje počet argumentů v seznamu objektů.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. K tomu dochází, protože neexistuje explicitní převod mezi typy polí, takže Kompilátor považuje pole za jeden argument, nikoli jako pole parametrů.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. Například následující volání Console.WriteLine(String, Object[]) metody FormatException vyvolá výjimku, ale nejvyšší index položek formátu je 3 a pole parametrů typu Int32 má čtyři prvky.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()
    

    Místo zpracování této výjimky byste měli odstranit jeho příčinu.Instead of handling this exception, you should eliminate its cause. Vzhledem k tomu, C# že ani Visual Basic ani nemůže převést celočíselné pole na pole objektu, je nutné provést převod sami před voláním metody složeného formátování.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. Následující příklad poskytuje jednu implementaci.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
    

FormatExceptionpoužívá HRESULT COR_E_FORMAT, který má hodnotu 0x80131537.FormatException uses the HRESULT COR_E_FORMAT, which has the value 0x80131537.

Třída je odvozena z Exception a nepřidává žádné jedinečné členy. FormatExceptionThe FormatException class derives from Exception and adds no unique members. Seznam počáteční hodnoty vlastností pro instanci FormatException, najdete v článku FormatException konstruktory.For a list of initial property values for an instance of FormatException, see the FormatException constructors.

Konstruktory

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

Inicializuje novou instanci třídy FormatException třídy.Initializes a new instance of the FormatException class.

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

Inicializuje novou instanci třídy FormatException třídy se serializovanými daty.Initializes a new instance of the FormatException class with serialized data.

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

Inicializuje novou instanci třídy FormatException třídy pomocí zadané chybové zprávy.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)

Inicializuje novou instanci třídy FormatException třídy pomocí zadané chybové zprávy a odkazu na vnitřní výjimku, která je příčinou této výjimky.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.

Vlastnosti

Data Data Data Data

Získá kolekci párů klíč/hodnota, které poskytují další uživatelsky definované informace o výjimce.Gets a collection of key/value pairs that provide additional user-defined information about the exception.

(Inherited from Exception)
HelpLink HelpLink HelpLink HelpLink

Získá nebo nastaví odkaz na soubor s nápovědě spojený s touto výjimkou.Gets or sets a link to the help file associated with this exception.

(Inherited from Exception)
HResult HResult HResult HResult

Získá nebo nastaví hodnotu HRESULT, kódované číselné hodnoty, která je přiřazena konkrétní výjimce.Gets or sets HRESULT, a coded numerical value that is assigned to a specific exception.

(Inherited from Exception)
InnerException InnerException InnerException InnerException

Exception Získá instanci, která způsobila aktuální výjimku.Gets the Exception instance that caused the current exception.

(Inherited from Exception)
Message Message Message Message

Získá zprávu s popisem aktuální výjimky.Gets a message that describes the current exception.

(Inherited from Exception)
Source Source Source Source

Získá nebo nastaví název aplikace nebo objektu, který způsobuje chybu.Gets or sets the name of the application or the object that causes the error.

(Inherited from Exception)
StackTrace StackTrace StackTrace StackTrace

Načte řetězcovou reprezentaci okamžitých snímků v zásobníku volání.Gets a string representation of the immediate frames on the call stack.

(Inherited from Exception)
TargetSite TargetSite TargetSite TargetSite

Získá metodu, která vyvolá aktuální výjimku.Gets the method that throws the current exception.

(Inherited from Exception)

Metody

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

Určuje, zda se zadaný objekt rovná aktuálnímu objektu.Determines whether the specified object is equal to the current object.

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

Při přepsání v odvozené třídě vrátí hodnotu Exception , která je hlavní příčinou jedné nebo více následných výjimek.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()

Slouží jako výchozí funkce hash.Serves as the default hash function.

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

Při přepsání v odvozené třídě nastaví na SerializationInfo výjimku informace o výjimce.When overridden in a derived class, sets the SerializationInfo with information about the exception.

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

Získá typ modulu runtime aktuální instance.Gets the runtime type of the current instance.

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

Vytvoří kopii aktuálního Objectseznamu.Creates a shallow copy of the current Object.

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

Vytvoří a vrátí řetězcovou reprezentaci aktuální výjimky.Creates and returns a string representation of the current exception.

(Inherited from Exception)

Události

SerializeObjectState SerializeObjectState SerializeObjectState SerializeObjectState

Nastane, pokud je serializovaná výjimka pro vytvoření objektu stavu výjimky, který obsahuje Serializovaná data o výjimce.Occurs when an exception is serialized to create an exception state object that contains serialized data about the exception.

(Inherited from Exception)

Platí pro

Viz také