FormatException Classe

Definição

public ref class FormatException : Exception

public ref class FormatException : SystemException

public class FormatException : Exception

public class FormatException : SystemException

[System.Serializable]
public class FormatException : SystemException

[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public class FormatException : SystemException

type FormatException = class
    inherit Exception

type FormatException = class
    inherit SystemException

[<System.Serializable>]
type FormatException = class
    inherit SystemException

[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type FormatException = class
    inherit SystemException

Public Class FormatException
Inherits Exception

Public Class FormatException
Inherits SystemException

Herança

Object

Exception

FormatException

Herança

Object

Exception

SystemException

FormatException

Derivado

System.IO.FileFormatException

System.Net.CookieException

System.Reflection.CustomAttributeFormatException

System.UriFormatException

Atributos

SerializableAttribute ComVisibleAttribute

Comentários

Uma FormatException exceção pode ser gerada por um dos seguintes motivos:

• 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á em conformidade com o padrão necessário. Isso normalmente ocorre ao chamar alguns métodos da Convert classe e os Parse métodos e ParseExact de alguns tipos.

  Na maioria dos casos, especialmente se a cadeia de caracteres que você está convertendo for entrada por um usuário ou leitura de um arquivo, você deverá usar um try/catch bloco (try/with em F#) e manipular a FormatException exceção se a conversão não for bem-sucedida. Você também pode substituir a chamada para o método de conversão por uma chamada para um TryParse método ou TryParseExact , se houver. No entanto, uma FormatException exceção gerada quando você está tentando analisar uma cadeia de caracteres predefinida ou embutida em código indica um erro de programa. Nesse caso, você deve corrigir o erro em vez de manipular a exceção.

  A conversão de uma cadeia de caracteres para os seguintes tipos no System namespace pode gerar uma FormatException exceção:

  • Boolean. Os Boolean.Parse(String) métodos e Convert.ToBoolean(String) exigem que a cadeia de caracteres seja convertida como "True", "true", "False" ou "false". Qualquer outro valor gera uma FormatException exceção.

  • DateTime e DateTimeOffset. Todos os dados de data e hora são interpretados com base nas convenções de formatação de uma cultura específica: a cultura atual (ou, em alguns casos, a cultura de domínio do aplicativo atual), a cultura invariável ou uma cultura especificada. Quando você chama os métodos e DateTimeOffset.ParseExact(String, String[], IFormatProvider, DateTimeStyles) , os DateTime.ParseExact(String, String, IFormatProvider, DateTimeStyles) 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 na chamada de método. Se ele não estiver em conformidade com um padrão específico de cultura esperado, uma FormatException exceção será gerada. 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.

    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.

  • 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 saída pelo Guid.ToString método . Para obter mais informações, consulte o método Guid.Parse.

  • Tipos numéricos, incluindo todos os inteiros com sinal, inteiros sem sinal e tipos de ponto flutuante. A cadeia de caracteres a ser analisada deve consistir nos dígitos latinos 0-9. Um sinal positivo ou negativo, separador decimal, separadores de grupo e símbolo de moeda também podem ser permitidos. Tentar analisar uma cadeia de caracteres que contém qualquer outro caractere sempre gera uma FormatException exceção.

    Todas as cadeias de caracteres numéricas são interpretadas com base nas convenções de formatação de uma cultura específica: a cultura atual, a cultura invariável ou uma cultura especificada. 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.

    Para obter mais informações sobre como analisar cadeias de caracteres numéricas, consulte Análise de cadeias de caracteres numéricas e a documentação do método específico que gerou a exceção.

  • Intervalos de tempo. A cadeia de caracteres a ser analisada deve estar no formato fixo que não diferencia cultura ou em um formato sensível à cultura definido pela cultura atual, pela cultura invariável ou por uma cultura especificada. Se a cadeia de caracteres não estiver em um formato apropriado ou se, no mínimo, os componentes de dias, horas e minutos do intervalo de tempo não estiverem presentes, o método de análise gerará uma FormatException exceção. Para obter mais informações, consulte a documentação do TimeSpan método de análise que gerou a exceção.

• Um tipo implementa a interface , que dá suporte a IFormattable 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. Isso é mais comum em uma operação de formatação. 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. No entanto, "Q" não é uma cadeia de caracteres de formato padrão válida.

  using System;
  
  public class Example
  {
     public static void Main()
     {
        decimal price = 169.32m;
        Console.WriteLine("The cost is {0:Q2}.", price);
     }
  }
  // The example displays the following output:
  //    Unhandled Exception: System.FormatException: Format specifier was invalid.
  //       at System.Number.FormatDecimal(Decimal value, String format, NumberFormatInfo info)
  //       at System.Decimal.ToString(String format, IFormatProvider provider)
  //       at System.Text.StringBuilder.AppendFormat(IFormatProvider provider, String format, Object[] args)
  //       at System.IO.TextWriter.WriteLine(String format, Object arg0)
  //       at System.IO.TextWriter.SyncTextWriter.WriteLine(String format, Object arg0)
  //       at Example.Main()
  

  let price = 169.32m
  printfn $"The cost is {price:Q2}."
  // The example displays the following output:
  //    Unhandled Exception: System.FormatException: Format specifier was invalid.
  //       at System.Number.NumberToString(ValueStringBuilder& sb, NumberBuffer& number, Char format, Int32 nMaxDigits, NumberFormatInfo info)
  //       at System.Number.TryFormatDecimal(Decimal value, ReadOnlySpan`1 format, NumberFormatInfo info, Span`1 destination, Int32& charsWritten)
  //       at System.Decimal.TryFormat(Span`1 destination, Int32& charsWritten, ReadOnlySpan`1 format, IFormatProvider provider)
  //       at System.Text.ValueStringBuilder.AppendFormatHelper(IFormatProvider provider, String format, ParamsArray args)
  //       at System.String.FormatHelper(IFormatProvider provider, String format, ParamsArray args)
  //       at Microsoft.FSharp.Core.PrintfImpl.InterpolandToString@917.Invoke(Object vobj)
  //       at Microsoft.FSharp.Core.PrintfImpl.PrintfEnv`3.RunSteps(Object[] args, Type[] argTys, Step[] steps)
  //       at Microsoft.FSharp.Core.PrintfModule.gprintf[a,TState,TResidue,TResult,TPrinter](FSharpFunc`2 envf, PrintfFormat`4 format)
  //       at <StartupCode$fs>.$Example.main@()
  

  Module Example
     Public Sub Main()
        Dim price As Decimal = 169.32d
        Console.WriteLine("The cost is {0:Q2}.", price)
     End Sub
  End Module
  ' The example displays the following output:
  '    Unhandled Exception: System.FormatException: Format specifier was invalid.
  '       at System.Number.FormatDecimal(Decimal value, String format, NumberFormatInfo info)
  '       at System.Decimal.ToString(String format, IFormatProvider provider)
  '       at System.Text.StringBuilder.AppendFormat(IFormatProvider provider, String format, Object[] args)
  '       at System.IO.TextWriter.WriteLine(String format, Object arg0)
  '       at System.IO.TextWriter.SyncTextWriter.WriteLine(String format, Object arg0)
  '       at Example.Main()
  

  Essa exceção resulta de um erro de codificação. Para corrigir o erro, remova a cadeia de caracteres de formato ou substitua uma válida. O exemplo a seguir corrige o erro substituindo a cadeia de caracteres de formato inválida pela cadeia de caracteres de formato "C" (moeda).

  using System;
  
  public class Example
  {
     public static void Main()
     {
        decimal price = 169.32m;
        Console.WriteLine("The cost is {0:C2}.", price);
     }
  }
  // The example displays the following output:
  //    The cost is $169.32.
  

  let price = 169.32m
  printfn $"The cost is {price:C2}."
  // The example displays the following output:
  //    The cost is $169.32.
  

  Module Example
     Public Sub Main()
        Dim price As Decimal = 169.32d
        Console.WriteLine("The cost is {0:C2}.", price)
     End Sub
  End Module
  ' The example displays the following output:
  '   The cost is $169.32.
  

  Uma FormatException exceção também pode ser gerada por métodos de análise, como DateTime.ParseExact e Guid.ParseExact, que exigem que a cadeia de caracteres seja analisada para estar em conformidade exatamente com o padrão especificado por uma cadeia de caracteres de formato. 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". No entanto, a Guid implementação da estrutura de não dá suporte à cadeia de caracteres de IFormattable formato "G".

  using System;
  
  public class Example
  {
     public static void Main()
     {
        string guidString = "ba748d5c-ae5f-4cca-84e5-1ac5291c38cb";
        Console.WriteLine(Guid.ParseExact(guidString, "G"));
     }
  }
  // The example displays the following output:
  //    Unhandled Exception: System.FormatException:
  //       Format String can be only "D", "d", "N", "n", "P", "p", "B", "b", "X" or "x".
  //       at System.Guid.ParseExact(String input, String format)
  //       at Example.Main()
  

  open System
  
  let guidString = "ba748d5c-ae5f-4cca-84e5-1ac5291c38cb"
  printfn $"""{Guid.ParseExact(guidString, "G")}"""
  // The example displays the following output:
  //    Unhandled Exception: System.FormatException:
  //       Format String can be only "D", "d", "N", "n", "P", "p", "B", "b", "X" or "x".
  //       at System.Guid.ParseExact(String input, String format)
  //       at <StartupCode$fs>.$Example.main@()
  

  Module Example
     Public Sub Main()
        Dim guidString As String = "ba748d5c-ae5f-4cca-84e5-1ac5291c38cb"
        Console.WriteLine(Guid.ParseExact(guidString, "G"))
     End Sub
  End Module
  ' The example displays the following output:
  '    Unhandled Exception: System.FormatException: 
  '       Format String can be only "D", "d", "N", "n", "P", "p", "B", "b", "X" or "x".
  '       at System.Guid.ParseExact(String input, String format)
  '       at Example.Main()
  

  Essa exceção também resulta de um erro de codificação. 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. O exemplo a seguir corrige o erro chamando o Guid.Parse método .

  using System;
  
  public class Example
  {
     public static void Main()
     {
        string guidString = "ba748d5c-ae5f-4cca-84e5-1ac5291c38cb";
        Console.WriteLine(Guid.Parse(guidString));
     }
  }
  // The example displays the following output:
  //    ba748d5c-ae5f-4cca-84e5-1ac5291c38cb
  

  open System
  
  let guidString = "ba748d5c-ae5f-4cca-84e5-1ac5291c38cb"
  printfn $"{Guid.Parse guidString}"
  // The example displays the following output:
  //    ba748d5c-ae5f-4cca-84e5-1ac5291c38cb
  

  Module Example
     Public Sub Main()
        Dim guidString As String = "ba748d5c-ae5f-4cca-84e5-1ac5291c38cb"
        Console.WriteLine(Guid.Parse(guidString))
     End Sub
  End Module
  ' The example displays the following output:
  '   ba748d5c-ae5f-4cca-84e5-1ac5291c38cb
  

• Um ou mais dos índices dos itens de formato em uma cadeia de caracteres de formato composto é maior que os índices dos itens na lista de objetos ou na matriz de parâmetros. No exemplo a seguir, o maior índice de um item de formato na cadeia de caracteres de formato é 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 tivesse quatro itens. Em vez disso, ele tem apenas três, dat, tempe scale, portanto, o código resulta em uma FormatException exceção em tempo de execução:.

  using System;
  
  public class Example
  {
     public enum TemperatureScale
     { Celsius, Fahrenheit, Kelvin }
  
     public static void Main()
     {
        String info = GetCurrentTemperature();
        Console.WriteLine(info);
     }
  
     private static String GetCurrentTemperature()
     {
        DateTime dat = DateTime.Now;
        Decimal temp = 20.6m;
        TemperatureScale scale = TemperatureScale.Celsius;
        String result;
  
        result = String.Format("At {0:t} on {1:D}, the temperature is {2:F1} {3:G}",
                               dat, temp, scale);
        return result;
     }
  }
  // The example displays output like the following:
  //    Unhandled Exception: System.FormatException: Format specifier was invalid.
  //       at System.Number.FormatDecimal(Decimal value, String format, NumberFormatInfo info)
  //       at System.Decimal.ToString(String format, IFormatProvider provider)
  //       at System.Text.StringBuilder.AppendFormat(IFormatProvider provider, String format, Object[] args)
  //       at System.String.Format(IFormatProvider provider, String format, Object[] args)
  //       at Example.Main()
  

  open System
  
  type TemperatureScale =
      | Celsius = 0
      | Fahrenheit = 1
      | Kelvin = 2
  
  let getCurrentTemperature () =
      let dat = DateTime.Now
      let temp = 20.6m
      let scale = TemperatureScale.Celsius
      String.Format("At {0:t} on {1:D}, the temperature is {2:F1} {3:G}", dat, temp, scale)
  
  getCurrentTemperature ()
  |> printfn "%s"
  
  // The example displays output like the following:
  //    Unhandled Exception: System.FormatException: Format specifier was invalid.
  //       at System.Number.NumberToString(ValueStringBuilder& sb, NumberBuffer& number, Char format, Int32 nMaxDigits, NumberFormatInfo info)   
  //       at System.Number.TryFormatDecimal(Decimal value, ReadOnlySpan`1 format, NumberFormatInfo info, Span`1 destination, Int32& charsWritten)
  //       at System.Decimal.TryFormat(Span`1 destination, Int32& charsWritten, ReadOnlySpan`1 format, IFormatProvider provider)       
  //       at System.Text.ValueStringBuilder.AppendFormatHelper(IFormatProvider provider, String format, ParamsArray args)
  //       at System.String.FormatHelper(IFormatProvider provider, String format, ParamsArray args)
  //       at System.String.Format(String format, Object arg0, Object arg1, Object arg2)
  //       at Example.getCurrentTemperature()
  //       at <StartupCode$fs>.$Example.main@()
  

  Module Example
     Public Enum TemperatureScale As Integer
        Celsius
        Fahrenheit
        Kelvin
     End Enum
  
     Public Sub Main()
        Dim info As String = GetCurrentTemperature()
        Console.WriteLine(info)
     End Sub
  
     Private Function GetCurrentTemperature() As String
        Dim dat As Date = Date.Now
        Dim temp As Decimal = 20.6d
        Dim scale As TemperatureScale = TemperatureScale.Celsius
        Dim result As String 
        
        result = String.Format("At {0:t} on {1:D}, the temperature is {2:F1} {3:G}",
                               dat, temp, scale)    
        Return result
     End Function
  End Module
  ' The example displays output like the following:
  '    Unhandled Exception: System.FormatException: Format specifier was invalid.
  '       at System.Number.FormatDecimal(Decimal value, String format, NumberFormatInfo info)
  '       at System.Decimal.ToString(String format, IFormatProvider provider)
  '       at System.Text.StringBuilder.AppendFormat(IFormatProvider provider, String format, Object[] args)
  '       at System.String.Format(IFormatProvider provider, String format, Object[] args)
  '       at Example.Main()
  

  Nesse caso, a FormatException exceção é resultado de um erro do desenvolvedor. Ele deve ser corrigido em vez de manipulado em um try/catch bloco, certificando-se de que cada item na lista de objetos corresponda ao índice de um item de formato. Para corrigir este exemplo, altere o índice do segundo item de formato para fazer referência à dat variável e decremente o índice de cada item de formato subsequente em um.

  using System;
  
  public class Example
  {
     public enum TemperatureScale
     { Celsius, Fahrenheit, Kelvin }
  
     public static void Main()
     {
        String info = GetCurrentTemperature();
        Console.WriteLine(info);
     }
  
     private static String GetCurrentTemperature()
     {
        DateTime dat = DateTime.Now;
        Decimal temp = 20.6m;
        TemperatureScale scale = TemperatureScale.Celsius;
        String result;
  
        result = String.Format("At {0:t} on {0:D}, the temperature is {1:F1} {2:G}",
                               dat, temp, scale);
        return result;
     }
  }
  // The example displays output like the following:
  //    At 10:40 AM on Wednesday, June 04, 2014, the temperature is 20.6 Celsius
  

  open System
  
  type TemperatureScale =
      | Celsius = 0
      | Fahrenheit = 1
      | Kelvin = 2
  
  let getCurrentTemperature () =
      let dat = DateTime.Now
      let temp = 20.6m
      let scale = TemperatureScale.Celsius
      String.Format("At {0:t} on {0:D}, the temperature is {1:F1} {2:G}", dat, temp, scale)
  
  getCurrentTemperature ()
  |> printfn "%s"
  
  // The example displays output like the following:
  //    At 10:40 AM on Wednesday, June 04, 2014, the temperature is 20.6 Celsius
  

  Module Example
     Public Enum TemperatureScale As Integer
        Celsius
        Fahrenheit
        Kelvin
     End Enum
  
     Public Sub Main()
        Dim info As String = GetCurrentTemperature()
        Console.WriteLine(info)
     End Sub
  
     Private Function GetCurrentTemperature() As String
        Dim dat As Date = Date.Now
        Dim temp As Decimal = 20.6d
        Dim scale As TemperatureScale = TemperatureScale.Celsius
        Dim result As String 
        
        result = String.Format("At {0:t} on {0:D}, the temperature is {1:F1} {2:G}",
                               dat, temp, scale)    
        Return result
     End Function
  End Module
  ' The example displays output like the following:
  '       At 10:40 AM on Wednesday, June 04, 2014, the temperature is 20.6 Celsius
  

• A cadeia de caracteres de formato composto não está bem formada. Quando isso acontece, a FormatException exceção é sempre resultado de um erro do desenvolvedor. Ele deve ser corrigido em vez de manipulado em um try/catch bloco.

  Tentar incluir chaves literais em uma cadeia de caracteres, como faz o exemplo a seguir, gerará a exceção.

  result = String.Format("The text has {0} '{' characters and {1} '}' characters.",
                         nOpen, nClose);
  

  let result = 
      String.Format("The text has {0} '{' characters and {1} '}' characters.", nOpen, nClose)
  

  result = String.Format("The text has {0} '{' characters and {1} '}' characters.",
                         nOpen, nClose)
  

  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. Por exemplo, você pode modificar a cadeia de caracteres de formato composto anterior, conforme mostrado aqui.

  string result;
  int nOpen = 1;
  int nClose = 2;
  result = String.Format("The text has {0} '{{' characters and {1} '}}' characters.",
                         nOpen, nClose);
  Console.WriteLine(result);
  

  let result =
      String.Format("The text has {0} '{{' characters and {1} '}}' characters.", nOpen, nClose)
  

  result = String.Format("The text has {0} '{{' characters and {1} '}}' characters.",
                         nOpen, nClose)
  

  A exceção também será gerada se a cadeia de caracteres de formato contiver um erro de digitação. A chamada a seguir para o String.Format método omite uma chave de fechamento e emparelha uma chave de abertura com um colchete de fechamento.

  int n1 = 10;
  int n2 = 20;
  String result = String.Format("{0 + {1] = {2}",
                                n1, n2, n1 + n2);
  

  let n1 = 10
  let n2 = 20
  String result = String.Format("{0 + {1] = {2}",
                              n1, n2, n1 + n2)
  

  Dim n1 As Integer = 10
  Dim n2 As Integer = 20
  Dim result As String = String.Format("{0 + {1] = {2}", 
                                       n1, n2, n1 + n2)
  

  Para corrigir o erro, verifique se todas as chaves de abertura e fechamento correspondem.

  String result = String.Format("{0} + {1} = {2}",
                                n1, n2, n1 + n2);
  

  let result = String.Format("{0} + {1} = {2}", n1, n2, n1 + n2)
  

  Dim result As String = String.Format("{0} + {1} = {2}", 
                                       n1, n2, n1 + n2)
  

• Você forneceu a lista de objetos em um método de formatação composta como uma matriz de parâmetros fortemente tipada e a FormatException exceção indica que o índice de um ou mais itens de formato excede o número de argumentos na lista de objetos. Isso ocorre porque não existe nenhuma conversão explícita entre tipos de matriz, portanto, em vez disso, o compilador trata a matriz como um único argumento em vez de como uma matriz de parâmetros. Por exemplo, a chamada a seguir para o Console.WriteLine(String, Object[]) método gera uma FormatException exceção, embora o índice mais alto dos itens de formato seja 3 e a matriz de parâmetros do tipo Int32 tenha quatro elementos.

  using System;
  using System.Collections.Generic;
  
  public class Example
  {
     public static void Main()
     {
        Random rnd = new Random();
        int[]  numbers = new int[4];
        int total = 0;
        for (int ctr = 0; ctr <= 2; ctr++) {
           int number = rnd.Next(1001);
           numbers[ctr] = number;
           total += number;
        }
        numbers[3] = total;
        Console.WriteLine("{0} + {1} + {2} = {3}", numbers);
     }
  }
  // The example displays the following output:
  //    Unhandled Exception:
  //    System.FormatException:
  //       Index (zero based) must be greater than or equal to zero and less than the size of the argument list.
  //       at System.Text.StringBuilder.AppendFormat(IFormatProvider provider, String format, Object[] args)
  //       at System.IO.TextWriter.WriteLine(String format, Object arg0)
  //       at System.IO.TextWriter.SyncTextWriter.WriteLine(String format, Object arg0)
  //       at Example.Main()
  

  open System
  
  let rnd = Random()
  let numbers = Array.zeroCreate<int> 4
  let mutable total = 0
  for i = 0 to 2 do
      let number = rnd.Next 1001
      numbers[i] <- number
      total <- total + number
  numbers[3] <- total
  Console.WriteLine("{0} + {1} + {2} = {3}", numbers)
  
  // The example displays the following output:
  //    Unhandled Exception:
  //    System.FormatException:
  //       Index (zero based) must be greater than or equal to zero and less than the size of the argument list.
  //       at System.Text.StringBuilder.AppendFormat(IFormatProvider provider, String format, Object[] args)
  //       at System.IO.TextWriter.WriteLine(String format, Object arg0)
  //       at System.IO.TextWriter.SyncTextWriter.WriteLine(String format, Object arg0)
  //       at <StartupCode$fs>.$Example.main@()
  

  Imports System.Collections.Generic
  
  Module Example
     Public Sub Main()
        Dim rnd As New Random()
        Dim numbers(3) As Integer
        Dim total As Integer = 0
        For ctr = 0 To 2
           Dim number As Integer = rnd.Next(1001)
           numbers(ctr) = number
           total += number
        Next
        numbers(3) = total
        Console.WriteLine("{0} + {1} + {2} = {3}", numbers)   
     End Sub
  End Module
  ' The example displays the following output:
  '    Unhandled Exception: 
  '    System.FormatException: 
  '       Index (zero based) must be greater than or equal to zero and less than the size of the argument list.
  '       at System.Text.StringBuilder.AppendFormat(IFormatProvider provider, String format, Object[] args)
  '       at System.IO.TextWriter.WriteLine(String format, Object arg0)
  '       at System.IO.TextWriter.SyncTextWriter.WriteLine(String format, Object arg0)
  '       at Example.Main()
  

  Em vez de lidar com essa exceção, você deve eliminar sua causa. Como nem o Visual Basic nem o C# podem converter uma matriz de inteiros em uma matriz de objetos, você precisa executar a conversão por conta própria antes de chamar o método de formatação composta. O exemplo a seguir fornece uma implementação.

  using System;
  using System.Collections.Generic;
  
  public class Example
  {
     public static void Main()
     {
        Random rnd = new Random();
        int[]  numbers = new int[4];
        int total = 0;
        for (int ctr = 0; ctr <= 2; ctr++) {
           int number = rnd.Next(1001);
           numbers[ctr] = number;
           total += number;
        }
        numbers[3] = total;
        object[] values = new object[numbers.Length];
        numbers.CopyTo(values, 0);
        Console.WriteLine("{0} + {1} + {2} = {3}", values);
     }
  }
  // The example displays output like the following:
  //        477 + 956 + 901 = 2334
  

  open System
  
  let rnd = Random()
  let numbers = Array.zeroCreate<int> 4
  let mutable total = 0
  for i = 0 to 2 do
      let number = rnd.Next 1001
      numbers[i] <- number
      total <- total + number
  numbers[3] <- total
  let values = Array.zeroCreate<obj> numbers.Length
  numbers.CopyTo(values, 0)
  Console.WriteLine("{0} + {1} + {2} = {3}", values)
  // The example displays output like the following:
  //        477 + 956 + 901 = 2334
  

  Imports System.Collections.Generic
  
  Module Example
     Public Sub Main()
        Dim rnd As New Random()
        Dim numbers(3) As Integer
        Dim total As Integer = 0
        For ctr = 0 To 2
           Dim number As Integer = rnd.Next(1001)
           numbers(ctr) = number
           total += number
        Next
        numbers(3) = total
        Dim values(numbers.Length - 1) As Object
        numbers.CopyTo(values, 0) 
        Console.WriteLine("{0} + {1} + {2} = {3}", values)   
     End Sub
  End Module
  ' The example displays output like the following:
  '       477 + 956 + 901 = 2334
  

FormatException usa a COR_E_FORMAT HRESULT, que tem o valor 0x80131537.

A FormatException classe deriva de Exception e não adiciona membros exclusivos. Para obter uma lista de valores de propriedade inicial para uma instância do FormatException, consulte o FormatException construtores.

Construtores

Propriedades

Métodos

Eventos

Aplica-se a

Confira também

• Exception
• Manipulando e lançando exceções