C# SQL null convertir to-from, des problèmes avec cela?

Question

Cela semble fonctionner pour moi, mais me demandais s'il y a des problèmes avec elle

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; } 
    } 

Le testDatabase correspond la classe en ce qui concerne les valeurs nulles sont.

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; 
     } 

Lors de la récupération des données que j'utilise

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]); 

et insertion j'utilise

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)); 

Cela fonctionne très bien, mais me demandais s'il y a quelque chose que je dois être au courant avant de mettre en œuvre dans mon DAL.

Cordialement

_Eric

Answer 1

comme une chose mineure, is serait probablement plus efficace:

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

comme secondes pensée, je n'aime pas le fait que si T=int vous obtiendrez 0 pour un null; Je voudrais une erreur. Je serais tenté d'utiliser:

return (T)(object)null; 

qui devrait fonctionner pour les types de référence et Nullable<T> correctement, et soulever une erreur pour int etc.

---

En ConvertToDb, le return (T)value; est redondant, puisque vous sont en train de retourner object; vous pouvez tout aussi bien:

return value ?? DBNull.Value; 

(dans les deux cas)

---

Alors:

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; 
    }