FormatException FormatException FormatException FormatException Class

Definição

A exceção que é lançada quando o formato de um argumento é inválido ou quando uma cadeia de caracteres de formato de composição não está bem formada.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
Herança
Derivado
Atributos

Comentários

Uma FormatException exceção pode ser lançada por um dos seguintes motivos:A FormatException exception can be thrown for one of the following reasons:

  • Em uma chamada para um método que converte uma cadeia de caracteres em algum outro tipo de dados, a cadeia de caracteres não está de acordo com o padrão necessário.In a call to a method that converts a string to some other data type, the string doesn't conform to the required pattern. Isso normalmente ocorre ao chamar alguns métodos da Convert classe e os Parse métodos e ParseExact de alguns tipos.This typically occurs when calling some methods of the Convert class and the Parse and ParseExact methods of some types.

    Na maioria dos casos, especialmente se a cadeia de caracteres que você está convertendo for inserida por um usuário ou lida de um arquivo try/catch , você deverá usar FormatException um bloco e manipular a exceção se a conversão não for bem-sucedida.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. Você também pode substituir a chamada para o método de conversão por uma chamada para TryParse um TryParseExact método ou, se existir um.You can also replace the call to the conversion method with a call to a TryParse or TryParseExact method, if one exists. No entanto FormatException , uma exceção que é lançada quando você está tentando analisar uma cadeia de caracteres predefinida ou embutida em código indica um erro 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. Nesse caso, você deve corrigir o erro em vez de tratar a exceção.In this case, you should correct the error rather than handle the exception.

    A conversão de uma cadeia de caracteres para os seguintes tipos System no namespace pode gerar FormatException uma exceção:The conversion of a string to the following types in the System namespace can throw a FormatException exception:

    • Boolean.Boolean. Os Boolean.Parse(String) métodos Convert.ToBoolean(String) e exigem que a cadeia de caracteres seja convertida para ser "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". Qualquer outro valor gera uma FormatException exceção.Any other value throws a FormatException exception.

    • DateTime e DateTimeOffset.DateTime and DateTimeOffset. Todos os dados de data e hora são interpretados com base nas convenções de formatação de uma cultura específica: ou seja, a cultura de thread atual (ou, em alguns casos, a cultura de domínio do aplicativo atual), a cultura invariável ou uma cultura 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. Quando você chama os DateTime.ParseExact(String, String, IFormatProvider, DateTimeStyles) métodos DateTimeOffset.ParseExact(String, String[], IFormatProvider, DateTimeStyles) e, os dados de data e hora também devem estar em conformidade exatamente com um padrão especificado por uma ou mais cadeias de caracteres de formato padrão ou cadeias de caracteres de formato personalizado que são fornecidas como argumentos no chamada de 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. Se ele não estiver em conformidade com um padrão específico de cultura esperado FormatException , uma exceção será lançada.If it doesn't conform to an expected culture-specific pattern, a FormatException exception is thrown. Isso significa que os dados de data e hora salvos em um formato específico de cultura em um sistema podem não ser analisados com êxito em outro 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 obter mais informações sobre como analisar datas e horas, consulte Analisando cadeias de caracteres de data e hora e a documentação do método que gerou a exceção.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. A representação de cadeia de caracteres de um GUID deve consistir em 32 dígitos hexadecimais (0-F) e deve estar em um dos cinco formatos de Guid.ToString saída pelo 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 obter mais informações, consulte o método Guid.Parse.For more information, see the Guid.Parse method.

    • Tipos numéricos, incluindo todos os inteiros assinados, inteiros não assinados e tipos de ponto flutuante.Numeric types, including all signed integers, unsigned integers, and floating-point types. A cadeia de caracteres a ser analisada deve consistir nos dígitos latinos 0-9.The string to be parsed must consist of the Latin digits 0-9. Um sinal positivo ou negativo, separador decimal, separadores de grupo e símbolo de moeda também podem ser permitidos.A positive or negative sign, decimal separator, group separators, and currency symbol may also be permitted. Tentar analisar uma cadeia de caracteres que contém qualquer outro caractere sempre gera FormatException uma exceção.Trying to parse a string that contains any other character always throws a FormatException exception.

      Todas as cadeias de caracteres numéricas são interpretadas com base nas convenções de formatação de uma cultura específica: ou seja, a cultura de thread atual (ou, em alguns casos, a cultura de domínio do aplicativo atual), a cultura invariável ou uma cultura 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, uma cadeia de caracteres numérica que é analisada usando as convenções de uma cultura pode falhar ao usar as convenções de outra.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 obter mais informações sobre como analisar cadeias de caracteres numéricas, consulte Analisando cadeias de caracteres numéricas e a documentação do método específico que gerou a exceção.For more information about parsing numeric strings, see Parsing Numeric Strings and the documentation for the specific method that threw the exception.

    • Intervalos de tempo.Time intervals. A cadeia de caracteres a ser analisada deve estar no formato fixo de não diferenciação de cultura ou em um formato sensível à cultura definido pela cultura de thread atual (ou, em alguns casos, a cultura de domínio do aplicativo atual), a cultura invariável ou uma cultura 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. Se a cadeia de caracteres não estiver em um formato apropriado, ou se, no mínimo, os componentes dias, horas e minutos do intervalo de tempo não estiverem presentes, o método de análise FormatException lançará uma exceção.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 obter mais informações, consulte a documentação para TimeSpan o método de análise que gerou a exceção.For more information, see the documentation for the TimeSpan parsing method that threw the exception.

  • Um tipo implementa a IFormattable interface, que dá suporte a cadeias de caracteres de formato que definem como um objeto é convertido em sua representação de cadeia de caracteres e uma cadeia de caracteres de formato inválida é usada.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. Isso é mais comum em uma operação de formatação.This is most common in a formatting operation. No exemplo a seguir, a cadeia de caracteres de formato padrão "Q" é usada em uma cadeia de caracteres de formato composto para formatar um número.In the following example, the "Q" standard format string is used in a composite format string to format a number. No entanto, "Q" não é uma cadeia de caracteres de formato padrãoválida.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()
    

    Essa exceção resulta de um erro de codificação.This exception results from a coding error. Para corrigir o erro, remova a cadeia de caracteres de formato ou substitua uma válida.To correct the error, either remove the format string or substitute a valid one. O exemplo a seguir corrige o erro substituindo a cadeia de caracteres de formato inválida pela cadeia de caracteres de formato "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.
    

    Uma FormatException exceção também pode ser lançada por meio de métodos de análise, DateTime.ParseExact como Guid.ParseExacte, que exigem que a cadeia de caracteres seja analisada para estar de acordo com o padrão especificado por uma cadeia de caracteres 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. No exemplo a seguir, espera-se que a representação de cadeia de caracteres de um GUID esteja em conformidade com o padrão especificado pela cadeia de caracteres de formato padrão "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. No entanto Guid , a implementação da IFormattable estrutura do não oferece suporte à cadeia de caracteres 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()
    

    Essa exceção também resulta de um erro de codificação.This exception also results from a coding error. Para corrigi-lo, chame um método de análise que não exija um formato preciso, como DateTime.Parse ou Guid.Parse, ou substitua uma cadeia de caracteres de formato válida.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. O exemplo a seguir corrige o erro chamando o 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
    
  • Um ou mais dos índices dos itens de formato em uma cadeia de caracteres de formato composto é maior do que os índices dos itens na lista de objetos ou na matriz de parâmetros.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. No exemplo a seguir, o maior índice de um item de formato na cadeia de caracteres de formato é 3.In the following example, the largest index of a format item in the format string is 3. Como os índices de itens na lista de objetos são baseados em zero, essa cadeia de caracteres de formato exigiria que a lista de objetos tenha quatro itens.Because the indexes of items in the object list are zero-based, this format string would require the object list to have four items. Em vez disso, ele tem apenas dattrês temp,, scalee, portanto, o código resulta FormatException em uma exceção em tempo de execução:.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()
    

    Nesse caso, a FormatException exceção é um resultado do erro do desenvolvedor.In this case, the FormatException exception is a result of developer error. Ele deve ser corrigido em vez de ser manipulado em um try/catch bloco, certificando-se de que cada item na lista de objetos corresponde ao índice de um item 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 corrigir este exemplo, altere o índice do segundo item de formato para referir- dat se à variável e decrementar o índice de cada item de formato subsequente em um.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
    
  • A cadeia de caracteres de formato composto não está bem formada.The composite format string isn't well-formed. Quando isso acontece, a FormatException exceção sempre é um resultado do erro do desenvolvedor.When this happens, the FormatException exception is always a result of developer error. Ele deve ser corrigido em vez de ser tratado try/catch em um bloco.It should be corrected rather than handled in a try/catch block.

    A tentativa de incluir chaves literais em uma cadeia de caracteres, como o exemplo a seguir, gerará a exceção.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)
    

    A técnica recomendada para incluir chaves literais em uma cadeia de caracteres de formato composto é incluí-las na lista de objetos e usar itens de formato para inseri-las na cadeia de caracteres 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 exemplo, você pode modificar a cadeia de caracteres de formato composto anterior, conforme mostrado aqui.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)
    

    A exceção também será gerada se a cadeia de caracteres de formato contiver um tipográfico.The exception is also thrown if your format string contains a typo. A chamada a seguir para String.Format o método omite uma chave de fechamento e emparelha uma chave de abertura com um colchete de fechamento.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 corrigir o erro, certifique-se de que todas as chaves de abertura e fechamento correspondem.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)
    
  • Você forneceu a lista de objetos em um método de formatação composta como uma matriz de parâmetros com rigidez FormatException de tipos e a exceção indica que o índice de um ou mais itens de formato excede o número de argumentos na 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. Isso ocorre porque não existe nenhuma conversão explícita entre os tipos de matriz, então o compilador trata a matriz como um único argumento, e não como uma 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 exemplo, a chamada a seguir para Console.WriteLine(String, Object[]) o método gera FormatException uma exceção, embora o índice mais alto dos itens de formato seja 3, e a matriz de Int32 parâmetros do tipo tenha quatro 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()
    

    Em vez de manipular essa exceção, você deve eliminar sua causa.Instead of handling this exception, you should eliminate its cause. Como nem Visual Basic nem C# pode converter uma matriz de inteiros em uma matriz de objeto, você mesmo precisa executar a conversão antes de chamar o método de formatação composto.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. O exemplo a seguir fornece uma implementação.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
    

