Típusellenőrző operátorok és cast kifejezések – is, as, typeof és castok

Ezek az operátorok és kifejezések típusellenőrzést vagy típusátalakítást hajtanak végre. Az isoperátor ellenőrzi, hogy egy kifejezés futásidejű típusa kompatibilis-e egy adott típussal. Az asoperátor explicit módon konvertál egy kifejezést egy adott típusra, ha a futásidejű típusa kompatibilis ezzel a típussal. A öntött kifejezések explicit konverziót végeznek egy céltípusra. Az typeofoperátor lekérte a System.Type példányt egy típushoz.

A C# nyelv referenciadokumentuma a C# nyelv legújabb kiadású verzióját ismerteti. Emellett a közelgő nyelvi kiadás nyilvános előzetes verziójú funkcióinak kezdeti dokumentációját is tartalmazza.

A dokumentáció azonosítja azokat a funkciókat, amelyeket először a nyelv utolsó három verziójában vagy az aktuális nyilvános előzetes verziókban vezetnek be.

Jótanács

Ha meg szeretné tudni, hogy mikor jelent meg először egy funkció a C#-ban, tekintse meg a C# nyelvi verzióelőzményeiről szóló cikket.

A is operátort

Az is operátor ellenőrzi, hogy a kifejezés eredményének futásideje kompatibilis-e egy adott típussal. Az is operátor egy kifejezés eredményét is teszteli egy mintán.

A típustesztelési is operátorral rendelkező kifejezés az alábbi űrlapot tartalmazza

E is T

Hol E van az a kifejezés, amely egy értéket ad vissza, és T egy típus vagy egy típusparaméter neve. E nem lehet névtelen metódus vagy lambda kifejezés.

Az is operátor akkor ad true vissza értéket, ha egy kifejezés eredménye nem null, és az alábbi feltételek bármelyike igaz:

  • A kifejezés eredményének futásidejű típusa identitásátalakítással rendelkezik T.

  • A kifejezés eredményének futásidejű típusa típusból T, implementálási felületből Tszármazik, vagy egy másik implicit referenciakonvertálás létezik belőle T. Ez a feltétel az öröklési kapcsolatokat és a felület implementációit fedi le.

  • A kifejezés eredményének futásidejű típusa egy null értékű értéktípus az alapul szolgáló típussal T , és a Nullable<T>.HasValue következő true.

  • Ha a kifejezés nem egy példány, akkor a kifejezés eredményének futásidejű típusából létezik boxing vagy T konverzió a ref struct típusba.

Az is operátor nem veszi figyelembe a felhasználó által definiált konverziókat vagy implicit span konverziókat.

Az alábbi példa azt mutatja be, hogy az is operátor akkor ad vissza true értéket, ha egy kifejezés eredménye futásidejű típusa egy adott típusból származik, vagyis létezik referenciakonvertálás a típusok között:

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

A következő példa azt mutatja, hogy az operátor figyelembe veszi a is dobozolást és a dobozolás feloldását, de nem veszi figyelembe a numerikus konverziókat:

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

A C#-konverziókkal kapcsolatos információkért lásd a C# nyelv specifikációjának Konverziók fejezetét.

Típustesztelés mintaegyezéssel

Az is operátor egy kifejezés eredményét is teszteli egy mintán. Az alábbi példa bemutatja, hogyan használható deklarációs minta egy kifejezés futásidejű típusának ellenőrzésére:

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

A támogatott mintákról további információt a Minták című témakörben talál.

A as operátort

as Az operátorral explicit módon konvertálhatja egy kifejezés eredményét egy adott hivatkozási vagy nullértékű értéktípusra. Ha az átalakítás nem lehetséges, az operátor ad as vissza null. Az öntött kifejezéssel ellentétben az as operátor soha nem ad kivételt.

Az űrlap kifejezése

E as T

