Condividi tramite

Classe System.InvalidCastException

  • Articolo

Questo articolo fornisce osservazioni supplementari alla documentazione di riferimento per questa API.

.NET 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 di interfaccia e indietro. Include anche un'ampia gamma di meccanismi che supportano conversioni personalizzate. Per altre informazioni, vedere Conversione dei tipi in .NET.

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 da un 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 di riferimento esplicita 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 tramite una conversione di riferimento implicita.

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

  • castclass
  • refanyval
  • unbox

InvalidCastException usa HRESULT COR_E_INVALIDCAST, 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 IConvertibleEx
{
    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 Example2
    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 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 è attivo).

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 il downcast, ovvero si sta provando a convertire un'istanza di un tipo di base in uno 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 Example1
    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 di 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 InterfaceEx
{
    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 Example3
    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 convertito nuovamente 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 .

public class StringEx
{
    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

Utilizzo 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 ToStringEx2
{
    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 di 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 "Cast specificato non valido". Per eliminare questa eccezione, modificare la riga di codice nel modulo ( 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))