FormatException Osztály

Definíció

Névtér:

System

Szerelvények:

netstandard.dll, System.Runtime.dll

Forrás:

FormatException.cs

A kivétel, amely akkor keletkezik, ha egy argumentum formátuma érvénytelen, vagy ha egy összetett formázási sztring nem megfelelően van formázva.

public ref class FormatException : SystemException

public class FormatException : SystemException

type FormatException = class
    inherit SystemException

Public Class FormatException
Inherits SystemException

Öröklődés

Object

Exception

SystemException

FormatException

Származtatott

System.IO.FileFormatException

System.Net.CookieException

System.Reflection.CustomAttributeFormatException

System.UriFormatException

Megjegyzések

A FormatException következő okok valamelyike miatt lehet kivételt kivenni:

• A sztringet más adattípussá konvertáló metódus hívása esetén a sztring nem felel meg a szükséges mintának. Ez általában akkor fordul elő, ha meghívja az Convert osztály egyes metódusait, valamint bizonyos Parse típusú metódusokat és ParseExact metódusokat.

  A legtöbb esetben, különösen ha a konvertálni kívánt sztringet egy felhasználó adja meg, vagy egy fájlból olvas be, használjon (try/catchtry/withF#-ban) blokkot, és kezelje a FormatException kivételt, ha az átalakítás sikertelen. A konvertálási metódus hívását is lecserélheti egy hívásra vagy TryParse metódusraTryParseExact, ha van ilyen. FormatException Egy előre definiált vagy rögzített sztring elemzésekor megjelenő kivétel azonban programhibát jelez. Ebben az esetben a kivétel kezelése helyett ki kell javítania a hibát.

  A névtérben System lévő sztringek a következő típusokra való konvertálása kivételt FormatException okozhat:

  • Boolean. A Boolean.Parse(String) metódusokhoz a Convert.ToBoolean(String) sztringet "Igaz", "igaz", "Hamis" vagy "hamis" értékre kell konvertálni. Bármely más érték kivételt FormatException eredményez.

  • DateTime és DateTimeOffset. A rendszer minden dátum- és időadatot egy adott kultúra formázási konvenciók alapján értelmez: vagy az aktuális kultúrát (vagy bizonyos esetekben az aktuális alkalmazástartomány-kultúrát), az invariáns kultúrát vagy egy meghatározott kultúrát. A metódusok és DateTime.ParseExact(String, String, IFormatProvider, DateTimeStyles) metódusok meghívásakor a DateTimeOffset.ParseExact(String, String[], IFormatProvider, DateTimeStyles) dátum- és időadatoknak pontosan meg kell felelniük a metódushívásban argumentumként megadott egy vagy több szabványos formátumsztring vagy egyéni formátumsztring által megadott mintának is. Ha nem felel meg a várt kultúraspecifikus mintának, FormatException kivételt jelent. Ez azt jelenti, hogy az egyik rendszeren kultúraspecifikus formátumban mentett dátum- és időadatok nem feltétlenül elemeznek sikeresen egy másik rendszeren.

    A dátumok és időpontok elemzésével kapcsolatos további információkért lásd a dátum- és idősztringek elemzését , valamint a kivételt okozó metódus dokumentációját.

  • Guid. A GUID sztring-ábrázolásának 32 hexadecimális számjegyből (0-F) kell állnia, és a metódus által Guid.ToString megadott öt formátum egyikében kell lennie. További információkért tekintse meg a metódust Guid.Parse .

  • Numerikus típusok, beleértve az összes aláírt egész számot, az aláíratlan egész számokat és a lebegőpontos típusokat. Az elemezni kívánt sztringnek a 0-9 latin számjegyekből kell állnia. Pozitív vagy negatív jel, tizedesjel, csoportelválasztó és pénznemszimbólum is engedélyezhető. Ha bármilyen más karaktert tartalmazó sztringet próbál elemezni, az mindig kivételt FormatException eredményez.

    Az összes numerikus sztring egy adott kultúra formázási konvenciói alapján van értelmezve: az aktuális kultúra, az invariáns kultúra vagy egy adott kultúra alapján. Ennek eredményeképpen egy olyan numerikus sztring, amelyet az egyik kultúra konvencióinak használatával elemeznek, meghiúsulhat egy másik konvenciók használatakor.

    A numerikus sztringek elemzéséről további információt a numerikus sztringek elemzése és a kivételt okozó adott metódus dokumentációja tartalmaz.

  • Időintervallumok. Az elemezni kívánt sztringnek rögzített kulturális érzéketlen formátumban, vagy az aktuális kultúra, az invariáns kultúra vagy egy meghatározott kultúra által meghatározott kultúraérzékeny formátumban kell lennie. Ha a sztring nem megfelelő formátumban van, vagy ha az időintervallum napjai, órái és percei nem jelennek meg, az elemzési módszer kivételt FormatException vet fel. További információkért tekintse meg a TimeSpan kivételt okozó elemzési módszer dokumentációját.

• Egy típus implementálja az interfészt, amely támogatja az IFormattable objektum sztring-ábrázolására való konvertálását meghatározó formázási sztringeket, és érvénytelen formázási sztringet használ. Ez a leggyakrabban használt formázási művelet. Az alábbi példában a "Q" standard formátumú sztring egy összetett formátumú sztringben egy szám formázására szolgál. A "Q" azonban nem érvényes szabványos formátumsztring.

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

  Ez a kivétel kódolási hibából ered. A hiba kijavításához távolítsa el a formátumsztringet, vagy helyettesítsen egy érvényeset. Az alábbi példa úgy javítja ki a hibát, hogy az érvénytelen formátumsztringet a "C" (pénznem) formátumsztringre cseréli.

  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.
  

  Kivételt FormatException olyan elemzési módszerek is okozhatnak, mint például DateTime.ParseExact az és Guid.ParseExact, amelyek megkövetelik, hogy a sztring elemzése pontosan megfeleljen a formátumsztring által megadott mintának. Az alábbi példában a GUID sztring-ábrázolása várhatóan megfelel a "G" standard formátumú sztring által megadott mintának. A Guid struktúra implementációja IFormattable azonban nem támogatja a "G" formátumsztringet.

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

  Ez a kivétel kódolási hibából is ered. A hiba kijavításához hívjon meg egy olyan elemzési módszert, amely nem igényel pontos formátumot, például DateTime.Parse egy érvényes formátumsztringet, vagy Guid.Parsehelyettesítsen be egy érvényes formátumsztringet. Az alábbi példa a metódus meghívásával javítja ki a Guid.Parse hibát.

  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
  

• Az összetett formátumú sztring formázási elemeinek egy vagy több indexe nagyobb, mint az objektumlista vagy a paramétertömb elemeinek indexe. Az alábbi példában a formátumsztring egyik formátumelemének legnagyobb indexe a 3. Mivel az objektumlistában lévő elemek indexei nulla alapúak, ez a formátumsztring négy elemet igényelne az objektumlistához. Ehelyett csak három, dattempés scale, így a kód egy kivételt FormatException eredményez futásidőben:

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

  Ebben az esetben a FormatException kivétel fejlesztői hiba eredménye. A hibát a blokkok kezelése helyett try/catch úgy kell kijavítani, hogy az objektumlistában szereplő minden elem megfelel-e egy formátumelem indexének. A példa kijavításához módosítsa a második formátumelem indexét úgy, hogy a dat változóra hivatkozzon, és az egyes további formázási elemek indexét egyenként csökkentse.

  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
  

• Az összetett formátumú sztring nem megfelelően formázott. Ha ez történik, a FormatException kivétel mindig fejlesztői hiba következménye. Nem blokkban try/catch , hanem javítva kell lennie.

  Ha a sztringben konstans kapcsos zárójeleket próbál felvenni, ahogyan az alábbi példában is látható, a kivétel ki fog következni.

  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)
  

  A konstans kapcsos zárójelek összetett formátumú sztringbe való belefoglalásának ajánlott módszere, ha azokat belefoglalja az objektumlistába, és a formázási elemek használatával beszúrja őket az eredménysztringbe. Módosíthatja például az előző összetett formátumú sztringet az itt látható módon.

  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)
  

  A kivétel akkor is megjelenik, ha a formátumsztring elírást tartalmaz. A metódus következő String.Format hívása kihagy egy záró zárójelet, és egy nyitó zárójelet párosít egy záró zárójelmel.

  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)
  

  A hiba kijavításához győződjön meg arról, hogy az összes nyitó és záró kapcsos zárójel megfelel.

  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)
  

