FormatException FormatException FormatException FormatException Class

Definizione

Eccezione generata quando il formato di un argomento non è valido oppure quando una stringa di formato composita non è corretta.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
Ereditarietà
Derivato
Attributi

Commenti

Oggetto FormatException eccezione può essere generata per uno dei motivi seguenti:A FormatException exception can be thrown for one of the following reasons:

  • In una chiamata a un metodo che converte una stringa in un altro tipo di dati, la stringa non sono conformi al criterio obbligatorio.In a call to a method that converts a string to some other data type, the string doesn't conform to the required pattern. Ciò si verifica in genere quando si chiamano alcuni metodi del Convert classe e il Parse e ParseExact metodi di alcuni tipi.This typically occurs when calling some methods of the Convert class and the Parse and ParseExact methods of some types.

    Nella maggior parte dei casi, in particolare se la stringa che si sta convertendo di input da un utente o viene letto da un file, è necessario utilizzare un try/catch bloccare e gestire il FormatException eccezione se la conversione ha esito negativo.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. È inoltre possibile sostituire la chiamata al metodo di conversione con una chiamata a un TryParse o TryParseExact metodo, se presente.You can also replace the call to the conversion method with a call to a TryParse or TryParseExact method, if one exists. Tuttavia, un FormatException eccezione generata quando si tenta di analizzare una stringa predefinita o impostate come hardcoded indica un errore del programma.However, a FormatException exception that is thrown when you're trying to parse a predefined or hard-coded string indicates a program error. In questo caso, è necessario correggere l'errore piuttosto che gestisce l'eccezione.In this case, you should correct the error rather than handle the exception.

    La conversione di una stringa per i tipi seguenti nel System dello spazio dei nomi può generare un FormatException eccezione:The conversion of a string to the following types in the System namespace can throw a FormatException exception:

    • Boolean.Boolean. Il Boolean.Parse(String) e Convert.ToBoolean(String) metodi richiedono la stringa da convertire per essere "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". Genera un'eccezione di qualsiasi altro valore un FormatException eccezione.Any other value throws a FormatException exception.

    • DateTime e DateTimeOffset.DateTime and DateTimeOffset. Tutti i dati di data e ora viene interpretato in base a convenzioni di formattazione di determinate impostazioni cultura: entrambi corrente impostazioni cultura del thread (o, in alcuni casi, le impostazioni cultura correnti dominio dell'applicazione), le impostazioni cultura invarianti, o impostazioni cultura specificate.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 si chiama il DateTime.ParseExact(String, String, IFormatProvider, DateTimeStyles) e DateTimeOffset.ParseExact(String, String[], IFormatProvider, DateTimeStyles) metodi, i dati di data e ora devono inoltre essere conforme esattamente a un criterio specificato da uno o più stringhe di formato standard o personalizzato stringhe di formato che vengono passati come argomenti nella chiamata al metodo.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 non è conforme a un modello di impostazioni cultura specifiche previsto, un FormatException viene generata un'eccezione.If it doesn't conform to an expected culture-specific pattern, a FormatException exception is thrown. Ciò significa che i dati di data e ora salvati in un formato specifico delle impostazioni cultura su un sistema potrebbero non vengono analizzate correttamente in un altro sistema.This means that date and time data saved in a culture-specific format on one system might not parse successfully on another system.

      Per ulteriori informazioni sull'analisi date e ore, vedere l'analisi di stringhe di data e ora e la documentazione per il metodo che ha generato l'eccezione.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. Rappresentazione di stringa del GUID deve essere costituito da 32 cifre esadecimali (0-F) e deve essere in uno all'output di cinque formati il Guid.ToString (metodo).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. Per altre informazioni, vedere il metodo Guid.Parse.For more information, see the Guid.Parse method.

    • Tipi numerici, inclusi tutti firmati interi, numeri interi senza segno e tipi a virgola mobile.Numeric types, including all signed integers, unsigned integers, and floating-point types. La stringa da analizzare deve contenere le cifre latine da 0 a 9.The string to be parsed must consist of the Latin digits 0-9. Potrebbe essere consentiti anche un segno positivo o negativo, il separatore decimale, i separatori di gruppi e simbolo di valuta.A positive or negative sign, decimal separator, group separators, and currency symbol may also be permitted. Tentativo di analizzare una stringa che contiene qualsiasi altro carattere sempre genera un FormatException eccezione.Trying to parse a string that contains any other character always throws a FormatException exception.

      Tutte le stringhe numeriche vengono interpretate in base alle convenzioni di formattazione di determinate impostazioni cultura: entrambi corrente impostazioni cultura del thread (o, in alcuni casi, le impostazioni cultura correnti dominio dell'applicazione), le impostazioni cultura invarianti, o impostazioni cultura specificate.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. Di conseguenza, una stringa numerica che viene analizzata tramite le convenzioni delle impostazioni cultura potrebbe non riuscire quando si usa le convenzioni di un altro.As a result, a numeric string that is parsed by using the conventions of one culture might fail when using the conventions of another.

      Per altre informazioni sull'analisi di stringhe numeriche, vedere l'analisi di stringhe numeriche e la documentazione per il metodo specifico che ha generato l'eccezione.For more information about parsing numeric strings, see Parsing Numeric Strings and the documentation for the specific method that threw the exception.

    • Intervalli di tempo.Time intervals. La stringa da analizzare deve essere in formato fisso distinzione delle impostazioni cultura o in un formato di distinzione delle impostazioni cultura definite dalle impostazioni cultura del thread corrente (o, in alcuni casi, le impostazioni cultura correnti dominio dell'applicazione), le impostazioni cultura invarianti, o impostazioni cultura specificate.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 la stringa non è in un formato appropriato o se il valore minimo, i giorni, ore, e non sono presenti componenti minuti dell'intervallo di tempo, il metodo di analisi genera un FormatException eccezione.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. Per altre informazioni, vedere la documentazione per il TimeSpan analisi del metodo che ha generato l'eccezione.For more information, see the documentation for the TimeSpan parsing method that threw the exception.

  • Un tipo implementa la IFormattable interfaccia, che supporta le stringhe di formato che definiscono come un oggetto viene convertito nella rappresentazione di stringa e viene utilizzata una stringa di formato non valido.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. Questo è più comune in un'operazione di formattazione.This is most common in a formatting operation. Nell'esempio seguente, la stringa di formato standard "Q" viene utilizzata in una stringa di formato composito per formattare un numero.In the following example, the "Q" standard format string is used in a composite format string to format a number. Tuttavia, non è valido "Q" stringa di formato standard.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()
    

    Questa eccezione comporta che da un errore di codifica.This exception results from a coding error. Per correggere l'errore, rimuovere la stringa di formato o sostituire uno valido.To correct the error, either remove the format string or substitute a valid one. Nell'esempio seguente corregge l'errore sostituendo la stringa di formato non valido con la stringa di formato "C" (valuta).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.
    

    Oggetto FormatException eccezione può essere generata anche dai metodi, ad esempio di analisi DateTime.ParseExact e Guid.ParseExact, che richiedono la stringa da analizzare per corrispondere esattamente al criterio specificato da una stringa di 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. Nell'esempio seguente, la rappresentazione di stringa di un GUID prevede sia conforme al criterio specificato dalla stringa di formato standard "G".In the following example, the string representation of a GUID is expected to conform to the pattern specified by the "G" standard format string. Tuttavia, il Guid implementazione della struttura di IFormattable non supporta la stringa di 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()
    

    Questa eccezione comporta che anche da un errore di codifica.This exception also results from a coding error. Per correggere l'errore, chiamare un metodo di analisi che non richiede un formato preciso, ad esempio DateTime.Parse o Guid.Parse, oppure sostituire con una stringa di formato valido.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. Nell'esempio seguente corregge l'errore chiamando il Guid.Parse (metodo).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 più degli indici degli elementi di formato in una stringa di formato composito è maggiore di indici degli elementi nella matrice di oggetti parametro o elenco.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. Nell'esempio seguente, l'indice più grande di un elemento di formato della stringa di formato è 3.In the following example, the largest index of a format item in the format string is 3. Poiché gli indici degli elementi nell'elenco di oggetti in base zero, questa stringa di formato richiederebbe l'elenco di oggetti per avere quattro elementi.Because the indexes of items in the object list are zero-based, this format string would require the object list to have four items. Ma ne contiene solo tre dat, temp, e scale, quindi il codice comporta un FormatException eccezione in fase di esecuzione:.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()
    

    In questo caso, il FormatException eccezione è il risultato di errore per gli sviluppatori.In this case, the FormatException exception is a result of developer error. Deve essere corretto anziché gestito in un try/catch blocco assicurandosi che ogni elemento nell'elenco di oggetti corrisponde all'indice di un elemento di 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. Per correggere questo esempio, modificare l'indice dell'elemento di formato secondo per fare riferimento al dat variabile dataready e decremento in forma dell'indice di ogni elemento di formato successive da 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 stringa di formato composto non è ben formata.The composite format string isn't well-formed. In questo caso, il FormatException eccezione è sempre un risultato di errore per gli sviluppatori.When this happens, the FormatException exception is always a result of developer error. Deve essere corretto anziché gestito in un try/catch blocco.It should be corrected rather than handled in a try/catch block.

    Il tentativo di inserire le parentesi graffe letterale in una stringa, come nell'esempio seguente viene, verrà generata l'eccezione.Trying to include literal braces in a string, as the following example does, will throw the exception.

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

    La tecnica consigliata per l'inclusione di valori letterali parentesi graffe in una stringa di formato composto è includerli nell'elenco di oggetti e usare gli elementi di formato per inserirli nella stringa di risultato.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. Ad esempio, è possibile modificare la stringa di formato composito precedente come illustrato di seguito.For example, you can modify the previous composite format string as shown here.

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

    L'eccezione viene generata anche se la stringa di formato contiene un errore di digitazione.The exception is also thrown if your format string contains a typo. La chiamata seguente al String.Format metodo omette una parentesi graffa di chiusura e coppie di parentesi graffa aperta con una parentesi di chiusura.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)
    

    Per correggere l'errore, assicurarsi che tutti apertura e chiusura delle parentesi graffe corrispondenti.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)
    
  • Sono stati forniti l'elenco di oggetti in un metodo come una matrice di parametri fortemente tipizzati, di formattazione composita e FormatException eccezione indica che l'indice di uno o più elementi di formato supera il numero di argomenti nell'elenco di oggetti.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. Ciò si verifica perché non esiste alcuna conversione esplicita tra i tipi di matrice, ma che il compilatore considera la matrice come un singolo argomento anziché come una matrice di parametri.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. Ad esempio, la chiamata seguente al Console.WriteLine(String, Object[]) metodo genera un FormatException eccezione, anche se l'indice più elevato di elementi di formato è 3 e la matrice di parametri di tipo Int32 dispone di quattro elementi.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()
    

    Invece di gestire questa eccezione, è consigliabile eliminare la causa.Instead of handling this exception, you should eliminate its cause. Poiché Visual Basic né C# può convertire una matrice di interi in una matrice di oggetti, è necessario eseguire la conversione prima di chiamare il metodo di formattazione composita.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. Nell'esempio seguente fornisce un'implementazione.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 Usa l'HRESULT COR_E_FORMAT con il valore 0x80131537.FormatException uses the HRESULT COR_E_FORMAT, which has the value 0x80131537.

Il FormatException deriva dalla classe Exception e viene aggiunto alcun membro univoco.The FormatException class derives from Exception and adds no unique members. Per un elenco di valori di proprietà iniziali per un'istanza di FormatException, vedere il FormatException costruttori.For a list of initial property values for an instance of FormatException, see the FormatException constructors.

Costruttori

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

Inizializza una nuova istanza della classe FormatException.Initializes a new instance of the FormatException class.

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

Inizializza una nuova istanza della classe FormatException con dati serializzati.Initializes a new instance of the FormatException class with serialized data.

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

Inizializza una nuova istanza della classe FormatException con un messaggio di errore specificato.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)

Inizializza una nuova istanza della classe FormatException con un messaggio di errore specificato e un riferimento all'eccezione interna che è la causa dell'eccezione corrente.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.

Proprietà

Data Data Data Data

Ottiene una raccolta di coppie chiave-valore che fornisce informazioni aggiuntive definite dall'utente relative all'eccezione.Gets a collection of key/value pairs that provide additional user-defined information about the exception.

(Inherited from Exception)
HelpLink HelpLink HelpLink HelpLink

Ottiene o imposta un collegamento al file della Guida associato all'eccezione.Gets or sets a link to the help file associated with this exception.

(Inherited from Exception)
HResult HResult HResult HResult

Ottiene o imposta HRESULT, un valore numerico codificato che viene assegnato a un'eccezione specifica.Gets or sets HRESULT, a coded numerical value that is assigned to a specific exception.

(Inherited from Exception)
InnerException InnerException InnerException InnerException

Ottiene l'istanza di Exception che ha causato l'eccezione corrente.Gets the Exception instance that caused the current exception.

(Inherited from Exception)
Message Message Message Message

Ottiene un messaggio che descrive l'eccezione corrente.Gets a message that describes the current exception.

(Inherited from Exception)
Source Source Source Source

Ottiene o imposta il nome dell'oggetto o dell'applicazione che ha generato l'errore.Gets or sets the name of the application or the object that causes the error.

(Inherited from Exception)
StackTrace StackTrace StackTrace StackTrace

Ottiene una rappresentazione di stringa dei frame immediati nello stack di chiamate.Gets a string representation of the immediate frames on the call stack.

(Inherited from Exception)
TargetSite TargetSite TargetSite TargetSite

Ottiene il metodo che genera l'eccezione corrente.Gets the method that throws the current exception.

(Inherited from Exception)

Metodi

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

Determina se l'oggetto specificato è uguale all'oggetto corrente.Determines whether the specified object is equal to the current object.

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

Se utilizzato come metodo di override in una classe derivata, restituisce l'Exception che è la causa radice di una o più eccezioni successive.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()

Funge da funzione hash predefinita.Serves as the default hash function.

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

Quando l'override viene eseguito in una classe derivata, imposta il controllo SerializationInfo per la colonna.When overridden in a derived class, sets the SerializationInfo with information about the exception.

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

Ottiene il tipo di runtime dell'istanza corrente.Gets the runtime type of the current instance.

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

Crea una copia superficiale dell'oggetto Object corrente.Creates a shallow copy of the current Object.

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

Crea e restituisce una rappresentazione di stringa dell'eccezione corrente.Creates and returns a string representation of the current exception.

(Inherited from Exception)

Eventi

SerializeObjectState SerializeObjectState SerializeObjectState SerializeObjectState

Si verifica quando un'eccezione viene serializzata per creare un oggetto di stato eccezione contenente i dati serializzati relativi all'eccezione.Occurs when an exception is serialized to create an exception state object that contains serialized data about the exception.

(Inherited from Exception)

Si applica a

Vedi anche