Hol E van az a kifejezés, amely egy értéket ad vissza, és T egy típus vagy egy típusparaméter neve, ugyanazt az eredményt hozza létre, mint a

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

Kivéve, hogy a E csak egyszer lesz kiértékelve.

Az as operátor csak hivatkozási, null értékű, boxing és unboxing konverziókat tekint. Az operátor nem használható as felhasználó által definiált átalakítás végrehajtására. Felhasználó által definiált átalakítás végrehajtásához használjon cast kifejezést.

Az alábbi példa az operátor használatát as mutatja be:

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

Feljegyzés

Ahogy az előző példa mutatja, össze kell hasonlítania a as kifejezés eredményét a null értékkel annak ellenőrzéséhez, hogy az átalakítás sikeres volt-e. Az operátorral tesztelheti, is hogy az átalakítás sikeres-e, és ha sikeres, rendelje hozzá az eredményt egy új változóhoz.

Öntött kifejezés

Az űrlap (T)E egy öntött kifejezése explicit módon típussá Ealakítja a kifejezés T eredményét. Ha a típustól E a típusig Tnem létezik explicit átalakítás, a fordító hibát ad ki. Futtatáskor előfordulhat, hogy egy explicit átalakítás nem sikerül, és egy leadott kifejezés kivételt jelenthet.

Az alábbi példa explicit numerikus és referenciakonvertálásokat mutat be:

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

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

A támogatott explicit konverziókkal kapcsolatos információkért tekintse meg a C#-nyelv specifikációjának Explicit konverziók szakaszát. Az egyéni explicit vagy implicit típusú átalakítás definiálásáról további információt a felhasználó által definiált konverziós operátorok című témakörben talál.

A () egyéb használati módjai

Zárójelek használatával meghívhat egy metódust, vagy meghívhat egy meghatalmazottat.

A zárójelek másik használata annak a sorrendnek a beállítása, amelyben a C# kiértékeli a kifejezés műveleteit. További információ: C# operátorok.

A typeof operátort

Az typeof operátor lekéri a System.Type példányt egy típushoz. Az operátor argumentumának typeof egy típus vagy egy típusparaméter nevének kell lennie, ahogy az alábbi példa mutatja:

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]

Az argumentum nem lehet olyan típus, amely metaadat-széljegyzeteket igényel. Ilyen típusok például a következő típusok:

  • dynamic
  • string? (vagy bármely null értékű hivatkozástípus)

Ezek a típusok nem jelennek meg közvetlenül a metaadatokban. A típusok az alapul szolgáló típust leíró attribútumokat tartalmaznak. Mindkét esetben használhatja a mögöttes típust. A dynamic helyett használja a következőt: object. A string? helyett használja a következőt: string.

Az operátort typeof kötetlen általános típusokkal is használhatja. A kötetlen általános típus nevének tartalmaznia kell a megfelelő számú vesszőt, ami egy kisebb, mint a típusparaméterek száma. Az alábbi példa az operátor kötetlen általános típussal való használatát typeof mutatja be:

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

A kifejezés nem lehet az typeof operátor argumentuma. A kifejezés eredményének futásidejű típusának példányának lekéréséhez System.Type használja a metódust Object.GetType .

Típustesztelés az typeof operátorral

typeof Az operátorral ellenőrizze, hogy a kifejezés eredményének futásideje pontosan egyezik-e egy adott típussal. Az alábbi példa az operátor és az operátor használatával typeof végzett típusellenőrzés közötti különbséget mutatja beis:

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

Operátorok túlterhelése

A , isés as operátorok typeofnem terhelhetők túl.

A felhasználó által definiált típus nem tudja túlterhelni az () operátort, de definiálhat egyéni típuskonverziókat, amelyeket egy leadott kifejezés hajt végre. További információ: Felhasználó által definiált konverziós operátorok.

C# nyelvspecifikáció

További információt a C# nyelvspecifikációjának alábbi szakaszaiban talál:

Lásd még

  • Last updated on