SqlDataReader Meilleure façon de vérifier les valeurs nulles -sqlDataReader.IsDBNull vs DBNull.Value

Je veux récupérer les valeurs décimales à partir de la base de données et je voudrais savoir qui est la méthode recommandée pour vérifier les valeurs null.

J'ai vu sur MSDN - DBNull.Champ De Valeur que cette case est rarement utilisé.

C'est donc le reader.IsDBNull le meilleur/le plus efficace pour vérifier les valeurs null?

J'ai créé 2 exemples de méthodes:

public static decimal? GetNullableDecimal(SqlDataReader reader, string fieldName)
{
    if (reader[fieldName] == DBNull.Value)
    {
        return null;
    }
    return (decimal)reader[fieldName];
}

public static decimal? GetNullableDecimal_2(SqlDataReader reader, string fieldName)
{
    if (reader.IsDBNull(reader[fieldName]))
    {
         return null;
    }
    return (decimal)reader[fieldName];
}

La plupart du temps, les champs vont être null.

Merci d'avance!

source d'informationauteur diver

  1. 28

    Je ne voudrais pas faire trop pris dans la quelle méthode est la meilleure, parce que à la fois le travail et je l'ai utilisé à la fois dans le code avant.

    Par exemple, voici une fonction d'utilité, j'ai creusé d'un de mes vieux projets:

    ///<summary>
///Helper class for SqlDataReader, which allows for the calling code to retrieve a value in a generic fashion.
///</summary>
public static class SqlReaderHelper
{
    private static bool IsNullableType(Type theValueType)
    {
        return (theValueType.IsGenericType && theValueType.GetGenericTypeDefinition().Equals(typeof(Nullable<>)));
    }

    ///<summary>
    ///Returns the value, of type T, from the SqlDataReader, accounting for both generic and non-generic types.
    ///</summary>
    ///<typeparam name="T">T, type applied</typeparam>
    ///<param name="theReader">The SqlDataReader object that queried the database</param>
    ///<param name="theColumnName">The column of data to retrieve a value from</param>
    ///<returns>T, type applied; default value of type if database value is null</returns>
    public static T GetValue<T>(this SqlDataReader theReader, string theColumnName)
    {
        //Read the value out of the reader by string (column name); returns object
        object theValue = theReader[theColumnName];

        //Cast to the generic type applied to this method (i.e. int?)
        Type theValueType = typeof(T);

        //Check for null value from the database
        if (DBNull.Value != theValue)
        {
            //We have a null, do we have a nullable type for T?
            if (!IsNullableType(theValueType))
            {
                //No, this is not a nullable type so just change the value's type from object to T
                return (T)Convert.ChangeType(theValue, theValueType);
            }
            else
            {
                //Yes, this is a nullable type so change the value's type from object to the underlying type of T
                NullableConverter theNullableConverter = new NullableConverter(theValueType);

                return (T)Convert.ChangeType(theValue, theNullableConverter.UnderlyingType);
            }
        }

        //The value was null in the database, so return the default value for T; this will vary based on what T is (i.e. int has a default of 0)
        return default(T);
    }
}

    Utilisation:

    yourSqlReaderObject.GetValue<int?>("SOME_ID_COLUMN");
yourSqlReaderObject.GetValue<string>("SOME_VALUE_COLUMN");
  2. 6

    Si vous voulez vérifier la nullité et de les traiter (par opposition à la vérification de la valeur null et alerter le programme qu'il était nul), vous pouvez utiliser le as opérateur avec le null-coalescence de l'opérateur ??.
    Donc dans mon programme

    SqlDataReader dr = cmd.ExecuteReader();
while (dr.Read())
{
    response.Employees.Add(new Employee() { Id = dr["id"] as int? ?? default(int), ImageUrl = dr["Photo"] as string, JobTitle = dr["JobTitle"] as string });
}
  3. 1

    Voici une version simplifiée de @Karl Anderson réponse:

    public static class DbHelper
{
    public static T GetValue<T>(this SqlDataReader sqlDataReader, string columnName)
    {
        var value = sqlDataReader[columnName];

        if (value != DBNull.Value)
        {
            return (T)value;
        }

        return default(T);
    }
}

    Ou encore:

    public static class DbHelper
{
    public static T GetValue<T>(this SqlDataReader sqlDataReader, string columnName)
    {
        var value = sqlDataReader[columnName];

        return value == DBNull.Value ? default(T) : (T) value;
    }
}

    Directe casting semble très bien fonctionner pour les valeurs null ou non les types nullables.