Odată cu tehnica numită pattern matching (căreia am să-ncerc să-i atribui traducerea verificare tipizată să văz cum se simte la limbaj) – o modalitate de-a verifica dacă o expresie întrunește anumite caracteristici (și de acționare pe baza rezultatului) – există o posibilitate mai apropiată de limbajul natural de-a testa dacă o variabilă are sau nu are valoarea NULL:

Company isNull = null;
Company isNotNull = new Company();

Console.WriteLine(isNull is null);
Console.WriteLine(isNotNull is not null);

Foto: Bogdan Stoica

Totuși, abordarea nu este complet identică din punct de vedere semantic cu folosirea operatorilor de egalitate (==), respectiv inegalitate (!=). La prima cercetare s-ar putea să pară contraintuitiv, însă, strict semantic, operatorul de egalitate verifică dacă-i egal, iar expresiile is/is not verifică dacă sunt ori nu sunt. Anumiți filozofi ar juisa până-n străfundul nădragilor.

Să exemplificăm acest lucru suprascriind operatorii astfel încât să returneze valoarea de adevăr false indiferent de obiectele comparate și vom vedea cum începe să adie a cunoscutul Informați-vă doar din surse oficiale:

class Company
{
    public static bool operator ==( Company left, 
        Company right )
    {
        return false;
    }

    public static bool operator !=( Company left, 
        Company right )
    {
        return false;
    }
}

Să verificăm acum ce obținem prin ambele abordări:

Company isNull = null;
Company isNotNull = new Company();

Console.WriteLine( $"Using (isNull == null): " +
    $"{isNull == null}" );
Console.WriteLine( $"Using (isNotNull != null): " +
    $"{isNotNull != null}" );

Console.WriteLine( $"Using (isNull is null): " +
    $"{isNull is null}" );
Console.WriteLine( $"Using (isNotNull is not null): " +
    $"{isNotNull is not null}" );

Deloc surprinzător (sau poate fi dacă nu știi cine ce-a făcut prin claia de cod):

Using (isNull == null): False
Using (isNotNull != null): False
Using (isNull is null): True
Using (isNotNull is not null): True

Ceea ce ar trebui să ridice întrebarea periferică: dacă surprascriem operatorii amintiți, astfel așezând premisele unei recursivități fără limită dacă, bunăoară, testarea pentru valoarea este efectuată tot cu operatorii surprascriși, ce alternativă exista înainte de verificarea tipizată? Nimic mai simplu: ReferenceEquals():

Company isNull = null;
Company isNotNull = new Company();

Console.WriteLine( $"Using (ReferenceEquals(isNull, null)): " +
    $"{ReferenceEquals(isNull, null)}" );
Console.WriteLine( $"Using (!ReferenceEquals(isNotNull, null)): " +
    $"{!ReferenceEquals(isNotNull, null)}" );

Iar rezultatul:

Using (ReferenceEquals(isNull, null)): True
Using (!ReferenceEquals(isNotNull, null)): True

Toate astea par niște vorbe de clacă și niște balade la pilictis. Să zicem doar că nu vă doriți să irosiți timp depanând anomalii cauzate de operatori suprascriși de-o manieră incompletă și, colac peste pupăză, nedocumentat.