FormatException Klas

Definitie

Naamruimte:: System

Assembly's:: mscorlib.dll, System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: System.Runtime.dll

Assembly:: netstandard.dll

Belangrijk

Bepaalde informatie heeft betrekking op een voorlopige productversie die aanzienlijk kan worden gewijzigd voordat deze wordt uitgebracht. Microsoft biedt geen enkele expliciete of impliciete garanties met betrekking tot de informatie die hier wordt verstrekt.

De uitzondering die wordt gegenereerd wanneer de notatie van een argument ongeldig is of wanneer een tekenreeks met samengestelde opmaak niet goed is gevormd.

public ref class FormatException : Exception

public ref class FormatException : SystemException

public class FormatException : Exception

[System.Serializable]
public class FormatException : SystemException

[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public class FormatException : SystemException

public class FormatException : SystemException

type FormatException = class
    inherit Exception

[<System.Serializable>]
type FormatException = class
    inherit SystemException

[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type FormatException = class
    inherit SystemException

type FormatException = class
    inherit SystemException

Public Class FormatException
Inherits Exception

Public Class FormatException
Inherits SystemException

Overname: Object

Exception
FormatException

Overname: Object

Exception

SystemException
FormatException

Afgeleid: System.IO.FileFormatException

System.Net.CookieException

System.Reflection.CustomAttributeFormatException

System.UriFormatException

Kenmerken: SerializableAttribute ComVisibleAttribute

Opmerkingen

Een FormatException uitzondering kan om een van de volgende redenen worden gegenereerd:

In een aanroep naar een methode die een tekenreeks converteert naar een ander gegevenstype, voldoet de tekenreeks niet aan het vereiste patroon. Dit gebeurt meestal wanneer bepaalde methoden van de Convert klasse en de Parse methoden ParseExact van sommige typen worden aangeroepen.

In de meeste gevallen, met name als de tekenreeks die u converteert invoer is door een gebruiker of gelezen uit een bestand, moet u een try/catch (try/with in F#) blok gebruiken en de FormatException uitzondering afhandelen als de conversie mislukt. U kunt de aanroep naar de conversiemethode ook vervangen door een aanroep naar een TryParse of TryParseExact methode, indien aanwezig. Een FormatException uitzondering die wordt gegenereerd wanneer u een vooraf gedefinieerde of in code vastgelegde tekenreeks probeert te parseren, geeft echter een programmafout aan. In dit geval moet u de fout corrigeren in plaats van de uitzondering af te handelen.

De conversie van een tekenreeks naar de volgende typen in de System naamruimte kan een FormatException uitzondering genereren:
- Boolean. Voor Boolean.Parse(String) de en Convert.ToBoolean(String) methoden moet de tekenreeks worden geconverteerd naar 'True', 'true', 'False' of 'false'. Elke andere waarde genereert een FormatException uitzondering.
- DateTime en DateTimeOffset. Alle datum- en tijdgegevens worden geïnterpreteerd op basis van de opmaakconventies van een bepaalde cultuur: de huidige cultuur (of in sommige gevallen de huidige cultuur van het toepassingsdomein), de invariante cultuur of een opgegeven cultuur. Wanneer u de DateTime.ParseExact(String, String, IFormatProvider, DateTimeStyles) en DateTimeOffset.ParseExact(String, String[], IFormatProvider, DateTimeStyles) methoden aanroept, moeten datum- en tijdgegevens ook exact voldoen aan een patroon dat is opgegeven door een of meer standaardnotatietekenreeksen of aangepaste notatietekenreeksen die worden opgegeven als argumenten in de methode-aanroep. Als het niet voldoet aan een verwacht cultuurspecifiek patroon, wordt er een FormatException uitzondering gegenereerd. Dit betekent dat datum- en tijdgegevens die zijn opgeslagen in een cultuurspecifieke indeling op het ene systeem mogelijk niet succesvol worden geparseerd op een ander systeem.
  
  Zie Datum- en tijdreeksen parseren en de documentatie voor de methode die de uitzondering heeft veroorzaakt voor meer informatie over het parseren van datums en tijden.
- GUIDs. De tekenreeksweergave van een GUID moet bestaan uit 32 hexadecimale cijfers (0-F) en moet een van de vijf indelingen hebben die door de Guid.ToString methode worden uitgevoerd. Zie de Guid.Parse methode voor meer informatie.
- Numerieke typen, inclusief alle ondertekende gehele getallen, niet-ondertekende gehele getallen en typen drijvende komma. De tekenreeks die moet worden geparseerd, moet bestaan uit de Latijnse cijfers 0-9. Een positief of negatief teken, decimaalteken, groepsscheidingstekens en valutasymbool kan ook zijn toegestaan. Als u een tekenreeks probeert te parseren die een ander teken bevat, wordt er altijd een FormatException uitzondering gegenereerd.
  
  Alle numerieke tekenreeksen worden geïnterpreteerd op basis van de opmaakconventies van een bepaalde cultuur: de huidige cultuur, de invariante cultuur of een opgegeven cultuur. Als gevolg hiervan kan een numerieke tekenreeks die wordt geparseerd met behulp van de conventies van één cultuur mislukken wanneer de conventies van een andere cultuur worden gebruikt.
  
  Zie Parsering van numerieke tekenreeksen en de documentatie voor de specifieke methode die de uitzondering heeft veroorzaakt voor meer informatie over het parseren van numerieke tekenreeksen.
- Tijdsintervallen. De tekenreeks die moet worden geparseerd, moet een vaste cultuurgevoelige notatie hebben of in een cultuurgevoelige indeling die is gedefinieerd door de huidige cultuur, de invariante cultuur of een opgegeven cultuur. Als de tekenreeks niet de juiste indeling heeft of als de onderdelen dagen, uren en minuten van het tijdsinterval niet aanwezig zijn, genereert de parseringsmethode een FormatException uitzondering. Zie de documentatie voor de TimeSpan parseringsmethode die de uitzondering heeft veroorzaakt voor meer informatie.

Een type implementeert de IFormattable interface, die indelingstekenreeksen ondersteunt die definiëren hoe een object wordt geconverteerd naar de tekenreeksweergave en een ongeldige notatietekenreeks wordt gebruikt. Dit komt het meest voor in een opmaakbewerking. In het volgende voorbeeld wordt de tekenreeks voor de standaardnotatie Q gebruikt in een samengestelde notatietekenreeks om een getal op te maken. Q is echter geen geldige standaardnotatietekenreeks.

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

Deze uitzondering is het gevolg van een coderingsfout. Als u de fout wilt corrigeren, verwijdert u de notatietekenreeks of vervangt u een geldige tekenreeks. In het volgende voorbeeld wordt de fout gecorrigeerd door de ongeldige notatietekenreeks te vervangen door de notatietekenreeks C (valuta).

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.

Een FormatException uitzondering kan ook worden gegenereerd door parseringsmethoden, zoals DateTime.ParseExact en Guid.ParseExact, waarvoor de tekenreeks moet worden geparseerd om exact te voldoen aan het patroon dat is opgegeven door een notatietekenreeks. In het volgende voorbeeld wordt verwacht dat de tekenreeksweergave van een GUID voldoet aan het patroon dat is opgegeven door de standaardnotatietekenreeks G. De implementatie van IFormattable de Guid structuur biedt echter geen ondersteuning voor de tekenreeks 'G'-indeling.

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

Deze uitzondering is ook het gevolg van een coderingsfout. U kunt dit corrigeren door een parseringsmethode aan te roepen waarvoor geen nauwkeurige indeling is vereist, zoals DateTime.Parse of Guid.Parse, of een geldige notatietekenreeks te vervangen. In het volgende voorbeeld wordt de fout gecorrigeerd door de Guid.Parse methode aan te roepen.

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

Een of meer indexen van de notatie-items in een samengestelde notatietekenreeks zijn groter dan de indexen van de items in de objectlijst of parametermatrix. In het volgende voorbeeld is de grootste index van een notatie-item in de notatietekenreeks 3. Omdat de indexen van items in de objectlijst op nul zijn gebaseerd, is voor deze notatietekenreeks vereist dat de objectlijst vier items bevat. In plaats daarvan heeft het slechts drie, dat, tempen scale, dus de code resulteert in een FormatException uitzondering tijdens runtime:.

using System;

public class Example
{
   public enum TemperatureScale
   { Celsius, Fahrenheit, Kelvin }

   public static void Main()
   {
      String info = GetCurrentTemperature();
      Console.WriteLine(info);
   }

   private static String GetCurrentTemperature()
   {
      DateTime dat = DateTime.Now;
      Decimal temp = 20.6m;
      TemperatureScale scale = TemperatureScale.Celsius;
      String result;

      result = String.Format("At {0:t} on {1:D}, the temperature is {2:F1} {3:G}",
                             dat, temp, scale);
      return result;
   }
}
// The example displays output like the following:
//    Unhandled Exception: System.FormatException: Format specifier was invalid.
//       at System.Number.FormatDecimal(Decimal value, String format, NumberFormatInfo info)
//       at System.Decimal.ToString(String format, IFormatProvider provider)
//       at System.Text.StringBuilder.AppendFormat(IFormatProvider provider, String format, Object[] args)
//       at System.String.Format(IFormatProvider provider, String format, Object[] args)
//       at Example.Main()

open System

type TemperatureScale =
    | Celsius = 0
    | Fahrenheit = 1
    | Kelvin = 2

let getCurrentTemperature () =
    let dat = DateTime.Now
    let temp = 20.6m
    let scale = TemperatureScale.Celsius
    String.Format("At {0:t} on {1:D}, the temperature is {2:F1} {3:G}", dat, temp, scale)

getCurrentTemperature ()
|> printfn "%s"

// The example displays output like the following:
//    Unhandled Exception: System.FormatException: Format specifier was invalid.
//       at System.Number.NumberToString(ValueStringBuilder& sb, NumberBuffer& number, Char format, Int32 nMaxDigits, NumberFormatInfo info)   
//       at System.Number.TryFormatDecimal(Decimal value, ReadOnlySpan`1 format, NumberFormatInfo info, Span`1 destination, Int32& charsWritten)
//       at System.Decimal.TryFormat(Span`1 destination, Int32& charsWritten, ReadOnlySpan`1 format, IFormatProvider provider)       
//       at System.Text.ValueStringBuilder.AppendFormatHelper(IFormatProvider provider, String format, ParamsArray args)
//       at System.String.FormatHelper(IFormatProvider provider, String format, ParamsArray args)
//       at System.String.Format(String format, Object arg0, Object arg1, Object arg2)
//       at Example.getCurrentTemperature()
//       at <StartupCode$fs>.$Example.main@()

Module Example
   Public Enum TemperatureScale As Integer
      Celsius
      Fahrenheit
      Kelvin
   End Enum

   Public Sub Main()
      Dim info As String = GetCurrentTemperature()
      Console.WriteLine(info)
   End Sub

   Private Function GetCurrentTemperature() As String
      Dim dat As Date = Date.Now
      Dim temp As Decimal = 20.6d
      Dim scale As TemperatureScale = TemperatureScale.Celsius
      Dim result As String 
      
      result = String.Format("At {0:t} on {1:D}, the temperature is {2:F1} {3:G}",
                             dat, temp, scale)    
      Return result
   End Function
End Module
' The example displays output like the following:
'    Unhandled Exception: System.FormatException: Format specifier was invalid.
'       at System.Number.FormatDecimal(Decimal value, String format, NumberFormatInfo info)
'       at System.Decimal.ToString(String format, IFormatProvider provider)
'       at System.Text.StringBuilder.AppendFormat(IFormatProvider provider, String format, Object[] args)
'       at System.String.Format(IFormatProvider provider, String format, Object[] args)
'       at Example.Main()

In dit geval is de uitzondering het gevolg van een fout in de FormatException ontwikkelaar. Dit moet worden gecorrigeerd in plaats van in een try/catch blok te worden verwerkt door ervoor te zorgen dat elk item in de objectlijst overeenkomt met de index van een opmaakitem. Als u dit voorbeeld wilt corrigeren, wijzigt u de index van het tweede notatie-item om naar de dat variabele te verwijzen en de index van elk volgend opmaakitem met één te verlagen.

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

De tekenreeks voor samengestelde notatie is niet goed opgemaakt. Wanneer dit gebeurt, is de FormatException uitzondering altijd het gevolg van een ontwikkelaarsfout. Het moet worden gecorrigeerd in plaats van verwerkt in een try/catch blok.

Als u letterlijke accolades in een tekenreeks wilt opnemen, zoals in het volgende voorbeeld, wordt de uitzondering gegenereerd.

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)

De aanbevolen techniek voor het opnemen van letterlijke accolades in een tekenreeks voor samengestelde notatie is om ze op te nemen in de lijst met objecten en items opmaken om ze in de resultaattekenreeks in te voegen. U kunt bijvoorbeeld de vorige tekenreeks voor samengestelde opmaak wijzigen, zoals hier wordt weergegeven.

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)

De uitzondering wordt ook gegenereerd als uw notatietekenreeks een typefout bevat. De volgende aanroep van de String.Format methode laat een accolade sluiten weg en koppelt een openingsbrace met een haak sluiten.

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)

