FormatException FormatException FormatException FormatException Class

Definición

Excepción que se produce cuando el formato de un argumento no es válido o cuando una cadena de formato compuesto no tiene el formato correcto.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
Herencia
Derivado
Atributos

Comentarios

Un FormatException se puede producir la excepción para uno de los siguientes motivos:A FormatException exception can be thrown for one of the following reasons:

  • En una llamada a un método que convierte una cadena en algún otro tipo de datos, la cadena no se ajusta al patrón requerido.In a call to a method that converts a string to some other data type, the string doesn't conform to the required pattern. Esto suele ocurrir cuando se llama a algunos métodos de la Convert clase y el Parse y ParseExact métodos de algunos tipos.This typically occurs when calling some methods of the Convert class and the Parse and ParseExact methods of some types.

    En la mayoría de los casos, especialmente si la cadena que se está convirtiendo es de entrada por un usuario o leer desde un archivo, debe usar un try/catch bloquear y controlar el FormatException excepción si la conversión se realiza correctamente.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. También puede reemplazar la llamada al método de conversión con una llamada a un TryParse o TryParseExact método, si existe alguno.You can also replace the call to the conversion method with a call to a TryParse or TryParseExact method, if one exists. Sin embargo, un FormatException excepción que se produce cuando se intenta analizar una cadena predefinida o codificado de forma rígida indica un error de programa.However, a FormatException exception that is thrown when you're trying to parse a predefined or hard-coded string indicates a program error. En este caso, se debe corregir el error en lugar de controlar la excepción.In this case, you should correct the error rather than handle the exception.

    La conversión de una cadena en los siguientes tipos en el System espacio de nombres puede producir un FormatException excepción:The conversion of a string to the following types in the System namespace can throw a FormatException exception:

    • Boolean.Boolean. El Boolean.Parse(String) y Convert.ToBoolean(String) métodos requieren la cadena que se pueden convertir para ser "True", "true", "False" o "false".The Boolean.Parse(String) and Convert.ToBoolean(String) methods require the string to be converted to be "True", "true", "False", or "false". Cualquier otro valor produce un FormatException excepción.Any other value throws a FormatException exception.

    • DateTime y DateTimeOffset.DateTime and DateTimeOffset. Todos los datos de fecha y hora se interpreta basándose en las convenciones de formato de una determinada referencia cultural: ya sea la actual referencia cultural del subproceso (o, en algunos casos, la referencia cultural actual dominio de aplicación), la referencia cultural invariable, o una referencia cultural especificada.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. Cuando se llama a la DateTime.ParseExact(String, String, IFormatProvider, DateTimeStyles) y DateTimeOffset.ParseExact(String, String[], IFormatProvider, DateTimeStyles) métodos, también deben cumplir los datos de fecha y hora exactamente a un patrón especificado por uno o varios cadenas de formato estándar o personalizado las cadenas de formato que se proporcionan como argumentos en la llamada al método.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 no cumple con un patrón esperado de referencia cultural específica, un FormatException es una excepción.If it doesn't conform to an expected culture-specific pattern, a FormatException exception is thrown. Esto significa que los datos de fecha y hora guardados en un formato específico de la referencia cultural en un sistema no pueden analizar correctamente en otro sistema.This means that date and time data saved in a culture-specific format on one system might not parse successfully on another system.

      Para obtener más información acerca de cómo analizar fechas y horas, vea analizar cadenas de fecha y hora y la documentación para el método que produjo la excepción.For more information about parsing dates and times, see Parsing Date and Time Strings and the documentation for the method that threw the exception.

    • GUIDs.GUIDs. Representación de cadena del GUID debe consistir en 32 dígitos hexadecimales (0-F) y debe estar en uno de la salida de cinco formatos mediante la Guid.ToString método.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. Para obtener más información, vea el método Guid.Parse.For more information, see the Guid.Parse method.

    • Tipos numéricos, incluidos todos los enteros de enteros sin signo y tipos de punto flotante.Numeric types, including all signed integers, unsigned integers, and floating-point types. La cadena que se va a analizar debe constar de los dígitos latinos 0-9.The string to be parsed must consist of the Latin digits 0-9. También se pueden permitir un signo positivo o negativo, separador de decimales, separadores de grupos y símbolo de moneda.A positive or negative sign, decimal separator, group separators, and currency symbol may also be permitted. Intenta analizar una cadena que contiene cualquier otro carácter siempre produce una FormatException excepción.Trying to parse a string that contains any other character always throws a FormatException exception.

      Todas las cadenas numéricas se interpretan según las convenciones de formato de una determinada referencia cultural: ya sea la actual referencia cultural del subproceso (o, en algunos casos, la referencia cultural actual dominio de aplicación), la referencia cultural invariable, o una referencia cultural especificada.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. Como resultado, una cadena numérica que se analiza mediante las convenciones de una referencia cultural puede producir un error cuando se usa las convenciones de otro.As a result, a numeric string that is parsed by using the conventions of one culture might fail when using the conventions of another.

      Para obtener más información acerca de cómo analizar cadenas numéricas, vea analizar cadenas numéricas y la documentación para el método específico que produjo la excepción.For more information about parsing numeric strings, see Parsing Numeric Strings and the documentation for the specific method that threw the exception.

    • Intervalos de tiempo.Time intervals. Debe ser la cadena que se analicen en formato cultural fijo o en un formato de la referencia cultural definida por la referencia cultural del subproceso actual (o, en algunos casos, la referencia cultural actual dominio de aplicación), la referencia cultural invariable, o una referencia cultural especificada.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 cadena no está en un formato adecuado, o si, en el mínimo, los días, horas, y los componentes de minutos del intervalo de tiempo no están presentes, el método de análisis produce un FormatException excepción.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. Para obtener más información, consulte la documentación para el TimeSpan al analizar el método que produjo la excepción.For more information, see the documentation for the TimeSpan parsing method that threw the exception.

  • Un tipo implementa la IFormattable interfaz, que es compatible con las cadenas de formato que definen cómo se convierte un objeto en su representación de cadena y se utiliza una cadena de formato no válido.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. Esto es muy habitual en una operación de formato.This is most common in a formatting operation. En el ejemplo siguiente, se utiliza la cadena de formato estándar "Q" en una cadena de formato compuesto para dar formato a un número.In the following example, the "Q" standard format string is used in a composite format string to format a number. Sin embargo, no es válido "Q" cadena de formato estándar.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()
    

    Esta excepción se origina un error de codificación.This exception results from a coding error. Para corregir el error, quite la cadena de formato o sustituir uno válido.To correct the error, either remove the format string or substitute a valid one. El ejemplo siguiente corrige el error si se reemplaza la cadena de formato no válido con la cadena de formato "C" (divisa).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.
    

    Un FormatException también se puede producir la excepción mediante el análisis de los métodos, como DateTime.ParseExact y Guid.ParseExact, que requieren la cadena que se puede analizar para que se ajuste exactamente con el modelo especificado por una cadena de formato.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. En el ejemplo siguiente, se espera que la representación de cadena de un GUID se ajustan al modelo especificado por la cadena de formato estándar "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. Sin embargo, el Guid implementación de la estructura de IFormattable no es compatible con la cadena de formato "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()
    

    Esta excepción también se produce desde un error de codificación.This exception also results from a coding error. Para corregirlo, llamar a un método de análisis que no requiere un formato preciso, tales como DateTime.Parse o Guid.Parse, o sustituir una cadena de formato válido.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. En el ejemplo siguiente se corrige el error mediante una llamada a la Guid.Parse método.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
    
  • Uno o varios de los índices de los elementos de formato en un cadena de formato compuesto es mayor que los índices de los elementos de la matriz de objetos de lista o un parámetro.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. En el ejemplo siguiente, el índice más grande de un elemento de formato de la cadena de formato es 3.In the following example, the largest index of a format item in the format string is 3. Dado que los índices de elementos en la lista de objetos son de base cero, esta cadena de formato requeriría la lista de objetos para tener cuatro elementos.Because the indexes of items in the object list are zero-based, this format string would require the object list to have four items. En su lugar, tiene solo tres dat, temp, y scale, por lo que el código produce un FormatException excepción en tiempo de ejecución:.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()
    

    En este caso, el FormatException excepción es el resultado de error de desarrollador.In this case, the FormatException exception is a result of developer error. Se debe corregir en lugar de controlar en un try/catch bloque porque nos aseguramos de que cada elemento de la lista de objetos se corresponde con el índice de un elemento de formato.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. Para corregir este ejemplo, cambie el índice del segundo elemento de formato para hacer referencia a la dat variable y disminuir el índice de cada elemento de formato posteriores por uno.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 cadena de formato compuesto no tiene el formato correcto.The composite format string isn't well-formed. Cuando esto sucede, el FormatException excepción siempre es el resultado de error de desarrollador.When this happens, the FormatException exception is always a result of developer error. Se debe corregir en lugar de controlar en un try/catch bloque.It should be corrected rather than handled in a try/catch block.

    Intentando incluye llaves literales en una cadena, como el siguiente ejemplo does, se producirá la excepción.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)
    

    Es la técnica recomendada para incluir las llaves literales en una cadena de formato compuesto incluirlos en la lista de objetos y usar elementos de formato para insertarlos en la cadena de resultado.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. Por ejemplo, puede modificar la cadena de formato compuesto anterior como se muestra aquí.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)
    

    La excepción también se produce si la cadena de formato contiene un error de escritura.The exception is also thrown if your format string contains a typo. La llamada siguiente a la String.Format método omite una llave de cierre y pares de una llave de apertura con un corchete de cierre.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)
    

    Para corregir el error, asegúrese de que se corresponden todos abriendo y las llaves de cierre.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)
    
  • Se ha proporcionado la lista de objetos en un método como una matriz de parámetro fuertemente tipado de formato compuesto y FormatException excepción indica que el índice de uno o más elementos de formato supera el número de argumentos en la lista de objetos.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. Esto ocurre porque existe ninguna conversión explícita entre los tipos de matriz, por lo tanto, que el compilador trata la matriz como un único argumento en lugar de una matriz de parámetros.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. Por ejemplo, la llamada siguiente a la Console.WriteLine(String, Object[]) método produce una FormatException excepción, aunque el índice más alto de los elementos de formato es 3 y la matriz de parámetros de tipo Int32 contiene cuatro elementos.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()
    

    En lugar de controlar esta excepción, debe eliminar su causa.Instead of handling this exception, you should eliminate its cause. Dado que Visual Basic ni C# puede convertir una matriz de enteros en una matriz de objetos, tendrá que realizar la conversión antes de llamar al método de formato compuesto.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. El ejemplo siguiente proporciona una implementación.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
    

