Operatory testowania typu i rzutowania (C# odwołanie)Type-testing and cast operators (C# reference)

Można użyć następujących operatorów do przeprowadzenia sprawdzania typu lub konwersji typu:You can use the following operators to perform type checking or type conversion:

IS — operatoris operator

is Operator sprawdza, czy typ środowiska uruchomieniowego wyniku wyrażenia jest zgodny z danym typem.The is operator checks if the runtime type of an expression result is compatible with a given type. Począwszy od C# 7,0, is operator sprawdza także wynik wyrażenia względem wzorca.Starting with C# 7.0, the is operator also tests an expression result against a pattern.

Wyrażenie z operatorem testowania is typu ma następującą postaćThe expression with the type-testing is operator has the following form

E is T

gdzie E jest wyrażeniem zwracającym wartość i T jest nazwą typu lub parametrem typu.where E is an expression that returns a value and T is the name of a type or a type parameter. Enie może być metodą anonimową ani wyrażeniem lambda.E cannot be an anonymous method or a lambda expression.

true E T Wyrażenie zwraca wartość, jeśli wynik ma wartość inną niż null i można go przekonwertować na typ za pomocą konwersji odwołania, konwersji pakującej lub konwersji rozpakowywania; w przeciwnym razie zwraca wartość false. E is TThe E is T expression returns true if the result of E is non-null and can be converted to type T by a reference conversion, a boxing conversion, or an unboxing conversion; otherwise, it returns false. is Operator nie uwzględnia konwersji zdefiniowanych przez użytkownika.The is operator doesn't consider user-defined conversions.

Poniższy przykład pokazuje, że is operator zwraca true , jeśli typ środowiska uruchomieniowego wyniku wyrażenia pochodzi z danego typu, to oznacza, że istnieje konwersja odwołania między typami:The following example demonstrates that the is operator returns true if the runtime 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
    }
}

W następnym przykładzie pokazano, że is operator bierze pod uwagę opakowanie i konwersje rozpakowywanie, ale nie uwzględnia konwersji liczbowych: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

Aby uzyskać informacje C# na temat konwersji, zobacz rozdział dotyczący konwersji C# specyfikacji języka.For information about C# conversions, see the Conversions chapter of the C# language specification.

Testowanie typu z dopasowaniem do wzorcaType testing with pattern matching

Począwszy od C# 7,0, is operator sprawdza także wynik wyrażenia względem wzorca.Starting with C# 7.0, the is operator also tests an expression result against a pattern. W szczególności obsługuje wzorzec typu w następującej postaci:In particular, it supports the type pattern in the following form:

E is T v

gdzie E jest wyrażeniem zwracającym wartość, T jest nazwą typu lub parametrem typu, a v to Nowa zmienna lokalna typu T.where E is an expression that returns a value, T is the name of a type or a type parameter, and v is a new local variable of type T. Jeśli E wynik jest inny niż null i można go przekonwertować na T za pomocą konwersji referencyjnej, pakującej lub rozpakowywania, E is T v wyrażenie zwraca true i przekonwertowaną wartość wyniku E jest przypisane do zmienna v.If the result of E is non-null and can be converted to T by a reference, boxing, or unboxing conversion, the E is T v expression returns true and the converted value of the result of E is assigned to variable v.

Poniższy przykład ilustruje użycie is operatora z wzorcem typu:The following example demonstrates the usage of the is operator with the type pattern:

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

Aby uzyskać więcej informacji na temat wzorca typu i innych obsługiwanych wzorców, zobacz Dopasowanie wzorców do.For more information about the type pattern and other supported patterns, see Pattern matching with is.

AS — operatoras operator

as Operator jawnie konwertuje wynik wyrażenia na daną odwołanie lub typ wartości null.The as operator explicitly converts the result of an expression to a given reference or nullable value type. Jeśli konwersja nie jest możliwa, as operator zwraca. nullIf the conversion is not possible, the as operator returns null. W przeciwieństwie do operatora CAST () as operator nigdy nie zgłasza wyjątku.Unlike the cast operator (), the as operator never throws an exception.

Wyrażenie formularzaThe expression of the form

E as T

gdzie E jest wyrażeniem zwracającym wartość i T jest nazwą typu lub parametrem typu, daje ten sam wynik jakowhere 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

z tą różnicą, że E jest obliczany tylko raz.except that E is only evaluated once.

as Operator traktuje wyłącznie konwersje odwołania, dopuszczające wartość null, opakowanie i rozpakowywanie.The as operator considers only reference, nullable, boxing, and unboxing conversions. Nie można użyć as operatora do wykonania konwersji zdefiniowanej przez użytkownika.You cannot use the as operator to perform a user-defined conversion. Aby to zrobić, użyj operatora CAST ().To do that, use the cast operator ().

