FormatException Classe

Définition

Espace de noms:: System

Assemblys:: mscorlib.dll, System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: System.Runtime.dll

Assembly:: netstandard.dll

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Exception levée lorsque le format d’un argument n’est pas valide ou lorsqu’une chaîne de format composite n’est pas correctement formée.

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

Héritage: Object

Exception
FormatException

Héritage: Object

Exception

SystemException
FormatException

Dérivé: System.IO.FileFormatException

System.Net.CookieException

System.Reflection.CustomAttributeFormatException

System.UriFormatException

Attributs: SerializableAttribute ComVisibleAttribute

Remarques

Une FormatException exception peut être levée pour l’une des raisons suivantes :

Dans un appel à une méthode qui convertit une chaîne en un autre type de données, la chaîne n’est pas conforme au modèle requis. Cela se produit généralement lors de l’appel de certaines méthodes de la Convert classe et des ParseParseExact méthodes de certains types.

Dans la plupart des cas, en particulier si la chaîne que vous convertissez est entrée par un utilisateur ou lue à partir d’un fichier, vous devez utiliser un try/catch bloc (try/with en F#) et gérer l’exception FormatException si la conversion échoue. Vous pouvez également remplacer l’appel à la méthode de conversion par un appel à une TryParse ou TryParseExact une méthode, s’il en existe un. Toutefois, une FormatException exception levée lorsque vous essayez d’analyser une chaîne prédéfinie ou codée en dur indique une erreur de programme. Dans ce cas, vous devez corriger l’erreur plutôt que de gérer l’exception.

La conversion d’une chaîne en types suivants dans l’espace System de noms peut lever une FormatException exception :
- Boolean. Les Boolean.Parse(String) méthodes exigent Convert.ToBoolean(String) que la chaîne soit convertie en « True », « true », « false » ou « false ». Toute autre valeur lève une FormatException exception.
- DateTime et DateTimeOffset. Toutes les données de date et d’heure sont interprétées en fonction des conventions de mise en forme d’une culture particulière : la culture actuelle (ou, dans certains cas, la culture de domaine d’application actuelle), la culture invariante ou une culture spécifiée. Lorsque vous appelez les méthodes et DateTimeOffset.ParseExact(String, String[], IFormatProvider, DateTimeStyles) les DateTime.ParseExact(String, String, IFormatProvider, DateTimeStyles) méthodes, les données de date et d’heure doivent également être conformes exactement à un modèle spécifié par une ou plusieurs chaînes de format standard ou des chaînes de format personnalisées fournies en tant qu’arguments dans l’appel de méthode. S’il n’est pas conforme à un modèle spécifique à la culture attendu, une FormatException exception est levée. Cela signifie que les données de date et d’heure enregistrées dans un format spécifique à la culture sur un système peuvent ne pas être analysées correctement sur un autre système.
  
  Pour plus d’informations sur l’analyse des dates et des heures, consultez Analyse des chaînes de date et d’heure et de la documentation de la méthode qui a levé l’exception.
- GUID. La représentation sous forme de chaîne d’un GUID doit se composer de 32 chiffres hexadécimaux (0-F) et doit se trouver dans l’un des cinq formats de sortie par la Guid.ToString méthode. Pour plus d’informations, consultez la Guid.Parse méthode.
- Types numériques, y compris tous les entiers signés, entiers non signés et types à virgule flottante. La chaîne à analyser doit être composée des chiffres latins 0-9. Un signe positif ou négatif, séparateur décimal, séparateur de groupe et symbole monétaire peut également être autorisé. Essayer d’analyser une chaîne qui contient tout autre caractère lève toujours une FormatException exception.
  
  Toutes les chaînes numériques sont interprétées en fonction des conventions de mise en forme d’une culture particulière : la culture actuelle, la culture invariante ou une culture spécifiée. Par conséquent, une chaîne numérique analysée à l’aide des conventions d’une culture peut échouer lors de l’utilisation des conventions d’une autre.
  
  Pour plus d’informations sur l’analyse des chaînes numériques, consultez Analyse des chaînes numériques et la documentation relative à la méthode spécifique qui a levé l’exception.
- Intervalles de temps. La chaîne à analyser doit être au format non sensible à la culture fixe ou dans un format respectant la culture défini par la culture actuelle, la culture invariante ou une culture spécifiée. Si la chaîne n’est pas dans un format approprié ou si, au minimum, les composants jours, heures et minutes de l’intervalle de temps ne sont pas présents, la méthode d’analyse lève une FormatException exception. Pour plus d’informations, consultez la documentation de la TimeSpan méthode d’analyse qui a levé l’exception.

Un type implémente l’interface IFormattable , qui prend en charge les chaînes de format qui définissent la façon dont un objet est converti en sa représentation sous forme de chaîne et une chaîne de format non valide est utilisée. Ceci est le plus courant dans une opération de mise en forme. Dans l’exemple suivant, la chaîne de format standard « Q » est utilisée dans une chaîne de format composite pour mettre en forme un nombre. Toutefois, « Q » n’est pas une chaîne de format standard valide.

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

Cette exception résulte d’une erreur de codage. Pour corriger l’erreur, supprimez la chaîne de format ou remplacez-en une valide. L’exemple suivant corrige l’erreur en remplaçant la chaîne de format non valide par la chaîne de format « C » (devise).

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.

Une FormatException exception peut également être levée par des méthodes d’analyse, telles que DateTime.ParseExact et Guid.ParseExact, qui nécessitent l’analyse de la chaîne pour être conforme exactement au modèle spécifié par une chaîne de format. Dans l’exemple suivant, la représentation sous forme de chaîne d’un GUID est censée être conforme au modèle spécifié par la chaîne de format standard « G ». Toutefois, l’implémentation de IFormattable la Guid structure ne prend pas en charge la chaîne de format « 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()

Cette exception résulte également d’une erreur de codage. Pour le corriger, appelez une méthode d’analyse qui ne nécessite pas de format précis, tel que DateTime.Parse ou Guid.Parse, ou remplacez une chaîne de format valide. L’exemple suivant corrige l’erreur en appelant la Guid.Parse méthode.

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

Un ou plusieurs index des éléments de format dans une chaîne de format composite sont supérieurs aux index des éléments de la liste d’objets ou du tableau de paramètres. Dans l’exemple suivant, le plus grand index d’un élément de format dans la chaîne de format est 3. Étant donné que les index des éléments de la liste d’objets sont de base zéro, cette chaîne de format exigerait que la liste d’objets ait quatre éléments. Au lieu de cela, il n’a que trois, dat, tempet , et scale, donc le code génère une FormatException exception au moment de l’exécution :.

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

Dans ce cas, l’exception FormatException résulte d’une erreur de développeur. Il doit être corrigé plutôt que géré dans un try/catch bloc en s’assurant que chaque élément de la liste d’objets correspond à l’index d’un élément de format. Pour corriger cet exemple, modifiez l’index du deuxième élément de format pour faire référence à la dat variable et décrémentez l’index de chaque élément de format suivant par un.

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

La chaîne de format composite n’est pas bien formée. Lorsque cela se produit, l’exception FormatException est toujours le résultat d’une erreur de développeur. Elle doit être corrigée plutôt que gérée dans un try/catch bloc.

La tentative d’inclure des accolades littérales dans une chaîne, comme l’exemple suivant, lève l’exception.

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)

