Wat doet deze operator precies?

De operator retourneert de left-hand als deze niet null is, als dit wel het geval is dan retourneert hij de right-hand. Dit houdt ook in dat deze operator alleen gebruikt kan worden met nullable types. Zodra je deze gebruikt bij een niet nullable type zal je de compile error Compiler Error CS0019 om je oren krijgen.

Even een code voorbeeld om de werking van de ?? operator te verduidelijken:

int? a;
int b = a ?? 100;

Hier zal variable b dus geinitializeerd worden met de waarde 100.
Dit komt omdat variable a een null waarde bevat en de ?? operator zal dus de right-hand retourneren.

int? a = 1;
int b = a ?? 100;

Hier zal variable b dus geinitializeerd worden met de waarde 1.
Dit komt omdat variable a geen null waarde bevat maar de integere waarde 1 en zal deze dus geretourneerd worden.

Als dit nog niet duidelijk genoeg is, hier een code voorbeeld die hetzelfde doet op 3 verschillende manieren:

int? a = null;
int b;
 
// If construction
if( a.HasValue )
{
    b = a.Value;
}
else
{
    b = 100;
}
 
// ?: operator
b = ( a.HasValue ? a.Value : 100 );
 
// ?? operator
b = a ?? 100;

Alle drie de methodes hebben hetzelfde resultaat, alleen de ?? operator is wat mij betreft een stuk leesbaarder!

Performance winst!

Niet alleen de leesbaarheid gaat vooruit, maar het kan ook performance winst opleveren. In de vorige code voorbeelden is a een variable. Maar wat nu als we a vervangen door een complexe tijdrovende method?

In het geval van de if constructie zal de method twee keer uitgevoerd worden als de return waarde niet null is. Bij de ?: operator is dit ook het geval.
Je kunt dit oplossen door de return waarde van de complexe tijdrovende method eerst in een variable te stoppen en deze variable te controleren en verder te gebruiken.
Maar bij de ?? operator is dit niet nodig!

Bij de ?? operator word de left-hand maar 1 keer uitgelezen en de return waarde word vast gehouden. Als deze niet null is zal de left-hand niet nogmaal bekeken worden, maar de vast gehouden return waarde van de left-hand zal geretourneerd worden.

In het kort

Reden genoeg dus om de ?? operator te gebruiken! Maar hier heb je alles nog even op een rijtje:

• Leesbaarder dan de ?: operator
• Leesbaarder dan een if-else constructie
• Performance, left-side word maar 1 keer bekeken

TrackBack URI for this entry

Comments (4)

Subscribe to this comment's feed

...
written by Marcel van Eijkel, januari 20, 2009

Hallo Erik Burger,

Je vraag om objectieve voorbeelden voor de "??" heeft mij aan het denken gezet.

In eerste instantie dacht ik dat voordelen misschien wel per definitie subjectief zijn.
Is dat niet waarom wij "Software Engineers" (IEEE definitie) zijn? In elke omgeving en situatie is een andere oplossing nodig. Dit vindt zijn oorsprong in de verschillende bedrijfsdoelstellingen en historie van de organisatie waar wij die oplossing voor ontwikkelen. Maar dat even terzijde.

Een aantal minder subjectieve voordelen zijn misschien abstractie en consistentie, ik zal je uitleggen wat ik daarmee bedoel:

- abstractie: door het gebruik van deze operator kan de implementatie(Intermediate Language Code gegenereerd door de compiler) in de toekomst worden aangepast. Denk bijvoorbeeld aan verbeteringen in .Net Service packs bijvoorbeeld op het gebied van performance. Dat zou minder voor de hand liggend zijn wanneer je deze operator niet zou gebruiken. Een concreet voorbeeld is bijvoorbeeld het gebruik van een type alias "int" in plaat van "System.Int32". Door deze abstractie kan de compiler de implementatie ervan aanpassen en dat gebeurd wanneer je bijvoorbeeld voor een 32 bits platform compileert.

- consistentie: het vervangen van de null waarde kun je op veel verschillende manieren doen. Zoveel ontwikkelaars zoveel mogelijkheden lijkt het soms wel. Het gebruik van een operator heeft vanzelfsprekend altijd de voorkeur ten opzichte van zelf geschreven functies en is daarom als vanzelfsprekend de standaard. Als iedereen dus weet wat hij zou moeten weten en doet wat hij zou moeten doen (een paradox maar altijd beter dan het alterantief) dan wordt de code dus consistenter, beter begrijpbaar en beter onderhoudbaar.

Bovendien is het gebruik van operators, indien juist geïmplementeerd, intuïtiever. Maar dat is weer subjectief.

De oplettende lezer merkt trouwens de overeenkomsten tussen bovenstaande en de Software Engineering Principles op.

Hopelijk heb je er iets aan.

Marcel van Eijkel
Http://blog.vaneijkel.com

• 
• +0
• 
• 

...
written by Erik Burger, oktober 27, 2008

Dat was een van de eerste voorbeelden die ik probeerde..helaas

Maar thanks for de poging!

• 
• +0
• 
• 

...
written by Pieter Joost van de Sande, oktober 24, 2008

Misschien is dit een goed voorbeeld?:

public String Title
{
get
{
return (String)ViewState[“Title”] ?? “Welcome!”;
}
}

• 
• +0
• 
• 

...
written by Erik Burger, oktober 24, 2008

Probleem met uitingen als "een stuk leesbaarder" is dat ze subjectief zijn..mijn collega begint al te mopperen als ik een "return SomeFunction();" neerpen. Ik probeer nu een voorbeeld te vinden die eens en voor altijd de kracht van de ?? operator laat zien..no luck sofar maar ik geef niet op

• 
• +0
• 
• 

Name

Email

Website

Comment

smaller | bigger

Subscribe via email (Registered users only)

Add Comment