Comment paramétrer une chaîne vide avec DBNull.Value clairement et rapidement

Question

Je suis fatigué d'écrire le code suivant:

/* 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. 
}*/ 

Alors, je l'ai écrit ceci:

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 cela est un bon moyen de faire cela alors que suggéreriez-vous comme nom de la méthode? DBNullValueorStringIfNotNull est un peu bavard et déroutant.

Je suis également ouvert aux moyens de résoudre ce problème entièrement. Je voudrais faire ceci:

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

mais cela ne fonctionnera pas parce que le "Opérateur" ?? ne peut pas être appliqué aux opérandes de type 'string et' System.DBNull '". J'ai le C# 3.5 et SQL Server 2005 à ma disposition si cela est important.

Answer 1

Convertissez l'une de vos valeurs en object et elle sera compilée.

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

Answer 2

Yeap, nous aimerions tous faire myCmd.Parameters.Add("@MiddleName", MiddleName ?? DBNull.Value);. Ou mieux encore, avez la couche SqlClient freakin 'comprendre que CLR null doit être mappé à DBNull.Value lors de l'ajout d'un paramètre. Malheureusement, le système de type .Net ferme la première alternative et l'implémentation de SqlClient ferme la seconde.

J'irais avec un nom de fonction bien connu, comme Coalesce ou IsNull. Tout développeur de DB reconnaîtra ce qu'il fait en un instant, à partir du nom seul.

Answer 3

Personnellement ce que je ferais avec une méthode d'extension (assurez-vous que ce qui se passe dans une classe statique)

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

Ensuite, vous auriez

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

Answer 4

Je préfère vous donner deux suggestions totalement différentes:

1. Utilisez un ORM. Il y a beaucoup d'outils ORM non intrusifs. Ecrivez votre propre emballage pour les commandes de construction, avec une interface plus propre.Quelque chose comme:

   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 vous Renommez vos méthodes AddParameter juste Add, vous pouvez l'utiliser d'une manière très lisse:

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

Answer 5

Je suggère d'utiliser les propriétés nullables au lieu des champs publics et une méthode 'AddParameter' (je ne sais pas si ce code est optimisé ou correct, juste du haut de ma tête):

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 Merci pour votre suggestion. La méthode suivante fonctionne très bien!

MiddleName ?? (object)DBNull.Value 

Answer 7

Vous pouvez éviter la distribution explicite à l'aide objectSqlString.Null au lieu de DBNull.Value:

MiddleName ?? SqlString.Null 

Il existe plusieurs types correspondants pour int, datetime, et ainsi de suite. Voici un extrait de code avec quelques autres exemples:

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