La technique recommandée pour inclure des accolades littérales dans une chaîne de format composite consiste à les inclure dans la liste d’objets et à utiliser des éléments de format pour les insérer dans la chaîne de résultat. Par exemple, vous pouvez modifier la chaîne de format composite précédente, comme illustré ici.

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)

L’exception est également levée si votre chaîne de format contient une faute de frappe. L’appel suivant à la String.Format méthode omet une accolade fermante et associe une accolade ouvrante avec un crochet fermant.

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)

Pour corriger l’erreur, vérifiez que toutes les accolades ouvrantes et fermante correspondent.

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)

Vous avez fourni la liste d’objets dans une méthode de mise en forme composite comme tableau de paramètres fortement typé, et l’exception FormatException indique que l’index d’un ou plusieurs éléments de format dépasse le nombre d’arguments dans la liste d’objets. Cela se produit parce qu’aucune conversion explicite entre les types de tableaux n’existe. Par conséquent, le compilateur traite le tableau comme un seul argument plutôt que comme un tableau de paramètres. Par exemple, l’appel suivant à la Console.WriteLine(String, Object[]) méthode lève une FormatException exception, bien que l’index le plus élevé des éléments de format soit 3, et que le tableau de paramètres de type Int32 comporte quatre éléments.

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

Au lieu de gérer cette exception, vous devez éliminer sa cause. Étant donné que ni Visual Basic ni C# ne peuvent convertir un tableau d’entiers en tableau d’objets, vous devez effectuer la conversion vous-même avant d’appeler la méthode de mise en forme composite. L’exemple suivant fournit une implémentation.

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 utilise le COR_E_FORMAT HRESULT, qui a la valeur 0x80131537.

