De is en as keywords

Dankzij polymorfisme kunnen we dus child en parent-objecten door elkaar gebruiken. De keywords is en as gaan ons helpen om door het bos van objecten het bos nog te zien.

Het is keyword

Het is keyword is een operator die je kan gebruiken om te weten te komen of:

  • Een object van een bepaalde datatype is.
  • Een object een bepaalde interface bevat (zie volgende hoofdstuk).

De is operator heeft twee operanden nodig en geeft een bool terug als resultaat. De linkse operator moet een variabele zijn, de rechtse een datatype. Bijvoorbeeld:

bool ditIsEenStudent = mijnStudent is Student;

is voorbeeld

Stel dat we volgende drie klassen hebben:

internal class Voertuig {}

internal class Auto: Voertuig{}

internal class Persoon {}

Een Auto is een Voertuig. Een Persoon is géén Voertuig.

Stel dat we enkele variabelen hebben als volgt:

Auto mijnAuto = new Auto();
Persoon rambo = new Persoon();

We kunnen nu de objecten met is bevragen of ze van een bepaalde type zijn:

if(mijnAuto is Voertuig)
{
    Console.WriteLine("mijnAuto is een Voertuig");
}
if(rambo is Voertuig)
{
    Console.WriteLine("rambo is een Voertuig");
}

De uitvoer zal worden: mijnAuto is een Voertuig.

Met polymorfisme wordt dit voorbeeld echter interessanter. Wat als we een hoop objecten in een lijst van voertuigen plaatsen en nu enkel met de auto’s iets willen doen, dan kan dat:

List<Voertuig> alleMiddelen = new List<Voertuig>();
alleMiddelen.Add(new Voertuig());
alleMiddelen.Add(new Auto());
alleMiddelen.Add(new Voertuig());

foreach (var middel in alleMiddelen)
{
    if(middel is Auto)
    {
        //Doe iets met het huidige voertuig
    }
}

as keyword met voorbeeld

Wanneer we objecten van het ene naar het andere type willen omzetten dan doen we dit vaak met behulp van casting:

Student fritz = new Student();
Mens jos = (Mens)fritz;

Het probleem bij casting is dat dit niet altijd lukt. Indien de conversie niet mogelijk is zal een uitzondering gegenereerd worden en je programma zal crashen als je niet aan exception handling doet.

Het as keyword lost dit op. Het keyword zegt aan de compiler “probeer dit object te converteren. Als het niet lukt, zet het dan op null in plaats van een uitzondering op te werpen.”

De code van daarnet herschrijven we dan naar:

Student fritz = new Student();
Mens jos = fritz as Mens;

Indien nu de casting niet lukt (omdat Student misschien geen childklasse van Mens blijkt te zijn) dan zal jos de waarde null krijgen.

We kunnen dan vervolgens schrijven:

Student fritz = new Student();
Mens jos = fritz as Mens;
if(jos != null)
{
    //Doe Mens-zaken 
}
Belangrijk

as werkt enkel met reference types (objecten van klassen en interfaces). Je kan as dus niet gebruiken op gewone value types zoals int of bool. Iets als int getal = mijnObject as int; zal niet compileren. (Voor value types bestaat een variant met een vraagteken, maar die zien we hier nog niet.)

Tip

Wanneer is en wanneer as? Vuistregel: wil je het object daarna meteen gebruiken, kies dan as (één keer omzetten, dan op null controleren). Wil je enkel weten of een object van een bepaald type is (een ja/nee-vraag, zonder het daarna te gebruiken), dan volstaat is.

Stagiair Steven

Steven heeft een lijst met allerlei objecten en wil, als het eerste object een Student is, de naam ervan tonen. De A.I. gaf hem dit:

object eersteObject = alleObjecten[0];
object tweedeObject = alleObjecten[1];

if (eersteObject is Student)
{
   Student student = tweedeObject as Student;
   Console.WriteLine(student.Naam);
}

“Ik controleer met is of het een Student is, en gebruik daarna netjes as om te casten. Dat zou toch veilig moeten zijn?”, zegt hij.

Deze code compileert en draait soms prima, maar crasht soms met een NullReferenceException. Hoe kan dat, als Steven toch netjes controleert?

Steven controleert inderdaad netjes met is, maar op de verkeerde variabele: hij test eersteObject, maar cast en gebruikt vervolgens tweedeObject. Is eersteObject toevallig een Student, maar tweedeObject niet, dan is de if wel true, maar wordt student via as alsnog null, en crasht student.Naam. De is-check zegt dus niets over tweedeObject: die twee variabelen hebben niets met elkaar te maken. Zoiets ontstaat typisch door onzorgvuldig kopiëren en aanpassen van code: de controle en het gebruik moeten over dezelfde variabele gaan. Steven las zijn eigen code niet nauwkeurig genoeg om dat op te merken.

is geeft een bool terug; as geeft de referentie terug als het type klopt, anders null.

Pattern matching: is met een variabele

Moderne C# (sinds C# 7) laat toe om de is-controle en het omzetten in één stap te doen. Je plaatst gewoon een variabelenaam achter het type. Slaagt de is-check, dan zit het omgezette object meteen in die variabele klaar voor gebruik. Dit heet pattern matching.

In plaats van:

if(mijnAuto is Voertuig)
{
    Voertuig v = (Voertuig)mijnAuto;
    //...gebruik v
}

schrijf je korter en veiliger:

if(mijnAuto is Voertuig v)
{
    //v is hier meteen beschikbaar als Voertuig
}

Je zal deze vorm overal in moderne C#-code (en op StackOverflow) tegenkomen, dus het loont om ze te herkennen en te gebruiken.

Tip

In dezelfde geest schrijf je je null-controles tegenwoordig vaak met is null en is not null in plaats van == null en != null:

if (jos is not null)
{
    //...
}

Beide werken; is null / is not null is de modernere, iets veiligere schrijfwijze.

Volgorde van bewerkingen met is en as

De is en as keywords worden gebruik in logische expressie. Ze hebben dan ook een bepaalde volgorde wanneer ze verwerkt zullen worden. Onze bestaande volgorde van bewerkingen krijgt dus 2 nieuwe leden op lijn 4:

  1. Logische NIET: !
  2. Delen en vermenigvuldigen: *, /, %
  3. Optellen en aftrekken: +, -
  4. Relationele operators: <, <=, >, >= én is, as
  5. Gelijkheid: ==, !=
  6. Logische EN: &&
  7. Logische OF: ||