Weisen Sie einem SqlParameter null zu

Der folgende Code gibt einen Fehler aus: "Keine implizite Konvertierung von DBnull nach int."

SqlParameter[] parameters = new SqlParameter[1];    
SqlParameter planIndexParameter = new SqlParameter("@AgeIndex", SqlDbType.Int);
planIndexParameter.Value = (AgeItem.AgeIndex== null) ? DBNull.Value : AgeItem.AgeIndex;
parameters[0] = planIndexParameter;

Das Problem besteht darin, dass der ?:Operator den Rückgabetyp nicht ermitteln kann, da Sie entweder einen intWert oder einen Wert vom Typ DBNull zurückgeben, die nicht kompatibel sind.

Sie können die Instanz von AgeIndex natürlich als Typ umwandeln, objectder die ?:Anforderung erfüllt.

Sie können den ??Null-Koaleszenz-Operator wie folgt verwenden

SqlParameter[] parameters = new SqlParameter[1];     
SqlParameter planIndexParameter = new SqlParameter("@AgeIndex", SqlDbType.Int);
planIndexParameter.Value = (object)AgeItem.AgeIndex ?? DBNull.Value;
parameters[0] = planIndexParameter; 

Hier ist ein Zitat aus der MSDN-Dokumentation für den ?:Bediener, das das Problem erklärt

Entweder müssen der Typ des ersten und des zweiten Ausdrucks identisch sein, oder es muss eine implizite Konvertierung von einem Typ zum anderen vorhanden sein.

Die akzeptierte Antwort schlägt vor, eine Besetzung zu verwenden. Die meisten SQL-Typen verfügen jedoch über ein spezielles Nullfeld, mit dem diese Umwandlung vermieden werden kann.

Beispiel: SqlInt32.Null"Stellt einen DBNull dar, der dieser Instanz der SqlInt32-Klasse zugewiesen werden kann."

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

Sie müssen DBNull.Valuein SQLCommand als Nullparameter übergeben werden, es sei denn, in der gespeicherten Prozedur ist ein Standardwert angegeben (wenn Sie eine gespeicherte Prozedur verwenden). Der beste Ansatz besteht darin, DBNull.Valuefehlende Parameter vor der Ausführung der Abfrage zuzuweisen. Wenn Sie foreach folgen, wird der Job ausgeführt.

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

Andernfalls ändern Sie diese Zeile:

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

Wie folgt:

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

Da Sie in bedingten Anweisungen keine unterschiedlichen Wertetypen verwenden können, unterscheiden sich DBNull und int voneinander. Hoffe das wird helfen.

Versuchen Sie Folgendes mit einer Codezeile:

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

Versuche dies:

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;

Wenn Sie den bedingten (ternären) Operator verwenden, benötigt der Compiler eine implizite Konvertierung zwischen beiden Typen, andernfalls erhalten Sie eine Ausnahme.

Sie können das Problem beheben, indem Sie eines von beiden auf Folgendes übertragen System.Object:

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

Da das Ergebnis jedoch nicht wirklich hübsch ist und Sie sich immer an dieses Casting erinnern müssen, können Sie stattdessen eine solche Erweiterungsmethode verwenden:

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

Dann können Sie diesen kurzen Code verwenden:

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

Meiner Meinung nach ist es besser, dies mit der Parameters- Eigenschaft der SqlCommand- Klasse zu tun :

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

Erwägen Sie die Verwendung der verfügbaren Nullable (T) -Struktur. Sie können nur Werte festlegen, wenn Sie diese haben, und Ihre SQL-Befehlsobjekte erkennen den nullbaren Wert und verarbeiten ihn entsprechend, ohne dass Sie Probleme damit haben.

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

Versuche dies:

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

Mit anderen Worten, wenn der Parameter null ist, senden Sie ihn einfach nicht an Ihren gespeicherten Prozess (vorausgesetzt natürlich, dass der gespeicherte Prozess null Parameter akzeptiert, was in Ihrer Frage impliziert ist).

versuchen Sie so etwas:

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

Ich löse so.

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

Das mache ich einfach ...

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

Eine einfache Erweiterungsmethode hierfür wäre:

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

Ich benutze eine einfache Methode mit einer Nullprüfung.

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

Mein Code, der in einem realen Projekt arbeitet Schauen Sie sich den ternären Operator an, bevor Sie den SQL-Parameter erstellen. Dies ist der beste Weg für mich, ohne Probleme:

    public bool Key_AddExisting
    (
          string clave
        , int? idHito_FileServer
        , int? idTipoDocumental_Almacen
        , string tipoExp_CHJ
        , int idTipoExp_Verti2
        , int idMov_Verti2
    )
    {
        List<SqlParameter> pars = new List<SqlParameter>()
        {
              new SqlParameter { ParameterName = "@Clave", Value = clave }
    LOOK -> , idHito_FileServer == null ? new SqlParameter { ParameterName = "@IdHito_FileServer", Value = DBNull.Value } : new SqlParameter { ParameterName = "@IdHito_FileServer", Value = idHito_FileServer }
    LOOK -> , idTipoDocumental_Almacen == null ? new SqlParameter { ParameterName = "@IdTipoDocumental_Almacen", Value = DBNull.Value } : new SqlParameter { ParameterName = "@IdTipoDocumental_Almacen", Value = idTipoDocumental_Almacen }
            , new SqlParameter { ParameterName = "@TipoExp_CHJ", Value = tipoExp_CHJ }
            , new SqlParameter { ParameterName = "@IdTipoExp_Verti2", Value = idTipoExp_Verti2 }
            , new SqlParameter { ParameterName = "@IdMov_Verti2", Value = idMov_Verti2 }
        };

        string sql = "INSERT INTO [dbo].[Enlaces_ClavesCHJ_MovimientosVerti2] " +
            "( " +
            "  [Clave] " +
            ", [IdHito_FileServer] " +
            ", [IdTipoDocumental_Almacen] " +
            ", [TipoExp_CHJ] " +
            ", [IdTipoExp_Verti2] " +
            ", [IdMov_Verti2] " +
            ") " +
            "VALUES" +
            "( " +
            "  @Clave" +
            ", @IdHito_FileServer" +
            ", @IdTipoDocumental_Almacen" +
            ", @TipoExp_CHJ" +
            ", @IdTipoExp_Verti2" +
            ", @IdMov_Verti2" +
            ")";

        return DbBasic.ExecNonQuery(ref this.conn, sql, pars);
    }