Assign null à un SqlParameter

Les accepté de répondre suggère l'utilisation d'une fonte. Cependant, la plupart des types SQL ont un champ Nul qui peut être utilisé pour éviter cette distribution.

par exemple, SqlInt32.Null "représente un DBNull qui peut être assigné à cette instance de la classe SqlInt32."

int? example = null;
object exampleCast = (object) example ?? DBNull.Value;
object exampleNoCast = example ?? SqlInt32.Null;

il faut passer DBNull.Valeur comme paramètre null dans SQLCommand, à moins qu'une valeur par défaut ne soit spécifiée dans la procédure stockée (si vous utilisez la procédure stockée). La meilleure approche consiste à assigner DBNull.Valeur pour tout paramètre manquant avant l'exécution de la requête, et la foreach suivante fera le travail.

foreach (SqlParameter parameter in sqlCmd.Parameters)
{
    if (parameter.Value == null)
    {
        parameter.Value = DBNull.Value;
    }
}

autrement modifier cette ligne:

planIndexParameter.Value = (AgeItem.AgeIndex== null) ? DBNull.Value : AgeItem.AgeIndex;

comme suit:

if (AgeItem.AgeIndex== null)
    planIndexParameter.Value = DBNull.Value;
else
    planIndexParameter.Value = AgeItem.AgeIndex;

parce que vous ne pouvez pas utiliser différents types de valeurs dans l'énoncé conditionnel, comme DBNull et int sont différents les uns des autres. Espérons que cela aidera.

avec une ligne de code, essayez ceci:

var piParameter = new SqlParameter("@AgeIndex", AgeItem.AgeIndex ?? (object)DBNull.Value);

essayez ceci:

SqlParameter[] parameters = new SqlParameter[1];    
SqlParameter planIndexParameter = new SqlParameter("@AgeIndex", SqlDbType.Int);

planIndexParameter.IsNullable = true; // Add this line

planIndexParameter.Value = (AgeItem.AgeIndex== null) ? DBNull.Value : AgeItem.AgeIndex== ;
parameters[0] = planIndexParameter;

à mon avis, la meilleure façon est de le faire avec le paramètres propriété de la SqlCommand classe:

public static void AddCommandParameter(SqlCommand myCommand)
{
    myCommand.Parameters.AddWithValue(
        "@AgeIndex",
        (AgeItem.AgeIndex== null) ? DBNull.Value : AgeItem.AgeIndex);
}

envisager d'utiliser la structure(T) nulle disponible. Cela ne vous permettra de définir des valeurs que si vous les avez, et vos objets de commande SQL reconnaîtront la valeur nullable et traiteront en conséquence sans tracas de votre côté.

si vous utilisez l'opérateur conditionnel(ternaire) le compilateur a besoin d'une conversion implicite entre les deux types, sinon vous obtenez une exception.

pour que vous puissiez le fixer en moulant l'un des deux à System.Object :

planIndexParameter.Value = (AgeItem.AgeIndex== null) ? DBNull.Value : (object) AgeItem.AgeIndex;

mais comme le résultat n'est pas vraiment joli et que vous devez toujours vous souvenir de ce casting, vous pouvez utiliser une telle méthode d'extension à la place:

public static object GetDBNullOrValue<T>(this T val)
{
    bool isDbNull = true;
    Type t = typeof(T);

    if (Nullable.GetUnderlyingType(t) != null)
        isDbNull = EqualityComparer<T>.Default.Equals(default(T), val);
    else if (t.IsValueType)
        isDbNull = false;
    else
        isDbNull = val == null;

    return isDbNull ? DBNull.Value : (object) val;
}

, Alors vous pouvez utiliser ce code concis:

planIndexParameter.Value = AgeItem.AgeIndex.GetDBNullOrValue();

essayez ceci:

if (AgeItem.AgeIndex != null)
{
   SqlParameter[] parameters = new SqlParameter[1];
   SqlParameter planIndexParameter = new SqlParameter("@AgeIndex", SqlDbType.Int);
   planIndexParameter.Value = AgeItem.AgeIndex;
   parameters[0] = planIndexParameter;
}

en d'autres termes, si le paramètre est nul, ne l'envoyez pas à votre proc stocké (en supposant, bien sûr, que le proc stocké accepte les paramètres nuls qui sont implicites dans votre question).

essayez quelque chose comme ceci:

if (_id_categoria_padre > 0)
{
    objComando.Parameters.Add("id_categoria_padre", SqlDbType.Int).Value = _id_categoria_padre;
}
else
{
    objComando.Parameters.Add("id_categoria_padre", DBNull.Value).Value = DBNull.Value;
}

int? nullableValue = null;
object nullableValueDB
{
   get{
       if(nullableValue==null)
          return DBNull.Value;
       else
          return (int)nullableValue;
   }
}

Je résous comme ça.

if (_id_categoria_padre > 0)
{
    objComando.Parameters.Add("id_categoria_padre", SqlDbType.Int).Value = _id_categoria_padre;
}
else
{
    objComando.Parameters.Add("id_categoria_padre", DBNull.Value).Value = DBNull.Value;
}

if (AgeItem.AgeIndex== null)  
    cmd.Parameters.Add(new SqlParameter("ParaMeterName", SqlDbType.DateTime).Value = DBNull);  
else  
    cmd.Parameters.Add(new SqlParameter("ParaMeterName", SqlDbType.DateTime).Value = AgeItem.AgeIndex);

C'est tout simplement ce que je fais...

        var PhoneParam = new SqlParameter("@Phone", DBNull.Value);
        if (user.User_Info_Phone != null)
        {
            PhoneParam.SqlValue = user.User_Info_Phone;
        }

        return this.Database.SqlQuery<CustLogonDM>("UpdateUserInfo @UserName, @NameLast, @NameMiddle, @NameFirst, @Address, @City, @State, @PostalCode, @Phone",
            UserNameParam, NameLastParam, NameMiddleParam, NameFirstParam, AddressParam, CityParam, StateParam, PostalParam, PhoneParam).Single();

            dynamic psd = DBNull.Value;

            if (schedule.pushScheduleDate > DateTime.MinValue)
            {
                psd = schedule.pushScheduleDate;
            }


            sql.DBController.RunGeneralStoredProcedureNonQuery("SchedulePush",
                     new string[] { "@PushScheduleDate"},
                     new object[] { psd }, 10, "PushCenter");

une méthode d'extension simple pour cela serait:

    public static void AddParameter(this SqlCommand sqlCommand, string parameterName, 
        SqlDbType sqlDbType, object item)
    {
        sqlCommand.Parameters.Add(parameterName, sqlDbType).Value = item ?? DBNull.Value;
    }

y a-t-il quelque chose de mal à créer simplement le paramètre "nullable" faire?

    public SqlParameter GetNullableParameter(string parameterName, object value)
    {
        if (value == null)
        {
            return new SqlParameter(parameterName, value);
        }
        else
        {
            return new SqlParameter(parameterName, DBNull.Value);
        }
    }