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.The exception that is thrown when the format of an argument is invalid, or when a composite format string is not well formed.

public ref class FormatException : SystemException
[System.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
public class FormatException : SystemException
type FormatException = class
    inherit SystemException
Public Class FormatException
Inherits SystemException
Héritage
FormatException
Dérivé
Attributs

Remarques

Une FormatException exception peut être levée pour l’une des raisons suivantes:A FormatException exception can be thrown for one of the following reasons:

  • 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.In a call to a method that converts a string to some other data type, the string doesn't conform to the required pattern. Cela se produit généralement lors de l’appel de Convert certaines méthodes de Parse la ParseExact classe et des méthodes et de certains types.This typically occurs when calling some methods of the Convert class and the Parse and ParseExact methods of some 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 try/catch , vous devez utiliser FormatException un bloc et gérer l’exception en cas d’échec de la conversion.In most cases, particularly if the string that you're converting is input by a user or read from a file, you should use a try/catch block and handle the FormatException exception if the conversion is unsuccessful. 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.You can also replace the call to the conversion method with a call to a TryParse or TryParseExact method, if one exists. 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.However, a FormatException exception that is thrown when you're trying to parse a predefined or hard-coded string indicates a program error. Dans ce cas, vous devez corriger l’erreur plutôt que de gérer l’exception.In this case, you should correct the error rather than handle the exception.

    La conversion d’une chaîne en types suivants dans l' System espace de noms peut lever une FormatException exception:The conversion of a string to the following types in the System namespace can throw a FormatException exception:

    • Boolean.Boolean. Les Boolean.Parse(String) méthodes Convert.ToBoolean(String) et requièrent que la chaîne soit convertie en «true», «true», «false» ou «false».The Boolean.Parse(String) and Convert.ToBoolean(String) methods require the string to be converted to be "True", "true", "False", or "false". Toute autre valeur lève une FormatException exception.Any other value throws a FormatException exception.

    • Voir DateTime et DateTimeOffset.DateTime and 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 du thread actuel (ou, dans certains cas, la culture du domaine d’application actuel), la culture dite indifférente, soit une culture spécifiée.All date and time data is interpreted based on the formatting conventions of a particular culture: either the current thread culture (or, in some cases, the current application domain culture), the invariant culture, or a specified culture. Quand vous appelez les DateTime.ParseExact(String, String, IFormatProvider, DateTimeStyles) méthodes DateTimeOffset.ParseExact(String, String[], IFormatProvider, DateTimeStyles) et, 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 qui sont fournies comme arguments dans le appel de méthode.When you call the DateTime.ParseExact(String, String, IFormatProvider, DateTimeStyles) and DateTimeOffset.ParseExact(String, String[], IFormatProvider, DateTimeStyles) methods, date and time data must also conform exactly to a pattern specified by one or more standard format strings or custom format strings that are provided as arguments in the method call. Si elle n’est pas conforme à un modèle attendu spécifique à la FormatException culture, une exception est levée.If it doesn't conform to an expected culture-specific pattern, a FormatException exception is thrown. 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.This means that date and time data saved in a culture-specific format on one system might not parse successfully on another system.

      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.For more information about parsing dates and times, see Parsing Date and Time Strings and the documentation for the method that threw the exception.

    • Guid.GUIDs. 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 Guid.ToString générés par la méthode.The string representation of a GUID must consist of 32 hexadecimal digits (0-F), and must be in one of the five formats output by the Guid.ToString method. Pour plus d'informations, voir la méthode Guid.Parse.For more information, see the Guid.Parse method.

    • Types numériques, y compris tous les entiers signés, les entiers non signés et les types à virgule flottante.Numeric types, including all signed integers, unsigned integers, and floating-point types. La chaîne à analyser doit être composée des chiffres latins 0-9.The string to be parsed must consist of the Latin digits 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.A positive or negative sign, decimal separator, group separators, and currency symbol may also be permitted. Toute tentative d’analyse d’une chaîne qui contient un autre caractère lève toujours FormatException une exception.Trying to parse a string that contains any other character always throws a FormatException exception.

      Toutes les chaînes numériques sont interprétées selon les conventions de mise en forme d’une culture particulière: soit la culture du thread actuel (ou, dans certains cas, la culture du domaine d’application actuel), la culture dite indifférente, soit une culture spécifiée.All numeric strings are interpreted based on the formatting conventions of a particular culture: either the current thread culture (or, in some cases, the current application domain culture), the invariant culture, or a specified culture. 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.As a result, a numeric string that is parsed by using the conventions of one culture might fail when using the conventions of another.

      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.For more information about parsing numeric strings, see Parsing Numeric Strings and the documentation for the specific method that threw the exception.

    • Intervalles de temps.Time intervals. 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 du thread actuel (ou, dans certains cas, la culture du domaine d’application actuel), la culture dite indifférente ou une culture spécifiée.The string to be parsed must be either in fixed culture-insensitive format or in a culture-sensitive format defined by the current thread culture (or, in some cases, the current application domain culture), the invariant culture, or a specified culture. 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 FormatException lève une exception.If the string isn't in an appropriate format, or if, at the minimum, the days, hours, and minutes components of the time interval aren't present, the parsing method throws a FormatException exception. Pour plus d’informations, consultez la documentation de TimeSpan la méthode d’analyse qui a levé l’exception.For more information, see the documentation for the TimeSpan parsing method that threw the 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.A type implements the IFormattable interface, which supports format strings that define how an object is converted to its string representation, and an invalid format string is used. Cela est le plus courant dans une opération de mise en forme.This is most common in a formatting operation. 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.In the following example, the "Q" standard format string is used in a composite format string to format a number. Toutefois, «Q» n’est pas une chaîne de format standardvalide.However, "Q" is not a valid standard format string.

    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.This exception results from a coding error. Pour corriger l’erreur, supprimez la chaîne de format ou remplacez-la par une chaîne valide.To correct the error, either remove the format string or substitute a valid one. L’exemple suivant corrige l’erreur en remplaçant la chaîne de format non valide par la chaîne de format "C" (Currency).The following example corrects the error by replacing the invalid format string with the "C" (currency) format string.

    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 DateTime.ParseExact que Guid.ParseExactet, 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.A FormatException exception can also be thrown by parsing methods, such as DateTime.ParseExact and Guid.ParseExact, that require the string to be parsed to conform exactly to the pattern specified by a format string. 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".In the following example, the string representation of a GUID is expected to conform to the pattern specified by the "G" standard format string. Toutefois, l' Guid implémentation de la structure IFormattable de ne prend pas en charge la chaîne de format "G".However, the Guid structure's implementation of IFormattable does not support the "G" format string.

    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.This exception also results from a coding error. Pour le corriger, appelez une méthode d’analyse qui n’a pas besoin d’un format précis DateTime.Parse , Guid.Parsetel que ou, ou remplacez une chaîne de format valide.To correct it, call a parsing method that doesn't require a precise format, such as DateTime.Parse or Guid.Parse, or substitute a valid format string. L’exemple suivant corrige l’erreur en appelant la Guid.Parse méthode.The following example corrects the error by calling the Guid.Parse method.

    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.One or more of the indexes of the format items in a composite format string is greater than the indexes of the items in the object list or parameter array. Dans l’exemple suivant, le plus grand index d’un élément de mise en forme dans la chaîne de format est 3.In the following example, the largest index of a format item in the format string is 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.Because the indexes of items in the object list are zero-based, this format string would require the object list to have four items. Au lieu de cela, il n' data tempque trois scale,, et, donc le code FormatException génère une exception au moment de l’exécution:.Instead, it has only three, dat, temp, and scale, so the code results in a FormatException exception at run time:.

    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.In this case, the FormatException exception is a result of developer error. Elle doit être corrigée plutôt que gérée try/catch dans un bloc en s’assurant que chaque élément de la liste d’objets correspond à l’index d’un élément de format.It should be corrected rather than handled in a try/catch block by making sure that each item in the object list corresponds to the index of a format item. Pour corriger cet exemple, modifiez l’index du deuxième élément de mise en forme pour faire dat référence à la variable, puis décrémente l’index de chaque élément de mise en forme suivant d’une unité.To correct this example, change the index of the second format item to refer to the dat variable, and decrement the index of each subsequent format item by one.

    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.The composite format string isn't well-formed. Dans ce cas, l' FormatException exception est toujours due à une erreur du développeur.When this happens, the FormatException exception is always a result of developer error. Elle doit être corrigée plutôt que gérée try/catch dans un bloc.It should be corrected rather than handled in a try/catch block.

    Si vous essayez d’inclure des accolades littérales dans une chaîne, comme le montre l’exemple suivant, lèvera l’exception.Trying to include literal braces in a string, as the following example does, will throw the 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.The recommended technique for including literal braces in a composite format string is to include them in the object list and use format items to insert them into the result string. Par exemple, vous pouvez modifier la chaîne de format composite précédente comme indiqué ici.For example, you can modify the previous composite format string as shown here.

    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.The exception is also thrown if your format string contains a typo. L’appel suivant à la String.Format méthode omet une accolade fermante et couple une accolade ouvrante à un crochet fermant.The following call to the String.Format method omits a closing brace and pairs an opening brace with a closing bracket.

    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.To correct the error, ensure that all opening and closing braces correspond.

    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 FormatException paramètres fortement typés, et l’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.You've supplied the object list in a composite formatting method as a strongly typed parameter array, and the FormatException exception indicates that the index of one or more format items exceeds the number of arguments in the object list. 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.This occurs because no explicit conversion between array types exists, so instead the compiler treats the array as a single argument rather than as a parameter array. 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 Int32 tableau de paramètres de type ait quatre éléments.For example, the following call to the Console.WriteLine(String, Object[]) method throws a FormatException exception, although the highest index of the format items is 3, and the parameter array of type Int32 has four elements.

    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.Instead of handling this exception, you should eliminate its cause. Étant donné que ni C# Visual Basic ni ne pouvez 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.Because neither Visual Basic nor C# can convert an integer array to an object array, you have to perform the conversion yourself before calling the composite formatting method. L’exemple suivant fournit une implémentation.The following example provides one implementation.

    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
    

FormatExceptionutilise le HRESULT COR_E_FORMAT, qui a la valeur 0x80131537.FormatException uses the HRESULT COR_E_FORMAT, which has the value 0x80131537.

La FormatException classe dérive de Exception et n’ajoute aucun membre unique.The FormatException class derives from Exception and adds no unique members. Pour obtenir la liste des valeurs initiales des propriétés d’une instance de FormatException, consultez le FormatException constructeurs.For a list of initial property values for an instance of FormatException, see the FormatException constructors.

Constructeurs

FormatException()

Initialise une nouvelle instance de la classe FormatException.Initializes a new instance of the FormatException class.

FormatException(SerializationInfo, StreamingContext)

Initialise une nouvelle instance de la classe FormatException avec des données sérialisées.Initializes a new instance of the FormatException class with serialized data.

FormatException(String)

Initialise une nouvelle instance de la classe FormatException avec un message d'erreur spécifié.Initializes a new instance of the FormatException class with a specified error message.

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.Initializes a new instance of the FormatException class with a specified error message and a reference to the inner exception that is the cause of this exception.

Propriétés

Data

Obtient une collection de paires clé/valeur qui fournissent des informations supplémentaires définies par l’utilisateur sur l’exception.Gets a collection of key/value pairs that provide additional user-defined information about the exception.

(Hérité de Exception)
HelpLink

Obtient ou définit un lien vers le fichier d'aide associé à cette exception.Gets or sets a link to the help file associated with this exception.

(Hérité de Exception)
HResult

Obtient ou définit HRESULT, valeur numérique codée qui est assignée à une exception spécifique.Gets or sets HRESULT, a coded numerical value that is assigned to a specific exception.

(Hérité de Exception)
InnerException

Obtient l'instance Exception qui a provoqué l'exception actuelle.Gets the Exception instance that caused the current exception.

(Hérité de Exception)
Message

Obtient un message qui décrit l'exception actuelle.Gets a message that describes the current exception.

(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.Gets or sets the name of the application or the object that causes the error.

(Hérité de Exception)
StackTrace

Obtient une représentation sous forme de chaîne des frames immédiats sur la pile des appels.Gets a string representation of the immediate frames on the call stack.

(Hérité de Exception)
TargetSite

Obtient la méthode qui lève l'exception actuelle.Gets the method that throws the current exception.

(Hérité de Exception)

Méthodes

Equals(Object)

Détermine si l'objet spécifié est égal à l'objet actuel.Determines whether the specified object is equal to the current object.

(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.When overridden in a derived class, returns the Exception that is the root cause of one or more subsequent exceptions.

(Hérité de Exception)
GetHashCode()

Sert de fonction de hachage par défaut.Serves as the default hash function.

(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.When overridden in a derived class, sets the SerializationInfo with information about the exception.

(Hérité de Exception)
GetType()

Obtient le type au moment de l'exécution de l'instance actuelle.Gets the runtime type of the current instance.

(Hérité de Exception)
MemberwiseClone()

Crée une copie superficielle du Object actuel.Creates a shallow copy of the current Object.

(Hérité de Object)
ToString()

Crée et retourne une chaîne représentant l'exception actuelle.Creates and returns a string representation of the current exception.

(Hérité de Exception)

Événements

SerializeObjectState

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.Occurs when an exception is serialized to create an exception state object that contains serialized data about the exception.

(Hérité de Exception)

S’applique à

Voir aussi