FormatException Classe

Définition

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

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
Héritage
FormatException
Héritage
FormatException
Dérivé
Attributs

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 Parse ParseExact des méthodes et 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 et gérer l' FormatException exception en cas d’échec de la conversion. Vous pouvez également remplacer l’appel à la méthode de conversion par un appel à TryParse une TryParseExact méthode ou, s’il en existe un. Toutefois, une FormatException exception qui est 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' System espace de noms peut lever une FormatException exception :

    • Boolean. Les Boolean.Parse(String) Convert.ToBoolean(String) méthodes et requièrent que la chaîne soit convertie en « true », « true », « false » ou « false ». Toute autre valeur lève une FormatException exception.

    • Voir DateTime et DateTimeOffset. Toutes les données de date et d’heure sont interprétées selon les conventions de mise en forme d’une culture particulière : soit la culture actuelle (ou, dans certains cas, la culture de domaine d’application actuelle), la culture dite indifférente, soit une culture spécifiée. Quand vous appelez les DateTime.ParseExact(String, String, IFormatProvider, DateTimeStyles) DateTimeOffset.ParseExact(String, String[], IFormatProvider, DateTimeStyles) méthodes et, les données de date et d’heure doivent également se conformer exactement à un modèle spécifié par une ou plusieurs chaînes de format standard ou des chaînes de format personnalisées qui sont fournies comme arguments dans l’appel de méthode. Si elle n’est pas conforme à un modèle attendu spécifique à la culture, 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 documentation de la méthode qui a levé l’exception.

    • GUID. La représentation sous forme de chaîne d’un GUID doit être composée de 32 chiffres hexadécimaux (0-F) et doit être dans l’un des cinq formats générés par la Guid.ToString méthode. Pour plus d'informations, voir la méthode Guid.Parse.

    • Types numériques, y compris tous les entiers signés, les entiers non signés et les types à virgule flottante. La chaîne à analyser doit être composée des chiffres latins 0-9. Le signe positif ou négatif, le séparateur décimal, les séparateurs de groupes et le symbole monétaire peuvent également être autorisés. Toute tentative d’analyse d’une chaîne qui contient un autre caractère lève toujours une FormatException exception.

      Toutes les chaînes numériques sont interprétées selon les conventions de mise en forme d’une culture particulière : la culture actuelle, la culture dite indifférente ou une culture spécifiée. Par conséquent, une chaîne numérique qui est analysée à l’aide des conventions d’une culture peut échouer lors de l’utilisation des conventions d’une autre culture.

      Pour plus d’informations sur l’analyse des chaînes numériques, consultez analyse de chaînes numériques et documentation pour la méthode spécifique qui a levé l’exception.

    • Intervalles de temps. La chaîne à analyser doit être dans un format fixe indépendant de la culture ou dans un format dépendant de la culture défini par la culture actuelle, la culture dite indifférente ou une culture spécifiée. Si la chaîne n’est pas dans un format approprié ou si, au minimum, les composants Days, Hours 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' IFormattable interface, 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. Cela 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 standardvalide.

    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()
    
    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-la par une chaîne valide. L’exemple suivant corrige l’erreur en remplaçant la chaîne de format non valide par la chaîne de format "C" (Currency).

    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.
    
    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 en analysant des méthodes, telles que DateTime.ParseExact et Guid.ParseExact , qui requièrent que la chaîne soit analysée pour se conformer 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 supposée se conformer au modèle spécifié par la chaîne de format standard "G". Toutefois, l' Guid implémentation de la structure de IFormattable 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()
    
    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 n’a pas besoin d’un 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
    
    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 des index des éléments de mise en forme d’une chaîne de format composite sont supérieurs aux index des éléments contenus dans la liste d’objets ou le tableau de paramètres. Dans l’exemple suivant, le plus grand index d’un élément de mise en forme 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 nécessite que la liste d’objets contiendra quatre éléments. Au lieu de cela, il n’a que trois, dat , temp 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()
    
    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' FormatException exception est le résultat d’une erreur du développeur. Elle doit être corrigée plutôt que gérée dans un bloc en s’assurant try/catch 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 mise en forme pour faire référence à la dat variable, puis décrémente l’index de chaque élément de mise en forme suivant d’une unité.

    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
    
    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. Dans ce cas, l' FormatException exception est toujours due à une erreur du développeur. Elle doit être corrigée plutôt que gérée dans un try/catch bloc.

    Si vous essayez d’inclure des accolades littérales dans une chaîne, comme le montre l’exemple suivant, lèvera l’exception.

    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 mise en forme 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 indiqué 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);
    
    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 couple une accolade ouvrante à un crochet fermant.

    int n1 = 10;
    int 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, assurez-vous que toutes les accolades ouvrantes et fermantes correspondent.

    String 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 en tant que tableau de paramètres fortement typés, et l' FormatException exception indique que l’index d’un ou plusieurs éléments de mise en forme dépasse le nombre d’arguments de la liste d’objets. Cela est dû au fait qu’il n’existe aucune conversion explicite entre des types tableau. par conséquent, le compilateur traite le tableau comme un argument unique 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 mise en forme soit 3 et que le tableau de paramètres de type Int32 ait 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()
    
    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
    
    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 de Exception et n’ajoute aucun membre unique. Pour obtenir la liste des valeurs initiales des propriétés d’une instance de FormatException, consultez le FormatException constructeurs.

Constructeurs

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)

Initialise une nouvelle instance de la classe FormatException avec un message d'erreur spécifié.

FormatException(String, Exception)

Initialise une nouvelle instance de la classe FormatException avec un message d'erreur spécifié et une référence à l'exception interne ayant provoqué cette exception.

Propriétés

Data

Obtient une collection de paires clé/valeur qui fournissent des informations définies par l'utilisateur supplémentaires 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 qui est assigné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 active.

(Hérité de Exception)
Source

Obtient ou définit le nom de l'application ou de l'objet qui est à l'origine de l'erreur.

(Hérité de Exception)
StackTrace

Obtient une représentation sous forme de chaîne des frames immédiats 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

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 à l'origine d'une ou de plusieurs exceptions ultérieures.

(Hérité de Exception)
GetHashCode()

Fait office 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 SerializationInfo avec des informations sur l'exception.

(Hérité de Exception)
GetType()

Obtient le type au moment de l'exécution de l'instance actuelle.

(Hérité de Exception)
MemberwiseClone()

Crée une copie superficielle du Object actuel.

(Hérité de Object)
ToString()

Crée et retourne une chaîne représentant l'exception actuelle.

(Hérité de Exception)

Événements

SerializeObjectState
Obsolète.

Se produit quand une exception est sérialisée pour créer un objet d'état d'exception qui contient des données sérialisées concernant l'exception.

(Hérité de Exception)

S’applique à

Voir aussi