C#

struct Dummy{
    public string dummyvalue;
}

Dummy? dummyStrct = null; //This is possible

[Serializable, StructLayout(LayoutKind.Sequential)]
public class 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 Null(T value,bool allownull)
    {
        this.value = value;
        this.hasValue = true;
        this.allowNull = allownull;
    }
    public Null(bool allownull)
    {
        this.hasValue = false;
        this.allowNull = allownull;
    }
    public Null()
    {
        this.hasValue = false;
        this.allowNull = false;
    }

    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...

public static implicit operator Null<T>(object value)
{
    if (value is T)
        return new Null<T>(value);
    else if (value == null)
        return new Null<T>(null, true);
    else
        throw new Exception("this is bad, but find a better exception");
}

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

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

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

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

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

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...