Question

This seems to work for me, but was wondering if there are any issues with it

 class Test
    {
        public int PKId { get; set; }
        public string RequiredString { get; set; }
        public int RequiredInt { get; set; }
        public decimal RequiredMoney { get; set; }
        public bool RequiredBool { get; set; }
        public DateTime RequiredDate { get; set; }
        public string NullableString { get; set; }
        public int? NullableInt { get; set; }
        public decimal? NullableMoney { get; set; }
        public bool? NullableBool { get; set; }
        public DateTime? NullableDate { get; set; }
    }

The testDatabase matches the class as far as nulls are concerned.

  static internal T NullConvertFromDB<T>(object value) 
        {
            if (value.Equals(DBNull.Value))
            {
                return default(T);
            }
            else
            {
                return (T)value;
            }
        }

        static internal object NullConvertToDB<T>(object value)
        {
            if (value == null)
                return System.DBNull.Value;
            else
                return (T)value;
        }

While retrieving data I use

 Test test = new Test();
                        test.PKId = dr.GetInt32(0);
                        test.RequiredString = dr.GetString(1);
                        test.RequiredInt = dr.GetInt32(2);
                        test.RequiredMoney = (decimal)dr.GetSqlMoney(3);
                        test.RequiredBool = dr.GetBoolean(4);
                        test.RequiredDate = dr.GetDateTime(5);
                        test.NullableString = NullConvertFromDB<string>(dr[6]);
                        test.NullableInt = NullConvertFromDB<int?>(dr[7]);
                        test.NullableMoney = NullConvertFromDB<decimal?>(dr[8]);
                        test.NullableBool = NullConvertFromDB<bool?>(dr[9]);
                        test.NullableDate = NullConvertFromDB<DateTime?>(dr[10]);

And inserting I use

 cmd.Parameters.AddWithValue("@RequiredString", test.RequiredString);
                    cmd.Parameters.AddWithValue("@RequiredInt", test.RequiredInt);
                    cmd.Parameters.AddWithValue("@RequiredMoney", test.RequiredMoney);
                    cmd.Parameters.AddWithValue("@RequiredBool", test.RequiredBool);
                    cmd.Parameters.AddWithValue("@RequiredDate", test.RequiredDate);
                    cmd.Parameters.AddWithValue("@NullableString", NullConvertToDB<string>(test.NullableString));
                    cmd.Parameters.AddWithValue("@NullableInt", NullConvertToDB<int?>(test.NullableInt));
                    cmd.Parameters.AddWithValue("@NullableMoney", NullConvertToDB<decimal?>(test.NullableMoney));
                    cmd.Parameters.AddWithValue("@NullableBool", NullConvertToDB<bool?>(test.NullableBool));
                    cmd.Parameters.AddWithValue("@NullableDate", NullConvertToDB<DateTime?>(test.NullableDate));

This works great but was wondering if there is anything I need to be aware of before I implement in in my DAL.

Regards

_Eric

Answer 1

As a minor thing, is would probably be more efficient:

if (value == null || value is DBNull) {... null code...}

as a second thought, I don’t like the fact that if T=int you will get 0 for a null; I’d want an error. I’d be tempted to use:

return (T)(object)null;

which should work for reference types and Nullable<T> correctly, and raise an error for int etc.

---

In ConvertToDb, the return (T)value; is redundant, since you are actually returning object; you may as well just:

return value ?? DBNull.Value;

(in both cases)

---

So:

    static internal T NullConvertFromDB<T>(object value) 
    {
        if (value == null || value is DBNull)
        {
            return (T)(object)null;
        }
        return (T)value;
    }

    static internal object NullConvertToDB<T>(object value)
    {
        return value ?? DBNull.Value;
    }