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

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

  • is –operátor : Zkontroluje, jestli je typ spuštění výrazu kompatibilní s daným typem.
  • as –operátor: Explicitní převod výrazu na daný typ, pokud je jeho typ běhu kompatibilní s tímto typem
  • výraz přetypování:Provedení explicitního převodu
  • typeof– operátor : Získání System.Type instance pro typ

Is – operátor

Operátor is zkontroluje, jestli je typ běhu výsledku výrazu kompatibilní s daným typem. Počínaje jazykem C# 7.0 otestuje operátor také výsledek is výrazu se vzorem.

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

E is T

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

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

  • Typ běhu výsledku výrazu je T .

  • Typ běhu výsledku výrazu je odvozen z typu , implementuje rozhraní nebo z něj existuje jiný implicitní převod T T odkazu na T .

  • Typ běhu výsledku výrazu je hodnotový typ s možnou hodnotou null s podkladovým typem a T je Nullable<T>.HasValue true .

  • Převod typu boxing nebo unboxing existuje z typu za běhu výsledku výrazu na typ T .

Operátor is neuvažuje o uživatelem definovaných převodech.

Následující příklad ukazuje, že operátor vrátí, pokud typ běhu výsledku výrazu je odvozen z daného typu, to znamená, že existuje převod odkazu is true 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
    }
}

Další příklad ukazuje, že operátor bere v úvahu převody typu boxing a unboxing, ale neuvažuje o is číselných převodech:

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řevody specifikace jazyka C#.

Testování typů s porovnáváním vzorů

Počínaje jazykem C# 7.0 otestuje operátor také výsledek is výrazu se vzorem. Následující příklad ukazuje, jak použít vzor deklarace ke kontrole typu 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 explicitně převede výsledek výrazu na daný odkaz nebo as typ hodnoty s možnou hodnotou null. Pokud převod není možný, vrátí as operátor null . Na rozdíl od výrazupřetypování as operátor nikdy nevy vyvolá výjimku.

Výraz formuláře

E as T

kde je výraz, který vrací hodnotu a je název typu nebo parametr typu, produkuje E T stejný výsledek jako

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

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

Operátor as bere v úvahu pouze převody typu reference, nullable, boxing a unboxing. Operátor nelze 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í as operátoru :

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, musíte porovnat výsledek výrazu s a zkontrolovat, as null jestli je převod úspěšný. Počínaje jazykem C# 7.0 můžete použít operátor is k otestování, jestli je převod úspěšný, a pokud bude úspěšný, přiřadit jeho výsledek nové proměnné.

Výraz přetypování

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 E na typ , dojde k chybě při T kompilaci. Za běhu nemusí explicitní převod být ú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řevody specifikace jazyka C#. Informace o tom, jak definovat vlastní explicitní nebo implicitní převod typu, najdete v tématu Uživatelsky definované operátory převodu.

Další použití ()

Závorky se také používají k volání metody nebo volání delegáta.

Jiné použití závorek je úprava 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á instanci pro System.Type typ. Argument operátoru musí být název typu nebo parametr typu, jak typeof 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 typ, který vyžaduje poznámky k metadatům. Mezi příklady patří následující typy:

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

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

Můžete také použít operátor typeof s nevázanými obecnými typy. Název nevázaného obecného typu musí obsahovat odpovídající počet čárek, což je 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 argumentem typeof operátoru. K získání System.Type instance pro typ běhu výsledku výrazu použijte Object.GetType metodu .

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

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

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 , a is as nelze 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ést výrazem přetypování. Další informace najdete v tématu Uživatelsky definované operátory převodu.

specifikace jazyka C#

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

Viz také