Dapper type handler nullable types

example-using-ValueTypeHandler.cs

void Main()
{
    SqlMapper.AddTypeHandler (typeof (Wrapper), WrapperHandler.Default);
    SqlMapper.AddTypeHandler (typeof (Wrapper?), WrapperHandler.Default);
    using (var db = new SqlConnection("Server=.;Database=tempdb;Integrated Security=SSPI")) {
        db.Open();
        db.Query<Foo> ("SELECT 1 AS A, NULL AS B, 2 AS C, 3 AS D, NULL AS E").Dump();
    }
}

class Foo
{
    public int A { get; set; }
    public int? B { get; set; }
    public Wrapper C { get; set; }
    public Wrapper? D { get; set; }
    public Wrapper? E { get; set; }
}

struct Wrapper
{
    public int Item { get; set; }
}

class WrapperHandler : ValueTypeHandler<Wrapper>
{
    public static readonly WrapperHandler Default = new WrapperHandler ();

    public override Wrapper Parse (object value)
    {
         return new Wrapper { Item = (int) value };
    }
    
    public override void SetValue (IDbDataParameter parameter, Wrapper value)
    {
        parameter.DbType = DbType.Int32;
        parameter.Value = value.Item;
    }
}

problem.cs

void Main()
{
    SqlMapper.AddTypeHandler<Wrapper> (WrapperHandler.Default);
    SqlMapper.AddTypeHandler<Wrapper?> (NullableWrapperHandler.Default);
    using (var db = new SqlConnection("Server=.;Database=tempdb;Integrated Security=SSPI")) {
        db.Open();
        db.Query<Foo> ("SELECT 1 AS A, NULL AS B, 2 AS C, 3 AS D, NULL AS E").Dump();
    }
}

class Foo
{
    public int A { get; set; }
    public int? B { get; set; }
    public Wrapper C { get; set; }
    public Wrapper? D { get; set; }
    public Wrapper? E { get; set; }
}

struct Wrapper
{
    public int Item { get; set; }
}

class WrapperHandler : SqlMapper.TypeHandler<Wrapper>
{
    public static readonly WrapperHandler Default = new WrapperHandler ();

    public override Wrapper Parse (object value)
    {
         return new Wrapper { Item = (int) value };
    }
    
    public override void SetValue (IDbDataParameter parameter, Wrapper value)
    {
        parameter.DbType = DbType.Int32;
        parameter.Value = value.Item;
    }
}

class NullableWrapperHandler : SqlMapper.TypeHandler<Wrapper?>
{
    public static readonly NullableWrapperHandler Default = new NullableWrapperHandler ();
    
    public override Wrapper? Parse (object value)
    {
        if (value == null || value == DBNull.Value) {
            return null;
        } else {
            return new Wrapper { Item = (int) value };
        }
    }
    
    public override void SetValue (IDbDataParameter parameter, Wrapper? value)
    {
        parameter.DbType = DbType.Int32;
        if (value == null) {
            parameter.Value = value.Value.Item;
        } else {
            parameter.Value = DBNull.Value;
        }
    }
}

ValueTypeHandler.cs

abstract class ValueTypeHandler<T> : SqlMapper.ITypeHandler where T : struct
{
    public abstract T Parse (object value);
    public abstract void SetValue(IDbDataParameter parameter, T value);

    object SqlMapper.ITypeHandler.Parse (Type destinationType, object value)
    {
        if (value == null) {
            return null;
        } else if (value is DBNull) {
            return null;
        } else {
            return Parse (value);
        }
    }
    
    void SqlMapper.ITypeHandler.SetValue (IDbDataParameter parameter, object value)
    {
        if (value is DBNull) {
            parameter.Value = value;
        } else {
            SetValue (parameter, (T) value);
        }
    }
}