FormatException Třída

Definice

Obor názvů:

System

Sestavení:

netstandard.dll, System.Runtime.dll

Zdroj:

FormatException.cs

Výjimka, která se vyvolá, když je formát argumentu neplatný nebo pokud složený formát řetězce není správně vytvořen.

public ref class FormatException : SystemException

public class FormatException : SystemException

type FormatException = class
    inherit SystemException

Public Class FormatException
Inherits SystemException

Dědičnost

Object

Exception

SystemException

FormatException

Odvozené

System.IO.FileFormatException

System.Net.CookieException

System.Reflection.CustomAttributeFormatException

System.UriFormatException

Poznámky

Výjimku FormatException lze vyvolat z jednoho z následujících důvodů:

• Při volání metody, která převede řetězec na jiný datový typ, řetězec neodpovídá požadovanému vzoru. K tomu obvykle dochází při volání některých metod Convert třídy a ParseParseExact metod některých typů.

  Ve většině případů, zejména pokud řetězec, který převádíte, je vstup uživatelem nebo přečtený ze souboru, měli byste použít try/catch blok (try/with v jazyce F#) a zpracovat FormatException výjimku, pokud převod nebude úspěšný. Volání metody převodu můžete také nahradit voláním TryParse metody nebo TryParseExact metody, pokud existuje. Výjimka FormatException , která se však vyvolá při pokusu o parsování předdefinovaného nebo pevně zakódovaného řetězce označuje chybu programu. V takovém případě byste měli chybu opravit místo zpracování výjimky.

  Převod řetězce na následující typy v System oboru názvů může vyvolat FormatException výjimku:

  • Boolean. Tyto Boolean.Parse(String) metody Convert.ToBoolean(String) vyžadují, aby byl řetězec převeden na True, True, True, False nebo False. Jakákoli jiná hodnota vyvolá FormatException výjimku.

  • DateTime a DateTimeOffset. Všechna data data a času se interpretují na základě konvencí formátování konkrétní jazykové verze: buď aktuální jazyková verze (nebo v některých případech aktuální jazyková verze domény aplikace), invariantní jazyková verze nebo zadaná jazyková verze. Při volání DateTime.ParseExact(String, String, IFormatProvider, DateTimeStyles) metod a DateTimeOffset.ParseExact(String, String[], IFormatProvider, DateTimeStyles) metod musí data data a času také přesně odpovídat vzoru určenému jedním nebo více standardními formátovacími řetězci nebo vlastními formátovacími řetězci, které jsou zadány jako argumenty volání metody. Pokud neodpovídá očekávanému FormatException vzoru specifickému pro jazykovou verzi, vyvolá se výjimka. To znamená, že data data a času uložená ve formátu specifickém pro jazykovou verzi v jednom systému nemusí být úspěšně analyzována v jiném systému.

    Další informace o analýze kalendářních dat a časů naleznete v tématu Analýza řetězců data a času a dokumentace pro metodu, která vyvolala výjimku.

  • GUIDy. Řetězcové vyjádření identifikátoru GUID musí obsahovat 32 šestnáctkových číslic (0 až F) a musí být v jednom z pěti formátů výstupu metodou Guid.ToString . Další informace najdete v metodě Guid.Parse.

  • Číselné typy, včetně všech znamének, celých čísel bez znaménka a typů s plovoucí desetinou čárkou. Řetězec, který se má analyzovat, musí obsahovat číslice latinky 0–9. Je také možné povolit kladné nebo záporné znaménko, oddělovač desetinných míst, oddělovače skupin a symbol měny. Při pokusu o analýzu řetězce, který obsahuje jakýkoli jiný znak, vždy vyvolá FormatException výjimku.

    Všechny číselné řetězce jsou interpretovány na základě konvencí formátování konkrétní jazykové verze: buď aktuální jazyková verze, invariantní jazyková verze nebo zadaná jazyková verze. V důsledku toho může číselný řetězec, který je analyzován pomocí konvencí jedné jazykové verze, selhat při použití konvencí jiné.

    Další informace o analýze číselných řetězců najdete v tématu Analýza číselných řetězců a dokumentace pro konkrétní metodu, která vyvolala výjimku.

  • Časové intervaly. Řetězec, který se má analyzovat, musí být buď v pevném formátu bez rozlišení jazykové verze, nebo ve formátu citlivém na jazykovou verzi definovaném aktuální jazykovou verzí, neutrální jazykovou verzí nebo zadanou jazykovou verzí. Pokud řetězec není ve vhodném formátu nebo pokud nejsou k dispozici komponenty dnů, hodin a minut časového intervalu, parsovací metoda vyvolá FormatException výjimku. Další informace najdete v dokumentaci k TimeSpan metodě analýzy, která vyvolala výjimku.

• Typ implementuje IFormattable rozhraní, které podporuje formátovací řetězce, které definují, jak je objekt převeden na řetězcové vyjádření a je použit neplatný formátovací řetězec. To je nejběžnější v operaci formátování. V následujícím příkladu se řetězec standardního formátu "Q" používá ve složeného řetězci formátu k formátování čísla. "Q" ale není platný standardní formátovací řetězec.

  using System;
  
  public class FormatExample8
  {
     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()
  

  Výsledkem této výjimky je chyba kódování. Chcete-li chybu opravit, odeberte řetězec formátu nebo nahraďte platný řetězec. Následující příklad chybu opraví nahrazením neplatného řetězce formátu řetězcem "C" (měna).

  using System;
  
  public class FormatExample9
  {
     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.
  

  Výjimku FormatException lze vyvolat také analýzou metod, například DateTime.ParseExact a Guid.ParseExact, které vyžadují, aby řetězec byl analyzován přesně podle vzoru určeného formátovacím řetězcem. V následujícím příkladu se očekává, že řetězcová reprezentace identifikátoru GUID odpovídá vzoru určenému standardním formátovacím řetězcem "G". Implementace Guid struktury IFormattable však nepodporuje řetězec formátu "G".

  using System;
  
  public class IFormattableExample3
  {
     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()
  

  Tato výjimka také vede k chybě kódování. Chcete-li ji opravit, zavolejte metodu analýzy, která nevyžaduje přesný formát, například DateTime.Parse nebo Guid.Parsenebo nahraďte platný řetězec formátu. Následující příklad chybu opraví voláním Guid.Parse metody.

  using System;
  
  public class FormatExample11
  {
     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
  

• Jeden nebo více indexů položek formátu v řetězci složeného formátu je větší než indexy položek v seznamu objektů nebo pole parametrů. V následujícím příkladu je největší index položky formátu v řetězci formátu 3. Vzhledem k tomu, že indexy položek v seznamu objektů jsou založené na nule, tento formátovací řetězec by vyžadoval, aby seznam objektů měl čtyři položky. Místo toho má pouze tři , dattempa , a scale, takže kód vede k výjimce FormatException za běhu:.

  using System;
  
  public class Example1
  {
     public enum TemperatureScale
     { Celsius, Fahrenheit, Kelvin }
  
     public static void Run()
     {
        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()
  

  V tomto případě FormatException je výjimka výsledkem chyby vývojáře. Měla by být opravena místo zpracování v try/catch bloku tím, že zajistí, aby každá položka v seznamu objektů odpovídala indexu položky formátu. Chcete-li tento příklad opravit, změňte index druhé položky formátu odkazující na dat proměnnou a dekrementujte index každé další položky formátu o jednu.

  using System;
  
  public class FormatExample2
  {
     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
  

• Složený formátovací řetězec není ve správném formátu. V takovém případě FormatException je výjimka vždy výsledkem chyby vývojáře. Měla by být opravena místo zpracování v try/catch bloku.

  Při pokusu o zahrnutí literálových složených závorek do řetězce, jak je znázorněno v následujícím příkladu, vyvolá výjimku.

  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)
  

  Doporučená technika zahrnutí literálových složených závorek do řetězce složeného formátu je zahrnout do seznamu objektů a pomocí položek formátu je vložit do výsledného řetězce. Můžete například upravit předchozí složený formátovací řetězec, jak je znázorněno zde.

  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)
  

  Výjimka se vyvolá také v případě, že váš formátovací řetězec obsahuje překlep. Následující volání String.Format metody vynechá pravou závorku a spáruje levou závorku s pravou závorkou.

  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)
  

  Chcete-li chybu opravit, ujistěte se, že všechny levá a pravá složená závorka odpovídají.

  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)
  

• Seznam objektů jste zadali ve složené metodě formátování jako pole parametrů 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ů. K tomu dochází, protože neexistuje žádný explicitní převod mezi typy polí, takže kompilátor považuje pole za jediný argument, nikoli jako pole parametrů. Například následující volání Console.WriteLine(String, Object[]) metody vyvolá FormatException výjimku, ačkoli nejvyšší index položek formátu je 3 a pole parametrů typu Int32 má čtyři prvky.

  using System;
  using System.Collections.Generic;
  
  public class QAExample1
  {
     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()
  

  Místo zpracování této výjimky byste měli odstranit její příčinu. Vzhledem k tomu, že Visual Basic ani jazyk C# nemůže převést celočíselné pole na pole objektů, je nutné provést převod sami před voláním složené metody formátování. Následující příklad obsahuje jednu implementaci.

  using System;
  using System.Collections.Generic;
  
  public class QAExample2
  {
     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 používá COR_E_FORMAT HRESULT, který má hodnotu 0x80131537.

Třída FormatException je odvozena od Exception a přidává žádné jedinečné členy. Seznam počátečních hodnot vlastností pro instanci FormatExceptionnaleznete v konstruktoru FormatException.

Konstruktory

Name	Description
FormatException()	Inicializuje novou instanci FormatException třídy.
FormatException(SerializationInfo, StreamingContext)	Zastaralé. Inicializuje novou instanci FormatException třídy serializovanými daty.
FormatException(String, Exception)	Inicializuje novou instanci FormatException třídy se zadanou chybovou zprávou a odkazem na vnitřní výjimku, která je příčinou této výjimky.
FormatException(String)	Inicializuje novou instanci FormatException třídy se zadanou chybovou zprávou.

Vlastnosti

Name	Description
Data	Získá kolekci párů klíč/hodnota, které poskytují další uživatelem definované informace o výjimce. (Zděděno od Exception)
HelpLink	Získá nebo nastaví odkaz na soubor nápovědy přidružený k této výjimce. (Zděděno od Exception)
HResult	Získá nebo nastaví HRESULT, kódovanou číselnou hodnotu, která je přiřazena ke konkrétní výjimce. (Zděděno od Exception)
InnerException	Exception Získá instanci, která způsobila aktuální výjimku. (Zděděno od Exception)
Message	Získá zprávu, která popisuje aktuální výjimku. (Zděděno od Exception)
Source	Získá nebo nastaví název aplikace nebo objektu, který způsobuje chybu. (Zděděno od Exception)
StackTrace	Získá řetězcové znázornění okamžitých rámců v zásobníku volání. (Zděděno od Exception)
TargetSite	Získá metodu, která vyvolá aktuální výjimku. (Zděděno od Exception)

Metody

Name	Description
Equals(Object)	Určuje, zda je zadaný objekt roven aktuálnímu objektu. (Zděděno od Object)
GetBaseException()	Při přepsání v odvozené třídě vrátí Exception to, že je původní příčinou jedné nebo více následných výjimek. (Zděděno od Exception)
GetHashCode()	Slouží jako výchozí funkce hash. (Zděděno od Object)
GetObjectData(SerializationInfo, StreamingContext)	Zastaralé. Při přepsání v odvozené třídě nastaví SerializationInfo s informacemi o výjimce. (Zděděno od Exception)
GetType()	Získá typ modulu runtime aktuální instance. (Zděděno od Exception)
MemberwiseClone()	Vytvoří mělkou kopii aktuálního Object. (Zděděno od Object)
ToString()	Vytvoří a vrátí řetězcovou reprezentaci aktuální výjimky. (Zděděno od Exception)

Událost

Name	Description
SerializeObjectState	Zastaralé. Nastane, když je výjimka serializována vytvořit objekt stavu výjimky, který obsahuje serializovaná data o výjimce. (Zděděno od Exception)

Viz také

• Exception
• Zpracování a vyvolání výjimek