FormatException utiliza HRESULT COR_E_FORMAT, que tiene el valor 0 x 80131537.FormatException uses the HRESULT COR_E_FORMAT, which has the value 0x80131537.

El FormatException clase se deriva de Exception y no se agrega ningún miembro único.The FormatException class derives from Exception and adds no unique members. Para obtener una lista de valores de propiedad iniciales de una instancia de FormatException, consulte el FormatException constructores.For a list of initial property values for an instance of FormatException, see the FormatException constructors.

Constructores

FormatException() FormatException() FormatException() FormatException()

Inicializa una nueva instancia de la clase FormatException.Initializes a new instance of the FormatException class.

FormatException(SerializationInfo, StreamingContext) FormatException(SerializationInfo, StreamingContext) FormatException(SerializationInfo, StreamingContext) FormatException(SerializationInfo, StreamingContext)

Inicializa una nueva instancia de la clase FormatException con datos serializados.Initializes a new instance of the FormatException class with serialized data.

FormatException(String) FormatException(String) FormatException(String) FormatException(String)

Inicializa una nueva instancia de la clase FormatException con el mensaje de error especificado.Initializes a new instance of the FormatException class with a specified error message.

FormatException(String, Exception) FormatException(String, Exception) FormatException(String, Exception) FormatException(String, Exception)