Als u de fout wilt corrigeren, moet u ervoor zorgen dat alle accolades openen en sluiten overeenkomen.

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)

U hebt de objectlijst in een samengestelde opmaakmethode opgegeven als een sterk getypte parametermatrix en de FormatException uitzondering geeft aan dat de index van een of meer opmaakitems het aantal argumenten in de objectlijst overschrijdt. Dit komt doordat er geen expliciete conversie tussen matrixtypen bestaat, dus in plaats daarvan behandelt de compiler de matrix als één argument in plaats van als een parametermatrix. De volgende aanroep van de Console.WriteLine(String, Object[]) methode genereert bijvoorbeeld een FormatException uitzondering, hoewel de hoogste index van de notatie-items 3 is en de parametermatrix van het type Int32 vier elementen heeft.

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

In plaats van deze uitzondering af te handelen, moet u de oorzaak ervan elimineren. Omdat geen Visual Basic noch C# een geheel getalmatrix kan converteren naar een objectmatrix, moet u de conversie zelf uitvoeren voordat u de samengestelde opmaakmethode aanroept. In het volgende voorbeeld ziet u één implementatie.

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 maakt gebruik van de HRESULT-COR_E_FORMAT, met de waarde 0x80131537.

De FormatException klasse is afgeleid van Exception en voegt geen unieke leden toe. Voor een lijst van initiële eigenschapswaarden voor een exemplaar van FormatException, zie de FormatException-constructoren.

