C#

[Serializable, StructLayout(LayoutKind.Sequential)]
public struct Null<T> where T : struct
{
    private bool hasValue;
    private bool allowNull;
    internal T value;
    public Null(T value)
    {
        this.value = value;
        this.hasValue = true;
        this.allowNull = true;
    }

    public bool HasValue
    {
        get
        {
            return this.hasValue;
        }
    }
    public bool AllowNull
    {
        get
        {
            return this.allowNull;
        }
    }
    public T Value
    {
        get
        {
            if (!this.HasValue)
            {
                throw new InvalidOperationException("No Value!");
            }
            return this.value;
        }
    }
    public T GetValueOrDefault()
    {
        return this.value;
    }

    public T GetValueOrDefault(T defaultValue)
    {
        if (!this.HasValue)
        {
            return defaultValue;
        }
        return this.value;
    }

    public override bool Equals(object other)
    {
        if (!this.HasValue)
        {
            return (other == null);
        }
        if (other == null)
        {
            return false;
        }
        return this.value.Equals(other);
    }

    public override int GetHashCode()
    {
        if (!this.HasValue)
        {
            return 0;
        }
        return this.value.GetHashCode();
    }

    public override string ToString()
    {
        if (!this.HasValue)
        {
            return "";
        }
        return this.value.ToString();
    }

    public static implicit operator Null<T>(T value)
    {
        return new Null<T>(value);
    }

    public static explicit operator T(Null<T> value)
    {
        return value.Value;
    }
}

With great code, comes great complexity, so keep it simple stupid...