Inicializa una nueva instancia de la clase FormatException con el mensaje de error especificado y una referencia a la excepción interna que representa la causa de esta excepción.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.

Propiedades

Data Data Data Data

Obtiene una colección de pares clave-valor que proporcionan más información definida por el usuario sobre la excepción.Gets a collection of key/value pairs that provide additional user-defined information about the exception.

(Inherited from Exception)
HelpLink HelpLink HelpLink HelpLink

Obtiene o establece un vínculo al archivo de ayuda asociado a esta excepción.Gets or sets a link to the help file associated with this exception.

(Inherited from Exception)
HResult HResult HResult HResult

Obtiene o establece HRESULT, un valor numérico codificado que se asigna a una excepción específica.Gets or sets HRESULT, a coded numerical value that is assigned to a specific exception.

(Inherited from Exception)
InnerException InnerException InnerException InnerException

Obtiene la instancia Exception que produjo la excepción actual.Gets the Exception instance that caused the current exception.

(Inherited from Exception)
Message Message Message Message

Obtiene un mensaje que describe la excepción actual.Gets a message that describes the current exception.

(Inherited from Exception)
Source Source Source Source

Devuelve o establece el nombre de la aplicación o del objeto que generó el error.Gets or sets the name of the application or the object that causes the error.

(Inherited from Exception)
StackTrace StackTrace StackTrace StackTrace