FormatExceptionusa o HRESULT COR_E_FORMAT, que tem o valor 0x80131537.FormatException uses the HRESULT COR_E_FORMAT, which has the value 0x80131537.

A FormatException classe deriva de Exception e não adiciona membros exclusivos.The FormatException class derives from Exception and adds no unique members. Para obter uma lista de valores de propriedade inicial para uma instância do FormatException, consulte o FormatException construtores.For a list of initial property values for an instance of FormatException, see the FormatException constructors.

Construtores

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

Inicializa uma nova instância da classe FormatException.Initializes a new instance of the FormatException class.

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

Inicializa uma nova instância da classe FormatException com dados serializados.Initializes a new instance of the FormatException class with serialized data.

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

Inicializa uma nova instância da classe FormatException com uma mensagem de erro especificada.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 uma nova instância da classe FormatException com uma mensagem de erro especificada e uma referência à exceção interna que é a causa da exceção.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.

Propriedades

Data Data Data Data

Obtém uma coleção de pares de chave/valor que fornecem informações adicionais definidas pelo usuário sobre a exceção.Gets a collection of key/value pairs that provide additional user-defined information about the exception.

(Inherited from Exception)
HelpLink HelpLink HelpLink HelpLink

Obtém ou define um link para o arquivo de ajuda associado a essa exceção.Gets or sets a link to the help file associated with this exception.