Poniższy przykład ilustruje użycie as operatora: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
}

Uwaga

Jak pokazano na powyższym przykładzie, należy porównać wynik as wyrażenia z null , aby sprawdzić, czy konwersja zakończyła się pomyślnie.As the preceding example shows, you need to compare the result of the as expression with null to check if the conversion is successful. Począwszy od C# 7,0, można użyć operatora is , aby sprawdzić, czy konwersja się powiedzie i, jeśli zakończy się pomyślnie, przypisz wynik do nowej zmiennej.Starting 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.

Operator rzutowania ()Cast operator ()

Wyrażenie rzutowania formularza (T)E wykonuje jawną konwersję wyniku wyrażenia E na typ T.A cast expression of the form (T)E performs an explicit conversion of the result of expression E to type T. Jeśli nie istnieje jawna konwersja z typu E do typu T, wystąpi błąd czasu kompilacji.If no explicit conversion exists from the type of E to type T, a compile-time error occurs. W czasie wykonywania jawna konwersja może się nie powieść, a wyrażenie rzutowania może zgłosić wyjątek.At run time, an explicit conversion might not succeed and a cast expression might throw an exception.

W poniższym przykładzie zademonstrowano jawne konwersje liczbowe i odwołania: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

Aby uzyskać informacje na temat obsługiwanych konwersji jawnych, zobacz sekcję Konwersje jawne w C# specyfikacji języka.For information about supported explicit conversions, see the Explicit conversions section of the C# language specification. Aby uzyskać informacje dotyczące sposobu definiowania niestandardowej jawnej lub niejawnej konwersji typu, zobacz Operatory konwersji zdefiniowane przez użytkownika.For information about how to define a custom explicit or implicit type conversion, see User-defined conversion operators.

Inne użycie ()Other usages of ()

Należy również użyć nawiasów do wywołania metody lub wywołania delegata.You also use parentheses to call a method or invoke a delegate.

Innym zastosowaniem nawiasów jest dostosowanie kolejności, w której mają być oceniane operacje w wyrażeniu.Other use of parentheses is to adjust the order in which to evaluate operations in an expression. Aby uzyskać więcej informacji, zobacz C# operatory.For more information, see C# operators.

typeof — Operatortypeof operator

Operator uzyskuje System.Type wystąpienie dla typu. typeofThe typeof operator obtains the System.Type instance for a type. Argument typeof operatora musi być nazwą typu lub parametrem typu, jak pokazano w poniższym przykładzie: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]

Można również użyć typeof operatora z niepowiązane typy ogólne.You also can use the typeof operator with unbound generic types. Nazwa niepowiązanego typu ogólnego musi zawierać odpowiednią liczbę przecinków, która jest mniejsza niż liczba parametrów typu.The name of an unbound generic type must contain the appropriate number of commas, which is one less than the number of type parameters. W poniższym przykładzie pokazano użycie typeof operatora z niezwiązanym typem ogólnym: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]

Wyrażenie nie może być argumentem typeof operatora.An expression cannot be an argument of the typeof operator. Aby uzyskać System.Type wystąpienie dla typu środowiska uruchomieniowego wyniku wyrażenia, Object.GetType Użyj metody.To get the System.Type instance for the runtime type of the expression result, use the Object.GetType method.

Testowanie typu za pomocą typeof operatoraType testing with the typeof operator

Użyj operatora typeof , aby sprawdzić, czy typ środowiska uruchomieniowego wyniku wyrażenia dokładnie pasuje do danego typu.Use the typeof operator to check if the runtime type of the expression result exactly matches a given type. Poniższy przykład ilustruje różnicę między sprawdzaniem typu wykonane z typeof operatorem i operatorem 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
    }
}

Przeciążanie operatoraOperator overloadability

asOperatorów is, i niemożnatypeof przeciążać.The is, as, and typeof operators are not overloadable.

Typ zdefiniowany przez użytkownika nie może przeciążać () operatora, ale może definiować konwersje typów niestandardowych, które mogą być wykonywane przez wyrażenie rzutowania.A user-defined type cannot overload the () operator, but can define custom type conversions that can be performed by a cast expression. Aby uzyskać więcej informacji, zobacz Operatory konwersji zdefiniowane przez użytkownika.For more information, see User-defined conversion operators.

specyfikacja języka C#C# language specification

Aby uzyskać więcej informacji, zobacz następujące sekcje C# specyfikacji języka:For more information, see the following sections of the C# language specification:

Zobacz takżeSee also