• Az objektumlistát egy összetett formázási metódusban egy erősen beírt paramétertömbként adja meg, a FormatException kivétel pedig azt jelzi, hogy egy vagy több formátumelem indexe meghaladja az objektumlistában szereplő argumentumok számát. Ez azért fordul elő, mert nincs explicit átalakítás a tömbtípusok között, ezért a fordító a tömböt nem paramétertömbként, hanem egyetlen argumentumként kezeli. A metódus következő Console.WriteLine(String, Object[]) hívása például kivételt FormatException jelez, bár a formátumelemek legmagasabb indexe 3, a típus Int32 paramétertömbje pedig négy elemet tartalmaz.

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

  A kivétel kezelése helyett meg kell szüntetnie annak okát. Mivel sem Visual Basic, sem a C# nem tud egész tömböt objektumtömbké alakítani, az összetett formázási módszer meghívása előtt saját maga kell elvégeznie az átalakítást. Az alábbi példa egy megvalósítást mutat be.

  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 A HRESULT COR_E_FORMAT használja, amelynek értéke 0x80131537.

Az FormatException osztály származik, Exception és nem ad hozzá egyedi tagokat. A FormatException példány kezdeti tulajdonságainak listájáért tekintse meg a FormatException konstruktorokat.

Konstruktorok

