Megosztás a következőn keresztül:

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 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 az öröklési kapcsolatokat és a felület implementációit ismerteti.

  • 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

Az as operátor explicit módon konvertálja egy kifejezés eredményét egy adott hivatkozási vagy null értékű tí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. Ehhez használjon egy öntött 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 a kifejezés E eredményének explicit átalakítását hajtja végre típusra T. Ha nem létezik explicit átalakítás a típus Etípusától T kezdve, fordítási időhiba lép fel. 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 a kifejezések műveleteinek kiértékelési sorrendjének módosítása. További információ: C# operátorok.

A typeof operátort

Az typeof operátor lekérte 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 metaadat-széljegyzeteket igénylő típus. Ilyenek 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. Ahelyett dynamic, hogy a object. Ahelyett string?, hogy a 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 típusellenőrzése typeof 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, asés typeof operátorok nem terhelhetők túl.

A felhasználó által definiált típus nem terhelheti túl az () operátort, de definiálhat egyéni típuskonverziókat, amelyeket egy öntvénykifejezé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