(Inherited from Exception)
HResult HResult HResult HResult

Obtém ou define HRESULT, um valor numérico codificado que é atribuído a uma exceção específica.Gets or sets HRESULT, a coded numerical value that is assigned to a specific exception.

(Inherited from Exception)
InnerException InnerException InnerException InnerException

Obtém a instância Exception que causou a exceção atual.Gets the Exception instance that caused the current exception.

(Inherited from Exception)
Message Message Message Message

Obtém uma mensagem que descreve a exceção atual.Gets a message that describes the current exception.

(Inherited from Exception)
Source Source Source Source

Obtém ou define o nome do aplicativo ou objeto que causa o erro.Gets or sets the name of the application or the object that causes the error.

(Inherited from Exception)
StackTrace StackTrace StackTrace StackTrace

Obtém uma representação de cadeia de caracteres de quadros imediatos na pilha de chamadas.Gets a string representation of the immediate frames on the call stack.

(Inherited from Exception)
TargetSite TargetSite TargetSite TargetSite

Obtém o método que gerou a exceção atual.Gets the method that throws the current exception.

(Inherited from Exception)

Métodos

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

Determina se o objeto especificado é igual ao objeto atual.Determines whether the specified object is equal to the current object.

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

Quando substituído em uma classe derivada, retorna a Exception que é a causa raiz de uma ou mais exceções subsequentes.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()

Serve como a função de hash padrão.Serves as the default hash function.

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

Quando substituído em uma classe derivada, define o SerializationInfo com informações sobre a exceção.When overridden in a derived class, sets the SerializationInfo with information about the exception.

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

Obtém o tipo de tempo de execução da instância atual.Gets the runtime type of the current instance.

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

Cria uma cópia superficial do Object atual.Creates a shallow copy of the current Object.

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

Cria e retorna uma representação de cadeia de caracteres da exceção atual.Creates and returns a string representation of the current exception.

(Inherited from Exception)

Eventos

SerializeObjectState SerializeObjectState SerializeObjectState SerializeObjectState

Ocorre quando uma exceção é serializada para criar um objeto de estado de exceção que contém dados serializados sobre a exceção.Occurs when an exception is serialized to create an exception state object that contains serialized data about the exception.

(Inherited from Exception)

Aplica-se a

Veja também