La FormatException classe dérive et Exception n’ajoute aucun membre unique. Pour obtenir la liste des valeurs de propriété initiales d’une instance de FormatException, consultez les FormatException constructeurs.

Constructeurs

Nom	Description
FormatException()	Initialise une nouvelle instance de la classe FormatException.
FormatException(SerializationInfo, StreamingContext)	Initialise une nouvelle instance de la classe FormatException avec des données sérialisées.
FormatException(String, Exception)	Initialise une nouvelle instance de la FormatException classe avec un message d’erreur spécifié et une référence à l’exception interne qui est la cause de cette exception.
FormatException(String)	Initialise une nouvelle instance de la FormatException classe avec un message d’erreur spécifié.

Propriétés

Nom	Description
Data	Obtient une collection de paires clé/valeur qui fournissent des informations supplémentaires définies par l’utilisateur sur l’exception. (Hérité de Exception)
HelpLink	Obtient ou définit un lien vers le fichier d’aide associé à cette exception. (Hérité de Exception)
HResult	Obtient ou définit HRESULT, valeur numérique codée affectée à une exception spécifique. (Hérité de Exception)
InnerException	Obtient l’instance Exception qui a provoqué l’exception actuelle. (Hérité de Exception)
Message	Obtient un message qui décrit l’exception actuelle. (Hérité de Exception)
Source	Obtient ou définit le nom de l’application ou de l’objet qui provoque l’erreur. (Hérité de Exception)
StackTrace	Obtient une représentation sous forme de chaîne des images immédiates sur la pile des appels. (Hérité de Exception)
TargetSite	Obtient la méthode qui lève l’exception actuelle. (Hérité de Exception)

Méthodes

Nom	Description
Equals(Object)	Détermine si l’objet spécifié est égal à l’objet actuel. (Hérité de Object)
GetBaseException()	En cas de substitution dans une classe dérivée, retourne la Exception qui est la cause racine d’une ou plusieurs exceptions ultérieures. (Hérité de Exception)
GetHashCode()	Sert de fonction de hachage par défaut. (Hérité de Object)
GetObjectData(SerializationInfo, StreamingContext)	En cas de substitution dans une classe dérivée, définit l'SerializationInfo avec des informations sur l’exception. (Hérité de Exception)
GetType()	Obtient le type d’exécution de l’instance actuelle. (Hérité de Exception)
MemberwiseClone()	Crée une copie superficielle du Objectactuel. (Hérité de Object)
ToString()	Crée et retourne une représentation sous forme de chaîne de l’exception actuelle. (Hérité de Exception)

Événements

Nom	Description
SerializeObjectState	Se produit lorsqu’une exception est sérialisée pour créer un objet d’état d’exception qui contient des données sérialisées sur l’exception. (Hérité de Exception)

S’applique à

Voir aussi

Commentaires

Cette page a-t-elle été utile ?