using System;

public class Program

{

    public static void Main()

    {

        int? x = null;

        Console.WriteLine(x.HasValue);

        var nInt = new NullableInt();

        NullableInt nInt2;

        Console.WriteLine(nInt2.HasValue);

        Console.WriteLine(nInt.GetValueOrDefault(-1));      // -1

        Console.WriteLine(nInt.HasValue);                   // False

        Console.WriteLine("\n");

        nInt.HasValue = true; // impliciet wordt de waarde gezet

        Console.WriteLine(nInt.GetValueOrDefault());        // 0

        Console.WriteLine(nInt.Value);                      // 0

        Console.WriteLine(nInt.HasValue);                   // True

        Console.WriteLine("\n");

        nInt.Value = 123;

        Console.WriteLine(nInt.GetValueOrDefault());        // 123

        Console.WriteLine(nInt.Value);                      // 123

        Console.WriteLine(nInt.HasValue);                   // True

        Console.WriteLine("\n");

        nInt.HasValue = false;

        Console.WriteLine(nInt.GetValueOrDefault());        // 0

        try {

            Console.WriteLine(nInt.Value);                  // Exception

        }

        catch (Exception ex) 

        {

            Console.WriteLine($"Deze fout is verwacht: {ex.Message}");  

        }

        Console.WriteLine(nInt.HasValue);                   // False

    }

}

​

// Base klasse voor gebruik van nullable types in Com

public struct NullableInt

{

    private int? _waarde;

    // Heeft het Nullable type een waarde of niet?

    public bool HasValue 

    { 

        get 

        {

            return _waarde.HasValue;    

        }

        set

        {

            if (value == _waarde.HasValue)

            {

                // Niets doen, nieuwe waarde komt overeen met bestaande waarde

            }

            else if (!value) 

            {

                // Waarde was gezet, maar wordt nu weer verwijderd

                _waarde = default(int?);    // null

            }

            else if (value) 

            {

                // Waarde was niet gezet, maar wordt nu gezet zonder dat daadwerkelijk een waarde is ingegeven.

                // Geen foutsituatie, maar door deze actie wordt de waarde impliciet op de default van het

                // non-nullable type gezet.

                _waarde = default(int);

            }

            else 

            {

                throw new ApplicationException($"Onverwachte situatie bij zetten van {nameof(HasValue)}");

            }

        }

    }

    // Obsolete markeren, deze nooit in .Net gebruiken

    public int Value 

    {

        get 

        {

            if(_waarde.HasValue) 

            {

                return _waarde.Value;   

            }

            // else

            throw new ApplicationException("Waarde van een Nullable type zonder waarde kan niet worden opgevraagd");

        }

        set 

        {

            _waarde = value;    

        }

    }

    // Deze mag niet COM-visible zijn

    public int? DotNetValue 

    {

        get { return _waarde; }

        set { _waarde = value; }

    }

    public NullableInt() 

    {

        // Onderstaande waarden worden expliciet gezet om de uitgangssituatie te verduidelijken

        _waarde = default(int?);    // null

    }

    public NullableInt(int waarde) 

    {

        _waarde = waarde;

    }

    public int GetValueOrDefault(int standaardwaarde = default(int)) 

    {

        return _waarde.HasValue ? _waarde.Value : standaardwaarde;  

    }

    // Operator overloading

    public static implicit operator NullableInt(int value) {

        return new NullableInt(value);

    }

} 

​