Operatori di test dei tipi ed espressione cast (riferimenti per C#)Type-testing operators and cast expression (C# reference)

È possibile usare gli operatori e le espressioni seguenti per eseguire il controllo dei tipi o la conversione dei tipi:You can use the following operators and expressions to perform type checking or type conversion:

  • operatore is: per verificare se il tipo di run-time di un'espressione è compatibile con un determinato tipois operator: to check if the run-time type of an expression is compatible with a given type
  • operatore as: per convertire in modo esplicito un'espressione in un determinato tipo se il tipo in fase di esecuzione è compatibile con tale tipoas operator: to explicitly convert an expression to a given type if its run-time type is compatible with that type
  • cast expression: per eseguire una conversione esplicitacast expression: to perform an explicit conversion
  • operatore typeof: per ottenere l'istanza System.Type per un tipotypeof operator: to obtain the System.Type instance for a type

Operatore isis operator

isL'operatore verifica se il tipo in fase di esecuzione di un risultato dell'espressione è compatibile con un determinato tipo.The is operator checks if the run-time type of an expression result is compatible with a given type. A partire da C# 7.0, l'operatore verifica anche is il risultato di un'espressione rispetto a un criterio.Beginning with C# 7.0, the is operator also tests an expression result against a pattern.

L'espressione con l'operatore di test del tipo is ha il formato seguente:The expression with the type-testing is operator has the following form

E is T

in cui E è un'espressione che restituisce un valore e T è il nome di un tipo o un parametro di tipo.where E is an expression that returns a value and T is the name of a type or a type parameter. E non può essere un metodo anonimo o un'espressione lambda.E cannot be an anonymous method or a lambda expression.

L'operatore restituisce quando il risultato di un'espressione è diverso da Null e is una delle condizioni seguenti è true vera:The is operator returns true when an expression result is non-null and any of the following conditions are true:

  • Il tipo di run-time del risultato di un'espressione è T .The run-time type of an expression result is T.

  • Il tipo in fase di esecuzione di un risultato dell'espressione deriva dal tipo , implementa l'interfaccia o esiste un'altra T T conversione implicita dei riferimenti da esso a T .The run-time type of an expression result derives from type T, implements interface T, or another implicit reference conversion exists from it to T.

  • Il tipo di esecuzione del risultato di un'espressione è un tipo valore nullable con il tipo sottostante T e è Nullable<T>.HasValue true .The run-time type of an expression result is a nullable value type with the underlying type T and the Nullable<T>.HasValue is true.

  • Esiste una conversione boxing o unboxing dal tipo di run-time di un risultato dell'espressione al tipo T .A boxing or unboxing conversion exists from the run-time type of an expression result to type T.

L'operatore is non considera le conversioni definite dall'utente.The is operator doesn't consider user-defined conversions.

L'esempio seguente dimostra che l'operatore restituisce se il tipo in fase di esecuzione di un risultato di espressione deriva da un tipo specificato, cio' esiste una conversione di is true riferimento tra tipi:The following example demonstrates that the is operator returns true if the run-time type of an expression result derives from a given type, that is, there exists a reference conversion between types:

public class Base { }

public class Derived : Base { }

public static class IsOperatorExample
{
    public static void Main()
    {
        object b = new Base();
        Console.WriteLine(b is Base);  // output: True
        Console.WriteLine(b is Derived);  // output: False

        object d = new Derived();
        Console.WriteLine(d is Base);  // output: True
        Console.WriteLine(d is Derived); // output: True
    }
}

L'esempio seguente mostra che l'operatore tiene conto delle conversioni boxing e unboxing, ma non is considera le conversioni numeriche:The next example shows that the is operator takes into account boxing and unboxing conversions but doesn't consider numeric conversions:

int i = 27;
Console.WriteLine(i is System.IFormattable);  // output: True

object iBoxed = i;
Console.WriteLine(iBoxed is int);  // output: True
Console.WriteLine(iBoxed is long);  // output: False

Per informazioni sulle conversioni C#, vedere il capito Conversioni della specifica del linguaggio C#.For information about C# conversions, see the Conversions chapter of the C# language specification.

Test del tipo con criteri di ricercaType testing with pattern matching

A partire da C# 7.0, l'operatore verifica anche is il risultato di un'espressione rispetto a un criterio.Beginning with C# 7.0, the is operator also tests an expression result against a pattern. Nell'esempio seguente viene illustrato come usare un modello di dichiarazione per controllare il tipo in fase di esecuzione di un'espressione:The following example shows how to use a declaration pattern to check the run-time type of an expression:

int i = 23;
object iBoxed = i;
int? jNullable = 7;
if (iBoxed is int a && jNullable is int b)
{
    Console.WriteLine(a + b);  // output 30
}

Per informazioni sui modelli supportati, vedere Modelli.For information about the supported patterns, see Patterns.

Operatore asas operator

L'operatore as converte in modo esplicito il risultato di un'espressione in un tipo di valore nullable o di riferimento specificato.The as operator explicitly converts the result of an expression to a given reference or nullable value type. Se la conversione non è possibile, l'operatore as restituisce null.If the conversion is not possible, the as operator returns null. A differenza di un'espressione cast, as l'operatore non genera mai un'eccezione.Unlike a cast expression, the as operator never throws an exception.

Un'espressione nel formatoThe expression of the form

E as T

in cui E è un'espressione che restituisce un valore e T è il nome di un tipo o un parametro di tipo, produce lo stesso risultato diwhere E is an expression that returns a value and T is the name of a type or a type parameter, produces the same result as

E is T ? (T)(E) : (T)null

con la differenza che E viene valutato una sola volta.except that E is only evaluated once.

L'operatore as considera solo conversioni di riferimenti, nullable, boxing e unboxing.The as operator considers only reference, nullable, boxing, and unboxing conversions. Non è possibile usare l'operatore as per eseguire una conversione definita dall'utente.You cannot use the as operator to perform a user-defined conversion. A tale scopo, usare un'espressione cast.To do that, use a cast expression.

Nell'esempio seguente viene illustrato l'uso dell'operatore as:The following example demonstrates the usage of the as operator:

IEnumerable<int> numbers = new[] { 10, 20, 30 };
IList<int> indexable = numbers as IList<int>;
if (indexable != null)
{
    Console.WriteLine(indexable[0] + indexable[indexable.Count - 1]);  // output: 40
}

Nota

Come mostrato nell'esempio precedente, è necessario confrontare il risultato dell'espressione as con null per verificare se la conversione riesce.As the preceding example shows, you need to compare the result of the as expression with null to check if the conversion is successful. A partire da C# 7.0, è possibile usare l'operatore is sia per verificare se la conversione ha esito positivo sia per assegnare il risultato a una nuova variabile.Beginning with C# 7.0, you can use the is operator both to test if the conversion succeeds and, if it succeeds, assign its result to a new variable.

Espressione castCast expression

Un'espressione cast nel formato (T)E esegue una conversione esplicita del risultato dell'espressione E nel tipo T.A cast expression of the form (T)E performs an explicit conversion of the result of expression E to type T. Se non esiste alcuna conversione esplicita dal tipo E al tipo T, si verifica un errore in fase di compilazione.If no explicit conversion exists from the type of E to type T, a compile-time error occurs. In fase di esecuzione, è possibile che una conversione esplicita non riesca e che un'espressione cast generi un'eccezione.At run time, an explicit conversion might not succeed and a cast expression might throw an exception.

L'esempio seguente illustra conversioni esplicite numeriche e di riferimento:The following example demonstrates explicit numeric and reference conversions:

double x = 1234.7;
int a = (int)x;
Console.WriteLine(a);   // output: 1234

IEnumerable<int> numbers = new int[] { 10, 20, 30 };
IList<int> list = (IList<int>)numbers;
Console.WriteLine(list.Count);  // output: 3
Console.WriteLine(list[1]);  // output: 20

Per informazioni sulle conversioni esplicite supportate, vedere la sezione Conversioni esplicite della specifica del linguaggio C#.For information about supported explicit conversions, see the Explicit conversions section of the C# language specification. Per informazioni su come definire una conversione personalizzata del tipo esplicito o implicito, vedere Operatori di conversione definiti dall'utente.For information about how to define a custom explicit or implicit type conversion, see User-defined conversion operators.

Altri utilizzi di ()Other usages of ()

È possibile usare le parentesi anche per chiamare un metodo oppure richiamare un delegato.You also use parentheses to call a method or invoke a delegate.

Le parentesi possono essere usate anche per specificare l'ordine in cui valutare le operazioni in un'espressione.Other use of parentheses is to adjust the order in which to evaluate operations in an expression. Per altre informazioni, vedere Operatori C#.For more information, see C# operators.

Operatore typeoftypeof operator

L'operatore typeof ottiene l'istanza System.Type per un tipo.The typeof operator obtains the System.Type instance for a type. L'argomento dell'operatore typeof deve essere il nome o il parametro di un tipo, come illustrato nell'esempio seguente:The argument to the typeof operator must be the name of a type or a type parameter, as the following example shows:

void PrintType<T>() => Console.WriteLine(typeof(T));

Console.WriteLine(typeof(List<string>));
PrintType<int>();
PrintType<System.Int32>();
PrintType<Dictionary<int, char>>();
// Output:
// System.Collections.Generic.List`1[System.String]
// System.Int32
// System.Int32
// System.Collections.Generic.Dictionary`2[System.Int32,System.Char]

È anche possibile usare typeof l'operatore con tipi generici non associati.You can also use the typeof operator with unbound generic types. Il nome di un tipo generico non associato deve contenere il numero appropriato di virgole, ovvero una in meno rispetto al numero di parametri del tipo.The name of an unbound generic type must contain the appropriate number of commas, which is one less than the number of type parameters. L'esempio seguente illustra l'uso dell'operatore typeof con un tipo generico non associato:The following example shows the usage of the typeof operator with an unbound generic type:

Console.WriteLine(typeof(Dictionary<,>));
// Output:
// System.Collections.Generic.Dictionary`2[TKey,TValue]

Un'espressione non può essere un argomento dell'operatore typeof.An expression cannot be an argument of the typeof operator. Per ottenere System.Type l'istanza per il tipo di run-time del risultato di un'espressione, usare il Object.GetType metodo .To get the System.Type instance for the run-time type of an expression result, use the Object.GetType method.

Test del tipo con l'operatore typeofType testing with the typeof operator

Usare typeof l'operatore per verificare se il tipo di run-time del risultato dell'espressione corrisponde esattamente a un determinato tipo.Use the typeof operator to check if the run-time type of the expression result exactly matches a given type. L'esempio seguente illustra la differenza tra il controllo del tipo eseguito con l'operatore typeof e il controllo del tipo con l'operatore is:The following example demonstrates the difference between type checking performed with the typeof operator and the is operator:

public class Animal { }

public class Giraffe : Animal { }

public static class TypeOfExample
{
    public static void Main()
    {
        object b = new Giraffe();
        Console.WriteLine(b is Animal);  // output: True
        Console.WriteLine(b.GetType() == typeof(Animal));  // output: False

        Console.WriteLine(b is Giraffe);  // output: True
        Console.WriteLine(b.GetType() == typeof(Giraffe));  // output: True
    }
}

Overload degli operatoriOperator overloadability

Non is è possibile eseguire as typeof l'overload degli operatori , e .The is, as, and typeof operators cannot be overloaded.

Un tipo definito dall'utente non può eseguire l'overload dell'operatore (), ma può definire conversioni di tipi personalizzate che possano essere eseguite da un'espressione cast.A user-defined type cannot overload the () operator, but can define custom type conversions that can be performed by a cast expression. Per altre informazioni, vedere Operatori di conversione definiti dall'utente.For more information, see User-defined conversion operators.

Specifiche del linguaggio C#C# language specification

Per altre informazioni, vedere le sezioni seguenti delle specifiche del linguaggio C#:For more information, see the following sections of the C# language specification:

Vedi ancheSee also