¿Cómo parametrizar una cadena nula con DBNull.Value clara y rápidamente

Question

Me cansé de escribir el siguiente código:

/* Commenting out irrelevant parts 
public string MiddleName; 
public void Save(){ 
    SqlCommand = new SqlCommand(); 
    // blah blah...boring INSERT statement with params etc go here. */ 
    if(MiddleName==null){ 
     myCmd.Parameters.Add("@MiddleName", DBNull.Value); 
    } 
    else{ 
     myCmd.Parameters.Add("@MiddleName", MiddleName); 
    } 
    /* 
    // more boring code to save to DB. 
}*/ 

Así, escribí esto:

public static object DBNullValueorStringIfNotNull(string value) 
{ 
    object o; 
    if (value == null) 
    { 
     o = DBNull.Value; 
    } 
    else 
    { 
     o = value; 
    } 
    return o; 
} 

// which would be called like: 
myCmd.Parameters.Add("@MiddleName", DBNullValueorStringIfNotNull(MiddleName)); 

Si esto es una buena forma de hacerlo, ¿qué sugieres como nombre del método? DBNullValueorStringIfNotNull es un poco detallado y confuso.

También estoy abierto a formas de aliviar este problema por completo. ME ENCANTARÍA hacer esto:

myCmd.Parameters.Add("@MiddleName", MiddleName==null ? DBNull.Value : MiddleName); 

pero eso no funcionará porque el "Operador" ?? no se puede aplicar a operandos de tipo 'cadena' y 'System.DBNull' ".

Tengo C# 3.5 y SQL Server 2005 a mi disposición si es importante.

Answer 1

Emitir cualquiera de sus valores a object y compilará.

myCmd.Parameters.Add("@MiddleName", MiddleName==null ? (object)DBNull.Value : MiddleName); 

Answer 2

Yeap, nos encantaría hacer myCmd.Parameters.Add("@MiddleName", MiddleName ?? DBNull.Value);. O mejor aún, tenga la capa SqlClient freakin 'entender que CLR null se debe mapear a DBNull.Value al agregar un parámetro. Desafortunadamente, el sistema de tipo .Net cierra la primera alternativa y la implementación de SqlClient cierra la segunda.

Iría con un nombre de función bien conocido, como Coalesce o IsNull. Cualquier desarrollador de DB reconocerá lo que hacen en un instante, solo desde el nombre.

Answer 3

Personalmente esto es lo que haría con un método de extensión (asegurarse de que esto sucede en una clase estática)

public static object GetStringOrDBNull(this string obj) 
{ 
    return string.IsNullOrEmpty(obj) ? DBNull.Value : (object) obj 
} 

entonces tendría

myCmd.Parameters.Add("@MiddleName", MiddleName.GetStringOrDBNull()); 

Answer 4

Yo prefiero darle dos sugerencias totalmente diferentes:

1. Utilice un ORM. Hay muchas herramientas ORM no intrusivas.

2. Escribe tu propia envoltura para construir comandos, con una interfaz más limpia.Algo así como:

   public class MyCommandRunner { 
       private SqlCommand cmd; 
   
       public MyCommandRunner(string commandText) { 
       cmd = new SqlCommand(commandText); 
       } 
   
       public void AddParameter(string name, string value) { 
       if (value == null) 
       cmd.Parameters.Add(name, DBNull.Value); 
       else 
        cmd.Parameters.Add(name, value); 
       } 
   
       // ... more AddParameter overloads 
   } 
   

Si cambia el nombre de sus AddParameter métodos para simplemente Add, que se puede utilizar de una manera muy elegante:

var cmd = new MyCommand("INSERT ...") 
    { 
    { "@Param1", null }, 
    { "@Param2", p2 } 
    }; 

Answer 5

se recomienda usar propiedades con valores nulos en lugar de campos públicos y un método 'AddParameter' (no sé si este código está optimizado o es correcto, solo fuera de mi cabeza):

private string m_MiddleName; 

public string MiddleName 
{ 
    get { return m_MiddleName; } 
    set { m_MiddleName = value; } 
} 

. 
. 
. 

public static void AddParameter(SQLCommand cmd, string parameterName, SQLDataType dataType, object value) 
{ 
    SQLParameter param = cmd.Parameters.Add(parameterName, dataType); 

    if (value is string) { // include other non-nullable datatypes 
    if (value == null) { 
     param.value = DBNull.Value; 
    } else { 
     param.value = value; 
    } 
    } else { 

    // nullable data types 
    // UPDATE: HasValue is for nullable, not object type 
    if (value.HasValue) // {{{===================================================== 
    { 
      param.value = value; 
    } else 
    { 
      param.value = DBNull.Value; 
    } 
    } 
} 

. 
. 
. 
AddParameter(cmd, "@MiddleName", SqlDbType.VarChar, MiddleName); 

Answer 6

@David Gracias por su sugerencia. El siguiente método funciona muy bien!

MiddleName ?? (object)DBNull.Value 

Answer 7

puede evitar el elenco explícita a object usando SqlString.Null en lugar de DBNull.Value:

MiddleName ?? SqlString.Null 

Hay correspondientes tipos de int, fecha y hora, y así sucesivamente. He aquí un fragmento de código con un par de ejemplos:

cmd.Parameters.AddWithValue("@StartDate", StartDate ?? SqlDateTime.Null); 
cmd.Parameters.AddWithValue("@EndDate", EndDate ?? SqlDateTime.Null); 
cmd.Parameters.AddWithValue("@Month", Month ?? SqlInt16.Null); 
cmd.Parameters.AddWithValue("@FormatID", FormatID ?? SqlInt32.Null); 
cmd.Parameters.AddWithValue("@Email", Email ?? SqlString.Null); 
cmd.Parameters.AddWithValue("@ZIP", ZIP ?? SqlBoolean.Null); 

Answer 8

myCmd.Parameters.Add("@MiddleName", MiddleName ?? (object)DBNull.Value);