FormatException Třída

  • Reference

Definice

Obor názvů:
System
Sestavení:
System.Runtime.dll
Sestavení:
mscorlib.dll
Sestavení:
netstandard.dll

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

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
Dědičnost
Object
Exception
FormatException
Dědičnost
Object
Exception
SystemException
FormatException
Odvozené
Atributy
SerializableAttribute ComVisibleAttribute

Poznámky

Výjimku FormatException je možné 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 Parse ParseExact metod některých typů.

    Ve většině případů, zejména pokud je řetězec, který převádíte, vstupuje uživatel nebo čte ze souboru, měli byste použít blok (try/withv jazyce F#) a zpracovat try/catch FormatException výjimku, pokud převod není úspěšný. Můžete také nahradit volání metody převodu voláním nebo TryParseExact metodouTryParse, pokud existuje. FormatException Výjimka, která se ale vyvolá při pokusu o analýzu 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 tak, aby byl "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: 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) a metod musí data a DateTimeOffset.ParseExact(String, String[], IFormatProvider, DateTimeStyles) času přesně odpovídat vzoru určenému jedním nebo více standardními formátovacími řetězci nebo řetězci vlastního formátu , které jsou poskytovány jako argumenty volání metody. Pokud neodpovídá očekávanému vzoru specifické pro jazykovou verzi, FormatException 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í úspěšně parsovat v jiném systému.

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

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

    • Číselné typy, včetně všech znamének, nepodepsaných celých čísel a typů s plovoucí desetinou čárkou. Řetězec, který se má analyzovat, musí obsahovat číslice latinky 0–9. Je možné povolit také 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 se interpretují na základě konvencí formátování konkrétní jazykové verze: aktuální jazykové verze, invariantní jazykové verze nebo zadané jazykové verze. Výsledkem může být selhání číselného řetězce, který je analyzován pomocí konvencí jedné jazykové verze při použití konvencí jiné.

      Další informace o parsování čí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 nerozlišující jazykové verze, nebo ve formátu citlivém na jazykovou verzi definovanou aktuální jazykovou verzí, invariantní jazykovou verzí nebo zadanou jazykovou verzí. Pokud řetězec není ve vhodném formátu nebo pokud nejsou součástí dny, hodin a minut časového intervalu nejsou k dispozici, vyvolá metoda FormatException parsování výjimku. Další informace najdete v dokumentaci k TimeSpan parsovací metodě, která vyvolala výjimku.

  • Typ implementuje IFormattable rozhraní, které podporuje formátovací řetězce, které definují způsob převodu objektu na jeho řetězcovou reprezentaci a používá se 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 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()

    Výsledkem této výjimky je chyba kódování. Pokud chcete 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 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.

    Výjimku FormatException může vyvolat také analýza metod, například DateTime.ParseExact a Guid.ParseExact, které vyžadují, aby řetězec byl analyzován přesně podle vzoru určeného řetězcem formátu. V následujícím příkladu se očekává, že řetězcová reprezentace identifikátoru GUID bude odpovídat vzoru určenému řetězcem standardního formátu "G". Guid Implementace IFormattable struktury však nepodporuje řetězec formátu "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()

    Tato výjimka také vede k chybě kódování. Pokud ho chcete 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 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

  • 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, dat, a proto scalekód vede k výjimce FormatException tempza běhu:.

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

    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íte, 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 tak, aby odkazovat na dat proměnnou, a dekrementujte index každé další položky formátu o jednu.

    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

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

    Při pokusu o zahrnutí složených závorek literálů v řetězci se vyvolá výjimka.

    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 závorek do složeného řetězce formátu spočívá v jejich zahrnutí do seznamu objektů a jejich vložení do výsledného řetězce pomocí položek formátu. Můžete například upravit předchozí složený formátovací řetězec, jak je znázorněno tady.

    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)

    Pokud chcete chybu opravit, ujistěte se, že všechny otevřené a zavírací závorky 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)

  • Zadali jste seznam objektů ve složené metodě formátování jako pole parametrů silného typu a výjimka FormatException 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 parametru typu Int32 má čtyři prvky.

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

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

    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 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 FormatException konstruktorech.

Konstruktory

FormatException()

Inicializuje novou instanci FormatException třídy.
FormatException(SerializationInfo, StreamingContext)

Inicializuje novou instanci třídy FormatException se serializovanými daty.
FormatException(String)

Inicializuje novou instanci třídy se zadanou chybovou FormatException zprávou.
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.

Vlastnosti

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 přiřazenou 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

Equals(Object)

Určí, zda se zadaný objekt rovná aktuálnímu objektu.

(Zděděno od Object)
GetBaseException()

Při přepsání v odvozené třídě vrátí Exception hodnotu, která je hlavní 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)

Při přepsání v odvozené třídě nastaví s SerializationInfo 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ří použádnou kopii aktuálního souboru 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

SerializeObjectState
Zastaralé.

Nastane, když je výjimka serializována k vytvoření objektu stavu výjimky, který obsahuje serializovaná data o výjimce.

(Zděděno od Exception)

Platí pro

Viz také