Operatoren voor typetests en cast-expressies - , isas, typeofen cast-expressies

Deze operators en expressies voeren typecontrole of typeconversie uit. De isoperator controleert of het runtimetype van een expressie compatibel is met een bepaald type. De asoperator converteert expliciet een expressie naar een bepaald type als het runtimetype compatibel is met dat type. Cast-expressies voeren een expliciete conversie uit naar een doeltype. De typeofoperator verkrijgt het System.Type exemplaar voor een type.

De C#-taalreferentiedocumenten beschrijven de meest recent uitgebrachte versie van de C#-taal. Het bevat ook de eerste documentatie voor functies in openbare previews voor de aanstaande taalrelease.

De documentatie identificeert alle functies die voor het eerst zijn geïntroduceerd in de laatste drie versies van de taal of in de huidige openbare previews.

Aanbeveling

Raadpleeg het artikel over de versiegeschiedenis van de C#-taal om te achterhalen wanneer een functie voor het eerst is geïntroduceerd in C#.

De operator is

De is operator controleert of het uitvoeringstype van een expressieresultaat compatibel is met een bepaald type. De is operator test ook een expressieresultaat op basis van een patroon.

De expressie met de operator voor typetests is heeft het volgende formulier

E is T

Waar E is een expressie die een waarde retourneert en T de naam is van een type of een typeparameter. E kan geen anonieme methode of lambda-expressie zijn.

De is operator retourneert true wanneer een expressieresultaat niet null is en een van de volgende voorwaarden waar is:

• Het uitvoertijdtype van een expressieresultaat heeft een identiteitsconversie naar T.

• Het uitvoeringstype van een expressieresultaat is afgeleid van het type T, implementeert interface Tof een andere impliciete verwijzingsconversie bestaat van daaruit T. Deze voorwaarde omvat overnamerelaties en interface-implementaties.

• Het uitvoeringstype van een expressieresultaat is een null-waardetype met het onderliggende type T en het Nullable<T>.HasValue is true.

• Een boxingconversie of unboxingconversie bestaat van het uitvoeringstype van een expressieresultaat naar type T als de expressie geen exemplaar van een ref struct is.

De is operator houdt geen rekening met door de gebruiker gedefinieerde conversies of impliciete spanconversies.

In het volgende voorbeeld ziet u dat de is operator retourneert true als het uitvoeringstijdtype van een expressieresultaat is afgeleid van een bepaald type, dat wil gezegd, er een verwijzingsconversie bestaat tussen typen:

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

In het volgende voorbeeld ziet u dat de is operator rekening houdt met conversies voor boksen en het opheffen van vakken, maar geen rekening houdt met numerieke conversies:

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

Zie het hoofdstuk Conversies van de C#-taalspecificatie voor meer informatie over C#-conversies.

Typetests met patroonkoppeling

De is operator test ook een expressieresultaat op basis van een patroon. In het volgende voorbeeld ziet u hoe u een declaratiepatroon gebruikt om het uitvoeringstype van een expressie te controleren:

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

Zie Patronen voor meer informatie over de ondersteunde patronen.

De operator as

Gebruik de as operator om het resultaat van een expressie expliciet te converteren naar een bepaald verwijzings- of null-waardetype. Als de conversie niet mogelijk is, retourneert asde null operator . In tegenstelling tot een cast-expressie genereert de as operator nooit een uitzondering.

De expressie van het formulier

E as T

Waar E is een expressie die een waarde retourneert en T de naam van een type of een typeparameter is, levert hetzelfde resultaat op als

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

Behalve dat E slechts eenmaal wordt geëvalueerd.

De as operator beschouwt alleen verwijzings-, null-, boks- en uitboxingconversies. U kunt de operator niet gebruiken om een door de as gebruiker gedefinieerde conversie uit te voeren. Gebruik een cast-expressie om een door de gebruiker gedefinieerde conversie uit te voeren.

In het volgende voorbeeld ziet u het gebruik van de as operator:

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
}

Notitie

Zoals het voorgaande voorbeeld laat zien, moet u het resultaat van de as expressie vergelijken met null om te controleren of de conversie is geslaagd. U kunt de is operator beide gebruiken om te testen of de conversie slaagt en, als deze slaagt, het resultaat toe te wijzen aan een nieuwe variabele.

Cast-expressie

Met een cast-expressie van het formulier (T)E wordt het resultaat van de expressie E expliciet geconverteerd naar type T. Als er geen expliciete conversie bestaat van het type E naar type T, geeft de compiler een fout. Tijdens runtime slaagt een expliciete conversie mogelijk niet en kan een cast-expressie een uitzondering genereren.

In het volgende voorbeeld ziet u expliciete numerieke en verwijzingsconversies:

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

Zie de sectie Expliciete conversies van de C#-taalspecificatie voor informatie over ondersteunde expliciete conversies. Zie Door de gebruiker gedefinieerde conversies voor meer informatie over het definiëren van een aangepaste expliciete of impliciete typeconversie.

Andere gebruiksrechten van ()

U gebruikt ook haakjes om een methode aan te roepen of een gemachtigde aan te roepen.

Een ander gebruik van haakjes is het aanpassen van de volgorde waarin C# bewerkingen in een expressie evalueert. Zie C#-operators voor meer informatie.

De operator typeof

De typeof operator haalt het System.Type exemplaar voor een type op. Het argument voor de typeof operator moet de naam van een type of een typeparameter zijn, zoals in het volgende voorbeeld wordt weergegeven:

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]

Het argument kan geen type zijn waarvoor metagegevensaantekeningen zijn vereist. Voorbeelden van deze typen zijn de volgende typen:

• dynamic
• string? (of een null-verwijzingstype)

Deze typen worden niet rechtstreeks weergegeven in metagegevens. De typen bevatten kenmerken die het onderliggende type beschrijven. In beide gevallen kunt u het onderliggende type gebruiken. Gebruik dynamic in plaats van object. Gebruik string? in plaats van string.

U kunt de typeof operator ook gebruiken met niet-afhankelijke algemene typen. De naam van een niet-afhankelijk algemeen type moet het juiste aantal komma's bevatten, dat één kleiner is dan het aantal typeparameters. In het volgende voorbeeld ziet u het gebruik van de typeof operator met een niet-afhankelijk algemeen type:

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

Een expressie kan geen argument van de typeof operator zijn. Gebruik de System.Type methode om het Object.GetType exemplaar op te halen voor het uitvoeringstype van een expressieresultaat.

Typetests met de typeof operator

Gebruik de typeof operator om te controleren of het uitvoeringstype van het expressieresultaat exact overeenkomt met een bepaald type. In het volgende voorbeeld ziet u het verschil tussen typecontrole met behulp van de typeof operator en de 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
    }
}

Overbelasting van operatoren

U kunt de is, asen typeof operators niet overbelasten.

Een door de gebruiker gedefinieerd type kan de () operator niet overbelasten, maar kan aangepaste typeconversies definiëren die door een cast-expressie worden uitgevoerd. Zie Door de gebruiker gedefinieerde conversieoperators voor meer informatie.

C#-taalspecificatie

Zie de volgende secties van de C#-taalspecificatie voor meer informatie:

• De operator is
• De operator as
• Cast-expressies
• De operator typeof

Zie ook

• C#-operators en -expressies
• Veilig casten met behulp van patroonkoppeling en de is en als operators
• Generics in .NET