Name	Description
FormatException()	Inicializálja a FormatException osztály új példányát.
FormatException(SerializationInfo, StreamingContext)	Elavult. Inicializálja az FormatException osztály új példányát szerializált adatokkal.
FormatException(String, Exception)	Inicializálja az FormatException osztály új példányát egy megadott hibaüzenettel és a kivétel okaként szolgáló belső kivételre mutató hivatkozással.
FormatException(String)	Inicializálja az FormatException osztály új példányát egy megadott hibaüzenettel.

Tulajdonságok

Name	Description
Data	Lekéri a kulcs-/érték párok gyűjteményét, amelyek további, felhasználó által definiált információkat biztosítanak a kivételről. (Öröklődés forrása Exception)
HelpLink	Lekéri vagy beállítja a kivételhez társított súgófájlra mutató hivatkozást. (Öröklődés forrása Exception)
HResult	Lekéri vagy beállítja a HRESULT-ot, egy kódolt numerikus értéket, amely egy adott kivételhez van hozzárendelve. (Öröklődés forrása Exception)
InnerException	Lekéri az Exception aktuális kivételt okozó példányt. (Öröklődés forrása Exception)
Message	Az aktuális kivételt leíró üzenet jelenik meg. (Öröklődés forrása Exception)
Source	Lekéri vagy beállítja az alkalmazás vagy a hibát okozó objektum nevét. (Öröklődés forrása Exception)
StackTrace	Lekéri a hívásverem közvetlen kereteinek sztringképét. (Öröklődés forrása Exception)
TargetSite	Lekéri az aktuális kivételt okozó metódust. (Öröklődés forrása Exception)

Metódusok

Name	Description
Equals(Object)	Meghatározza, hogy a megadott objektum egyenlő-e az aktuális objektummal. (Öröklődés forrása Object)
GetBaseException()	Ha egy származtatott osztály felül van bírálva, egy Exception vagy több későbbi kivétel kiváltó okát adja vissza. (Öröklődés forrása Exception)
GetHashCode()	Ez az alapértelmezett kivonatoló függvény. (Öröklődés forrása Object)
GetObjectData(SerializationInfo, StreamingContext)	Elavult. Ha felül van bírálva egy származtatott osztályban, a SerializationInfo kivétel adatait adja meg. (Öröklődés forrása Exception)
GetType()	Lekéri az aktuális példány futtatókörnyezeti típusát. (Öröklődés forrása Exception)
MemberwiseClone()	Az aktuális Objectpéldány sekély másolatát hozza létre. (Öröklődés forrása Object)
ToString()	Létrehozza és visszaadja az aktuális kivétel sztring-ábrázolását. (Öröklődés forrása Exception)

esemény

Name	Description
SerializeObjectState	Elavult. Akkor fordul elő, ha a kivétel szerializálva van egy kivételállapot-objektum létrehozásához, amely szerializált adatokat tartalmaz a kivételről. (Öröklődés forrása Exception)

Lásd még

• Exception
• Kivételek kezelése és kivetése