Impossible de convertir un objet de type «System.DBNull» en type «System.String»

J'ai eu l'erreur ci-dessus dans mon application. Voici le code original

public string GetCustomerNumber(Guid id)
{
     string accountNumber = 
          (string)DBSqlHelperFactory.ExecuteScalar(connectionStringSplendidmyApp, 
                          CommandType.StoredProcedure, 
                          "GetCustomerNumber", 
                          new SqlParameter("@id", id));
     return accountNumber.ToString();
 }

J'ai remplacé par

public string GetCustomerNumber(Guid id)
{
   object accountNumber =  
          (object)DBSqlHelperFactory.ExecuteScalar(connectionStringSplendidCRM, 
                                CommandType.StoredProcedure, 
                                "spx_GetCustomerNumber", 
                                new SqlParameter("@id", id));
    if (accountNumber is System.DBNull)
    {
       return string.Empty;
    }
    else
    {
       return accountNumber.ToString();
    }
}

Y a-t-il un meilleur moyen de contourner cela?

Un formulaire plus court peut être utilisé:

return (accountNumber == DBNull.Value) ? string.Empty : accountNumber.ToString()

EDIT: Je n'ai pas fait attention à ExecuteScalar. Il renvoie vraiment null si le champ est absent du résultat renvoyé. Alors utilisez plutôt:

return (accountNumber == null) ? string.Empty : accountNumber.ToString() 

Avec une simple fonction générique, vous pouvez rendre cela très facile. Faites juste ceci:

return ConvertFromDBVal<string>(accountNumber);

en utilisant la fonction:

public static T ConvertFromDBVal<T>(object obj)
{
    if (obj == null || obj == DBNull.Value)
    {
        return default(T); // returns the default value for the type
    }
    else
    {
        return (T)obj;
    }
}

ExecuteScalar retournera

• null s'il n'y a pas de jeu de résultats
• sinon, la première colonne de la première ligne de l'ensemble de résultats, qui peut être DBNull.

Si vous savez que la première colonne du jeu de résultats est une chaîne, alors pour couvrir toutes les bases, vous devez vérifier à la fois null et DBNull. Quelque chose comme:

object accountNumber = ...ExecuteScalar(...);
return (accountNumber == null) ? String.Empty : accountNumber.ToString();

Le code ci-dessus repose sur le fait que DBNull.ToString renvoie une chaîne vide.

Si accountNumber était un autre type (par exemple, un entier), vous auriez besoin d'être plus explicite:

object accountNumber = ...ExecuteScalar(...);
return (accountNumber == null || Convert.IsDBNull(accountNumber) ?     
         (int) accountNumber : 0;

Si vous savez avec certitude que votre jeu de résultats aura toujours au moins une ligne (par exemple, SELECT COUNT (*) ...), vous pouvez ignorer la vérification de null.

Dans votre cas, le message d'erreur «Impossible de convertir un objet de type« System.DBNull »en type« System.String »» indique que la première colonne de votre jeu de résultats est une valeur DBNUll. C'est de la distribution à la chaîne sur la première ligne:

string accountNumber = (string) ... ExecuteScalar(...);

Le commentaire de Marc_s selon lequel vous n'avez pas besoin de vérifier DBNull.Value est faux.

Vous pouvez utiliser l'opérateur de fusion nul de C #

return accountNumber ?? string.Empty;

Il existe un autre moyen de contourner ce problème. Que diriez-vous de modifier la procédure de votre boutique? en utilisant la fonction SQL ISNULL (votre champ, ""), vous pouvez renvoyer une chaîne vide si la valeur de retour est nulle.

Ensuite, vous avez votre code propre en version originale.

C'est la méthode générique que j'utilise pour convertir tout objet qui pourrait être un DBNull.Value:

public static T ConvertDBNull<T>(object value, Func<object, T> conversionFunction)
{
    return conversionFunction(value == DBNull.Value ? null : value);
}

usage:

var result = command.ExecuteScalar();

return result.ConvertDBNull(Convert.ToInt32);

plus court:

return command
    .ExecuteScalar()
    .ConvertDBNull(Convert.ToInt32);

Je suppose que vous pouvez le faire comme ceci:

string accountNumber = DBSqlHelperFactory.ExecuteScalar(...) as string;

Si accountNumber est nul, cela signifie qu'il était DBNull et non une chaîne :)

String.Concat transforme les valeurs DBNull et null en une chaîne vide.

public string GetCustomerNumber(Guid id)
{
   object accountNumber =  
          (object)DBSqlHelperFactory.ExecuteScalar(connectionStringSplendidCRM, 
                                CommandType.StoredProcedure, 
                                "spx_GetCustomerNumber", 
                                new SqlParameter("@id", id));

    return String.Concat(accountNumber);

 }

Cependant, je pense que vous perdez quelque chose sur la compréhensibilité du code

Depuis que j'ai une instance qui n'est pas nulle et si je la compare à DBNULL, j'ai Operator '==' cannot be applied to operands of type 'string' and 'system.dbnull' exception, et si j'essayais de changer pour comparer à NULL, cela ne fonctionnait tout simplement pas (puisque DBNull est un objet) même c'est la réponse acceptée.

J'ai décidé d'utiliser simplement le mot-clé «est». Le résultat est donc très lisible:

data = (item is DBNull) ? String.Empty : item

J'utilise une extension pour éliminer ce problème pour moi, qui peut ou non être ce que vous recherchez.

Ça va comme ça:

public static class Extensions
{

    public String TrimString(this object item)
    {
        return String.Format("{0}", item).Trim();
    }

}

Remarque:

Cette extension ne renvoie pas denull valeurs! Si l'élément est nullou DBNull.Value , il renverra une chaîne vide.

Usage:

public string GetCustomerNumber(Guid id)
{
    var obj = 
        DBSqlHelperFactory.ExecuteScalar(
            connectionStringSplendidmyApp, 
            CommandType.StoredProcedure, 
            "GetCustomerNumber", 
            new SqlParameter("@id", id)
        );
    return obj.TrimString();
}

Convertissez-le comme

string s = System.DBNull.value.ToString();