Constructors

Name	Description
FormatException()	Initialiseert een nieuw exemplaar van de FormatException klasse.
FormatException(SerializationInfo, StreamingContext)	Initialiseert een nieuw exemplaar van de FormatException klasse met geserialiseerde gegevens.
FormatException(String, Exception)	Initialiseert een nieuw exemplaar van de FormatException klasse met een opgegeven foutbericht en een verwijzing naar de binnenste uitzondering die de oorzaak van deze uitzondering is.
FormatException(String)	Initialiseert een nieuw exemplaar van de FormatException klasse met een opgegeven foutbericht.

Eigenschappen

Name	Description
Data	Hiermee haalt u een verzameling sleutel-waardeparen op die aanvullende door de gebruiker gedefinieerde informatie over de uitzondering bieden. (Overgenomen van Exception)
HelpLink	Hiermee haalt u een koppeling op naar het Help-bestand dat aan deze uitzondering is gekoppeld. (Overgenomen van Exception)
HResult	Hiermee wordt HRESULT opgehaald of ingesteld, een gecodeerde numerieke waarde die is toegewezen aan een specifieke uitzondering. (Overgenomen van Exception)
InnerException	Hiermee haalt u het Exception exemplaar op dat de huidige uitzondering heeft veroorzaakt. (Overgenomen van Exception)
Message	Hiermee wordt een bericht weergegeven waarin de huidige uitzondering wordt beschreven. (Overgenomen van Exception)
Source	Hiermee wordt de naam van de toepassing of het object dat de fout veroorzaakt, opgehaald of ingesteld. (Overgenomen van Exception)
StackTrace	Hiermee haalt u een tekenreeksweergave van de directe frames op de aanroepstack op. (Overgenomen van Exception)
TargetSite	Hiermee haalt u de methode op waarmee de huidige uitzondering wordt gegenereerd. (Overgenomen van Exception)