Obtiene una representación de cadena de los marcos inmediatos en la pila de llamadas.Gets a string representation of the immediate frames on the call stack.

(Inherited from Exception)
TargetSite TargetSite TargetSite TargetSite

Obtiene el método que produjo la excepción actual.Gets the method that throws the current exception.

(Inherited from Exception)

Métodos

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Determina si el objeto especificado es igual al objeto actual.Determines whether the specified object is equal to the current object.

(Inherited from Object)
GetBaseException() GetBaseException() GetBaseException() GetBaseException()

Cuando se reemplaza en una clase derivada, devuelve la clase Exception que representa la causa principal de una o más excepciones posteriores.When overridden in a derived class, returns the Exception that is the root cause of one or more subsequent exceptions.

(Inherited from Exception)
GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Sirve como la función hash predeterminada.Serves as the default hash function.

(Inherited from Object)
GetObjectData(SerializationInfo, StreamingContext) GetObjectData(SerializationInfo, StreamingContext) GetObjectData(SerializationInfo, StreamingContext) GetObjectData(SerializationInfo, StreamingContext)

Cuando se reemplaza en una clase derivada, establece SerializationInfo con información sobre la excepción.When overridden in a derived class, sets the SerializationInfo with information about the exception.

(Inherited from Exception)
GetType() GetType() GetType() GetType()

Obtiene el tipo de tiempo de ejecución de la instancia actual.Gets the runtime type of the current instance.

(Inherited from Exception)
MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Crea una copia superficial del objeto Object actual.Creates a shallow copy of the current Object.

(Inherited from Object)
ToString() ToString() ToString() ToString()

Crea y devuelve una representación de cadena de la excepción actual.Creates and returns a string representation of the current exception.

(Inherited from Exception)

Eventos

SerializeObjectState SerializeObjectState SerializeObjectState SerializeObjectState

Ocurre cuando una excepción se serializa para crear un objeto de estado de excepción que contenga datos serializados sobre la excepción.Occurs when an exception is serialized to create an exception state object that contains serialized data about the exception.

(Inherited from Exception)

Se aplica a

Consulte también: