InvalidCastException Classe

Definizione

Eccezione generata per una conversione esplicita o un cast non valido.

public ref class InvalidCastException : Exception
public ref class InvalidCastException : SystemException
public class InvalidCastException : Exception
public class InvalidCastException : SystemException
[System.Serializable]
public class InvalidCastException : SystemException
[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public class InvalidCastException : SystemException
type InvalidCastException = class
    inherit Exception
type InvalidCastException = class
    inherit SystemException
[<System.Serializable>]
type InvalidCastException = class
    inherit SystemException
[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type InvalidCastException = class
    inherit SystemException
Public Class InvalidCastException
Inherits Exception
Public Class InvalidCastException
Inherits SystemException
Ereditarietà
InvalidCastException
Ereditarietà
InvalidCastException
Attributi

Commenti

.NET Framework supporta la conversione automatica dai tipi derivati ai relativi tipi di base e torna al tipo derivato, nonché dai tipi che presentano interfacce a oggetti interfaccia e indietro. Include anche un'ampia gamma di meccanismi che supportano conversioni personalizzate. Per altre informazioni, vedere Conversione dei tipi in .NET Framework.

Viene generata un'eccezione InvalidCastException quando la conversione di un'istanza di un tipo in un altro non è supportata. Ad esempio, il tentativo di convertire un Char valore in un DateTime valore genera un'eccezione InvalidCastException . Differisce da un'eccezione OverflowException, che viene generata quando la conversione di un tipo in un altro è supportata, ma il valore del tipo di origine non è compreso nell'intervallo del tipo di destinazione. Un'eccezione InvalidCastException è causata dall'errore dello sviluppatore e non deve essere gestita in un try/catch blocco. Al contrario, la causa dell'eccezione deve essere eliminata.

Per informazioni sulle conversioni supportate dal sistema, vedere la classe Convert. Per gli errori che si verificano quando il tipo di destinazione può archiviare i valori del tipo di origine ma non è sufficientemente grande da archiviare un valore di origine specifico, vedere l'eccezione OverflowException .

Nota

In molti casi, il compilatore di linguaggio rileva che non è possibile alcuna conversione tra il tipo di origine e il tipo di destinazione e genera un errore del compilatore.

Alcune delle condizioni in cui una conversione tentata genera un'eccezione InvalidCastException sono descritte nelle sezioni seguenti:

Affinché una conversione esplicita dei riferimenti venga eseguita correttamente, il valore di origine deve essere nullo il tipo di oggetto a cui fa riferimento l'argomento di origine deve essere convertibile nel tipo di destinazione da una conversione di riferimento implicita.

Le seguenti istruzioni del linguaggio intermedio (IL) generano un'eccezione InvalidCastException:

  • castclass

  • refanyval

  • unbox

InvalidCastException usa il COR_E_INVALIDCAST HRESULT, che ha il valore 0x80004002.

Per un elenco di valori di proprietà iniziali per un'istanza di InvalidCastException, vedere il InvalidCastException costruttori.

Tipi primitivi e IConvertible

Viene chiamata direttamente o indirettamente l'implementazione IConvertible di un tipo primitivo che non supporta una determinata conversione. Ad esempio, il tentativo di convertire un valore Boolean in Char o un valore DateTime in Int32 genera un'eccezione InvalidCastException. Nell'esempio seguente vengono chiamati i metodi Boolean.IConvertible.ToChar e Convert.ToChar(Boolean) per convertire un valore Boolean in Char. In entrambi i casi, la chiamata al metodo genera un'eccezione InvalidCastException.

using System;

public class Example
{
   public static void Main()
   {
      bool flag = true;
      try {
         IConvertible conv = flag;
         Char ch = conv.ToChar(null);
         Console.WriteLine("Conversion succeeded.");
      }
      catch (InvalidCastException) {
         Console.WriteLine("Cannot convert a Boolean to a Char.");
      }

      try {
         Char ch = Convert.ToChar(flag);
         Console.WriteLine("Conversion succeeded.");
      }
      catch (InvalidCastException) {
         Console.WriteLine("Cannot convert a Boolean to a Char.");
      }
   }
}
// The example displays the following output:
//       Cannot convert a Boolean to a Char.
//       Cannot convert a Boolean to a Char.
open System

let flag = true
try
    let conv: IConvertible = flag
    let ch = conv.ToChar null
    printfn "Conversion succeeded."
with :? InvalidCastException ->
    printfn "Cannot convert a Boolean to a Char."

try
    let ch = Convert.ToChar flag
    printfn "Conversion succeeded."
with :? InvalidCastException ->
    printfn "Cannot convert a Boolean to a Char."

// The example displays the following output:
//       Cannot convert a Boolean to a Char.
//       Cannot convert a Boolean to a Char.
Module Example
   Public Sub Main()
      Dim flag As Boolean = True
      Try
         Dim conv As IConvertible = flag
         Dim ch As Char = conv.ToChar(Nothing)
         Console.WriteLine("Conversion succeeded.")
      Catch e As InvalidCastException   
         Console.WriteLine("Cannot convert a Boolean to a Char.")
      End Try
      
      Try
         Dim ch As Char = Convert.ToChar(flag)
         Console.WriteLine("Conversion succeeded.")
      Catch e As InvalidCastException   
         Console.WriteLine("Cannot convert a Boolean to a Char.")
      End Try
   End Sub
End Module
' The example displays the following output:
'       Cannot convert a Boolean to a Char.
'       Cannot convert a Boolean to a Char.

Poiché la conversione non è supportata, non esiste alcuna soluzione alternativa.

Metodo Convert.ChangeType

È stato chiamato il metodo Convert.ChangeType per convertire un oggetto da un tipo in un altro, ma uno o entrambi i tipi non implementano l'interfaccia IConvertible.

Nella maggior parte dei casi, poiché la conversione non è supportata, non esiste alcuna soluzione alternativa. In alcuni casi, una possibile soluzione alternativa consiste nell'assegnare manualmente i valori delle proprietà dal tipo di origine a proprietà simili di un tipo di destinazione.

Conversioni di tipo narrowing e implementazioni IConvertible

Gli operatori di tipo narrowing definiscono le conversioni esplicite supportate da un tipo. Per eseguire la conversione è necessario un operatore di cast in C# o il CType metodo di conversione in Visual Basic (se Option Strict è attivato).

Tuttavia, se né il tipo di origine né il tipo di destinazione definiscono una conversione esplicita o ridotta tra i due tipi e l'implementazione IConvertible di uno o entrambi i tipi non supporta una conversione dal tipo di origine al tipo di destinazione, viene generata un'eccezione InvalidCastException .

Nella maggior parte dei casi, poiché la conversione non è supportata, non esiste alcuna soluzione alternativa.

Downcasting

Si sta eseguendo un downcast, ovvero si sta provando a convertire un'istanza di un tipo di base in una dei relativi tipi derivati. Nell'esempio seguente, il tentativo di convertire un oggetto Person in un oggetto PersonWithID ha esito negativo.

using System;

public class Person
{
   String _name;

   public String Name
   {
      get { return _name; }
      set { _name = value; }
   }
}

public class PersonWithId : Person
{
   String _id;

   public string Id
   {
      get { return _id; }
      set { _id = value; }
   }
}

public class Example
{
   public static void Main()
   {
      Person p = new Person();
      p.Name = "John";
      try {
         PersonWithId pid = (PersonWithId) p;
         Console.WriteLine("Conversion succeeded.");
      }
      catch (InvalidCastException) {
         Console.WriteLine("Conversion failed.");
      }

      PersonWithId pid1 = new PersonWithId();
      pid1.Name = "John";
      pid1.Id = "246";
      Person p1 = pid1;
      try {
         PersonWithId pid1a = (PersonWithId) p1;
         Console.WriteLine("Conversion succeeded.");
      }
      catch (InvalidCastException) {
         Console.WriteLine("Conversion failed.");
      }

      Person p2 = null;
      try {
         PersonWithId pid2 = (PersonWithId) p2;
         Console.WriteLine("Conversion succeeded.");
      }
      catch (InvalidCastException) {
         Console.WriteLine("Conversion failed.");
      }
   }
}
// The example displays the following output:
//       Conversion failed.
//       Conversion succeeded.
//       Conversion succeeded.
open System

type Person() =
    member val Name = String.Empty with get, set

type PersonWithId() =
    inherit Person()
    member val Id = String.Empty with get, set


let p = Person()
p.Name <- "John"
try
    let pid = p :?> PersonWithId
    printfn "Conversion succeeded."
with :? InvalidCastException ->
    printfn "Conversion failed."

let pid1 = PersonWithId()
pid1.Name <- "John"
pid1.Id <- "246"
let p1: Person = pid1
try
    let pid1a = p1 :?> PersonWithId
    printfn "Conversion succeeded."
with :? InvalidCastException ->
    printfn "Conversion failed."

// The example displays the following output:
//       Conversion failed.
//       Conversion succeeded.
Public Class Person
   Dim _name As String
   
   Public Property Name As String
      Get
         Return _name
      End Get
      Set
         _name = value
      End Set
   End Property
End Class

Public Class PersonWithID : Inherits Person
   Dim _id As String
   
   Public Property Id As String
      Get
         Return _id
      End Get
      Set
         _id = value
      End Set
   End Property
End Class

Module Example
   Public Sub Main()
      Dim p As New Person()
      p.Name = "John"
      Try
         Dim pid As PersonWithId = CType(p, PersonWithId)
         Console.WriteLine("Conversion succeeded.")
      Catch e As InvalidCastException
         Console.WriteLine("Conversion failed.")
      End Try 
      
      Dim pid1 As New PersonWithId()
      pid1.Name = "John"
      pid1.Id = "246"
      Dim p1 As Person = pid1
      
      Try   
         Dim pid1a As PersonWithId = CType(p1, PersonWithId)
         Console.WriteLine("Conversion succeeded.")
      Catch e As InvalidCastException
         Console.WriteLine("Conversion failed.")
      End Try 
      
      Dim p2 As Person = Nothing
      Try   
         Dim pid2 As PersonWithId = CType(p2, PersonWithId)
         Console.WriteLine("Conversion succeeded.")
      Catch e As InvalidCastException
         Console.WriteLine("Conversion failed.")
      End Try 
   End Sub
End Module
' The example displays the following output:
'       Conversion failed.
'       Conversion succeeded.
'       Conversion succeeded.

Come illustrato nell'esempio, il downcast ha esito positivo solo se l'oggetto Person è stato creato da un upcast di un oggetto PersonWithId in un oggetto Person o se l'oggetto Person è null.

Conversione da un oggetto interfaccia

Si sta tentando di convertire un oggetto interfaccia in un tipo che implementa tale interfaccia, ma il tipo di destinazione non è lo stesso tipo o una classe base del tipo da cui è stato originariamente derivato l'oggetto interfaccia. Nell'esempio seguente viene generata un'eccezione InvalidCastException quando tenta di convertire un IFormatProvider oggetto in un DateTimeFormatInfo oggetto . La conversione non riesce perché anche se la DateTimeFormatInfo classe implementa l'interfaccia IFormatProvider , l'oggetto DateTimeFormatInfo non è correlato alla CultureInfo classe da cui è stato derivato l'oggetto interfaccia.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      var culture = CultureInfo.InvariantCulture;
      IFormatProvider provider = culture;

      DateTimeFormatInfo dt = (DateTimeFormatInfo) provider;
   }
}
// The example displays the following output:
//    Unhandled Exception: System.InvalidCastException:
//       Unable to cast object of type //System.Globalization.CultureInfo// to
//           type //System.Globalization.DateTimeFormatInfo//.
//       at Example.Main()
open System
open System.Globalization

let culture = CultureInfo.InvariantCulture
let provider: IFormatProvider = culture

let dt = provider :?> DateTimeFormatInfo

// The example displays the following output:
//    Unhandled Exception: System.InvalidCastException:
//       Unable to cast object of type //System.Globalization.CultureInfo// to
//           type //System.Globalization.DateTimeFormatInfo//.
//       at Example.main()
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim culture As CultureInfo = CultureInfo.InvariantCulture
      Dim provider As IFormatProvider = culture
      
      Dim dt As DateTimeFormatInfo = CType(provider, DateTimeFormatInfo)
   End Sub
End Module
' The example displays the following output:
'    Unhandled Exception: System.InvalidCastException: 
'       Unable to cast object of type 'System.Globalization.CultureInfo' to 
'           type 'System.Globalization.DateTimeFormatInfo'.
'       at Example.Main()

Come indica il messaggio di eccezione, la conversione avrà esito positivo solo se l'oggetto interfaccia viene riconvertito in un'istanza del tipo originale, in questo caso un oggetto CultureInfo. La conversione avrà esito positivo anche se l'oggetto interfaccia viene convertito in un'istanza di un tipo di base del tipo originale.

Conversioni di stringhe

Si sta tentando di convertire un valore o un oggetto nella relativa rappresentazione di stringa usando un operatore di cast in C#. Nell'esempio seguente, sia il tentativo di eseguire il cast di un Char valore a una stringa che il tentativo di eseguire il cast di un numero intero in una stringa genera un'eccezione InvalidCastException .

using System;

public class Example
{
   public static void Main()
   {
      object value = 12;
      // Cast throws an InvalidCastException exception.
      string s = (string) value;
   }
}
let value: obj = 12
// Cast throws an InvalidCastException exception.
let s = value :?> string

Nota

L'uso dell'operatore Visual Basic CStr per convertire un valore di un tipo primitivo in una stringa ha esito positivo. L'operazione non genera un'eccezione InvalidCastException .

Per convertire correttamente un'istanza di qualsiasi tipo nella relativa rappresentazione di stringa, chiamare il relativo ToString metodo, come nell'esempio seguente. Il ToString metodo è sempre presente, poiché il ToString metodo è definito dalla Object classe e pertanto viene ereditato o sottoposto a override da tutti i tipi gestiti.

using System;

public class Example
{
   public static void Main()
   {
      object value = 12;
      string s = value.ToString();
      Console.WriteLine(s);
   }
}
// The example displays the following output:
//      12
let value: obj = 12
let s = value.ToString()
printfn $"{s}"
// The example displays the following output:
//      12

migrazione Visual Basic 6.0

Si sta aggiornando un'applicazione Visual Basic 6.0 con una chiamata a un evento personalizzato in un controllo utente a Visual Basic .NET e viene generata un'eccezione InvalidCastException con il messaggio "Il cast specificato non è valido". Per eliminare questa eccezione, modificare la riga di codice nel formato ( ad esempio Form1)

Call UserControl11_MyCustomEvent(UserControl11, New UserControl1.MyCustomEventEventArgs(5))

e sostituirlo con la riga di codice seguente:

Call UserControl11_MyCustomEvent(UserControl11(0), New UserControl1.MyCustomEventEventArgs(5))

Costruttori

InvalidCastException()

Inizializza una nuova istanza della classe InvalidCastException.

InvalidCastException(SerializationInfo, StreamingContext)

Inizializza una nuova istanza della classe InvalidCastException con dati serializzati.

InvalidCastException(String)

Inizializza una nuova istanza della classe InvalidCastException con un messaggio di errore specificato.

InvalidCastException(String, Exception)

Inizializza una nuova istanza della classe InvalidCastException con un messaggio di errore specificato e un riferimento all'eccezione interna che è la causa dell'eccezione corrente.

InvalidCastException(String, Int32)

Inizializza una nuova istanza della classe InvalidCastException con un messaggio e il codice di errore specificati.

Proprietà

Data

Ottiene una raccolta di coppie chiave/valore che forniscono informazioni definite dall'utente aggiuntive sull'eccezione.

(Ereditato da Exception)
HelpLink

Ottiene o imposta un collegamento al file della Guida associato all'eccezione.

(Ereditato da Exception)
HResult

Ottiene o imposta HRESULT, un valore numerico codificato che viene assegnato a un'eccezione specifica.

(Ereditato da Exception)
InnerException

Ottiene l'istanza di Exception che ha causato l'eccezione corrente.

(Ereditato da Exception)
Message

Ottiene un messaggio che descrive l'eccezione corrente.

(Ereditato da Exception)
Source

Ottiene o imposta il nome dell'oggetto o dell'applicazione che ha generato l'errore.

(Ereditato da Exception)
StackTrace

Ottiene una rappresentazione di stringa dei frame immediati nello stack di chiamate.

(Ereditato da Exception)
TargetSite

Ottiene il metodo che genera l'eccezione corrente.

(Ereditato da Exception)

Metodi

Equals(Object)

Determina se l'oggetto specificato è uguale all'oggetto corrente.

(Ereditato da Object)
GetBaseException()

Quando ne viene eseguito l'override in una classe derivata, restituisce l'Exception che è la causa radice di una o più eccezioni successive.

(Ereditato da Exception)
GetHashCode()

Funge da funzione hash predefinita.

(Ereditato da Object)
GetObjectData(SerializationInfo, StreamingContext)

Quando ne viene eseguito l'override in una classe derivata, imposta il controllo SerializationInfo con le informazioni sull'eccezione.

(Ereditato da Exception)
GetType()

Ottiene il tipo di runtime dell'istanza corrente.

(Ereditato da Exception)
MemberwiseClone()

Crea una copia superficiale dell'oggetto Object corrente.

(Ereditato da Object)
ToString()

Crea e restituisce una rappresentazione di stringa dell'eccezione corrente.

(Ereditato da Exception)

evento

SerializeObjectState
Obsoleta.

Si verifica quando un'eccezione viene serializzata per creare un oggetto di stato eccezione contenente i dati serializzati relativi all'eccezione.

(Ereditato da Exception)

Si applica a

Vedi anche