Methoden

Name	Description
Equals(Object)	Bepaalt of het opgegeven object gelijk is aan het huidige object. (Overgenomen van Object)
GetBaseException()	Wanneer deze wordt overschreven in een afgeleide klasse, retourneert u de Exception hoofdoorzaak van een of meer volgende uitzonderingen. (Overgenomen van Exception)
GetHashCode()	Fungeert als de standaardhashfunctie. (Overgenomen van Object)
GetObjectData(SerializationInfo, StreamingContext)	Wanneer deze wordt overschreven in een afgeleide klasse, stelt u de SerializationInfo met informatie over de uitzondering in. (Overgenomen van Exception)
GetType()	Hiermee haalt u het runtimetype van het huidige exemplaar op. (Overgenomen van Exception)
MemberwiseClone()	Hiermee maakt u een ondiepe kopie van de huidige Object. (Overgenomen van Object)
ToString()	Hiermee maakt en retourneert u een tekenreeksweergave van de huidige uitzondering. (Overgenomen van Exception)

gebeurtenis

Name	Description
SerializeObjectState	Treedt op wanneer een uitzondering wordt geserialiseerd om een uitzonderingsstatusobject te maken dat geserialiseerde gegevens over de uitzondering bevat. (Overgenomen van Exception)

Van toepassing op

Zie ook

Feedback

Is deze pagina nuttig?