Operátory testování typů a výraz přetypování (referenční dokumentace jazyka C#)

K provedení kontroly typů nebo převodu typů můžete použít následující operátory a výrazy:

is – operátor

Operátor zkontroluje is , jestli je typ výsledku výrazu za běhu kompatibilní s daným typem. Operátor is také testuje výsledek výrazu podle vzoru.

Výraz s operátorem pro testování is typů má následující formulář.

E is T

kde E je výraz, který vrací hodnotu a T je název typu nebo parametru typu. E nemůže být anonymní metoda ani výraz lambda.

Operátor is vrátí true , když je výsledek výrazu nenulový a platí některá z následujících podmínek:

Operátor is nebere v úvahu uživatelem definované převody.

Následující příklad ukazuje, že is operátor vrátí true , pokud typ běhu výsledku výrazu pochází z daného typu, to znamená, že existuje odkaz převod mezi typy:

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
    }
}

Následující příklad ukazuje, že is operátor bere v úvahu převody boxů a oddělování, ale nepovažuje za číselné převody:

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

Informace o převodech jazyka C# najdete v kapitole Převodyspecifikace jazyka C#.

Testování typů pomocí porovnávání vzorů

Operátor is také testuje výsledek výrazu podle vzoru. Následující příklad ukazuje, jak pomocí vzoru deklarace zkontrolovat typ běhu výrazu:

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

Informace o podporovaných vzorech najdete v tématu Vzory.

Operátor as

Operátor as explicitně převede výsledek výrazu na daný odkaz nebo typ hodnoty s možnou hodnotou null. Pokud převod není možný, as vrátí nulloperátor . Na rozdíl od výrazu přetypování operátor as nikdy nevyvolá výjimku.

Výraz formuláře

E as T

kde E je výraz, který vrací hodnotu a T je názvem typu nebo parametru typu, vytvoří stejný výsledek jako

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

s tím rozdílem, že E se vyhodnocuje pouze jednou.

Operátor as považuje pouze odkaz, nullable, boxing a unboxing conversions. Operátor nemůžete použít as k provedení uživatelem definovaného převodu. K tomu použijte výraz přetypování.

Následující příklad ukazuje použití operátoru as :

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
}

Poznámka

Jak ukazuje předchozí příklad, je potřeba porovnat výsledek výrazu as a null zkontrolovat, jestli převod proběhl úspěšně. Operátor is můžete použít k otestování, jestli převod proběhne úspěšně, a pokud bude úspěšný, přiřaďte jeho výsledek k nové proměnné.

Přetypování výrazu

Výraz přetypování formuláře (T)E provádí explicitní převod výsledku výrazu E na typ T. Pokud neexistuje žádný explicitní převod z typu na typ ET, dojde k chybě v době kompilace. V době běhu nemusí explicitní převod proběhnout úspěšně a výraz přetypování může vyvolat výjimku.

Následující příklad ukazuje explicitní číselné a referenční převody:

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

Informace o podporovaných explicitních převodech najdete v části Explicitní převodyspecifikace jazyka C#. Informace o tom, jak definovat vlastní explicitní nebo implicitní převod typů, najdete v tématu Operátory převodu definované uživatelem.

Jiné využití ()

Pomocí závorek můžete také volat metodu nebo vyvolat delegáta.

Dalším použitím závorek je upravit pořadí, ve kterém se mají vyhodnocovat operace ve výrazu. Další informace najdete v tématu Operátory jazyka C#.

typeof – operátor

Operátor typeof získá System.Type instanci pro typ. Argument operátoru typeof musí být název typu nebo parametru typu, jak ukazuje následující příklad:

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]

Argument nesmí být typem, který vyžaduje poznámky metadat. Příklady zahrnují následující typy:

  • dynamic
  • string? (nebo jakýkoli typ odkazu s možnou hodnotou null)

Tyto typy nejsou přímo reprezentovány v metadatech. Typy zahrnují atributy, které popisují základní typ. V obou případech můžete použít podkladový typ. dynamicMísto toho můžete použít object. string?Místo toho můžete použít string.

Operátor můžete použít typeof také s nevázanými obecnými typy. Název nevázaného obecného typu musí obsahovat odpovídající počet čárk, což je jedna menší než počet parametrů typu. Následující příklad ukazuje použití operátoru typeof s nevázaným obecným typem:

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

Výraz nemůže být argument operátoru typeof . Pokud chcete získat System.Type instanci pro typ běhu výsledku výrazu, použijte metodu Object.GetType .

Testování typů pomocí operátoru typeof

Pomocí operátoru typeof zkontrolujte, jestli typ běhu výsledku výrazu přesně odpovídá danému typu. Následující příklad ukazuje rozdíl mezi kontrolou typů provedenou s operátorem typeof a operátor je:

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
    }
}

Přetížení operátoru

Operátory isa , asnelze typeof přetížit.

Uživatelem definovaný typ nemůže přetížit () operátor, ale může definovat vlastní převody typů, které lze provádět výrazem přetypování. Další informace najdete v tématu Operátory převodu definované uživatelem.

specifikace jazyka C#

Další informace najdete v následujících částech specifikace jazyka C#:

Viz také