Wyjątek, gdy parametr AddWithValue ma wartość NULL

Mam następujący kod do określania parametrów zapytania SQL. Otrzymuję następujący wyjątek, kiedy używam Code 1; ale działa dobrze, gdy używam Code 2. W Code 2mamy czek na null, a więc if..elseblok.

Wyjątek:

Sparametryzowane zapytanie „(@application_ex_id nvarchar (4000)) SELECT E.application_ex_id A” oczekuje parametru „@application_ex_id”, który nie został dostarczony.

Kod 1 :

command.Parameters.AddWithValue("@application_ex_id", logSearch.LogID);

Kod 2 :

if (logSearch.LogID != null)
{
         command.Parameters.AddWithValue("@application_ex_id", logSearch.LogID);
}
else
{
        command.Parameters.AddWithValue("@application_ex_id", DBNull.Value );
}

PYTANIE

1. Czy możesz wyjaśnić, dlaczego nie można pobrać wartości NULL z wartości logSearch.LogID w kodzie 1 (ale jest w stanie zaakceptować DBNull)?

2. Czy istnieje lepszy kod do obsługi tego?

Odniesienie :

1. Przypisz null do SqlParameter
2. Zwrócony typ danych różni się w zależności od danych w tabeli
3. Błąd konwersji z bazy danych smallint na C # dopuszcza wartość null int
4. Jaki jest sens DBNull?

KOD

    public Collection<Log> GetLogs(LogSearch logSearch)
    {
        Collection<Log> logs = new Collection<Log>();

        using (SqlConnection connection = new SqlConnection(connectionString))
        {
            connection.Open();

            string commandText = @"SELECT  *
                FROM Application_Ex E 
                WHERE  (E.application_ex_id = @application_ex_id OR @application_ex_id IS NULL)";

            using (SqlCommand command = new SqlCommand(commandText, connection))
            {
                command.CommandType = System.Data.CommandType.Text;

                //Parameter value setting
                //command.Parameters.AddWithValue("@application_ex_id", logSearch.LogID);
                if (logSearch.LogID != null)
                {
                    command.Parameters.AddWithValue("@application_ex_id", logSearch.LogID);
                }
                else
                {
                    command.Parameters.AddWithValue("@application_ex_id", DBNull.Value );
                }

                using (SqlDataReader reader = command.ExecuteReader())
                {
                    if (reader.HasRows)
                    {
                        Collection<Object> entityList = new Collection<Object>();
                        entityList.Add(new Log());

                        ArrayList records = EntityDataMappingHelper.SelectRecords(entityList, reader);

                        for (int i = 0; i < records.Count; i++)
                        {
                            Log log = new Log();
                            Dictionary<string, object> currentRecord = (Dictionary<string, object>)records[i];
                            EntityDataMappingHelper.FillEntityFromRecord(log, currentRecord);
                            logs.Add(log);
                        }
                    }

                    //reader.Close();
                }
            }
        }

        return logs;
    }

Irytujące, prawda?

Możesz użyć:

command.Parameters.AddWithValue("@application_ex_id",
       ((object)logSearch.LogID) ?? DBNull.Value);

Możesz też użyć narzędzia takiego jak „elegancki”, które zrobi za Ciebie cały bałagan.

Na przykład:

var data = conn.Query<SomeType>(commandText,
      new { application_ex_id = logSearch.LogID }).ToList();

Mam pokusę, aby dodać metodę, aby uzyskać elegancki IDataReader... naprawdę nie wiem jeszcze, czy jest to dobry pomysł.

Łatwiej jest po prostu napisać metodę rozszerzenia dla tego, SqlParameterCollectionktóra obsługuje wartości null:

public static SqlParameter AddWithNullableValue(
    this SqlParameterCollection collection,
    string parameterName,
    object value)
{
    if(value == null)
        return collection.AddWithValue(parameterName, DBNull.Value);
    else
        return collection.AddWithValue(parameterName, value);
}

Następnie nazywasz to po prostu:

sqlCommand.Parameters.AddWithNullableValue(key, value);

Na wypadek, gdybyś robił to podczas wywoływania procedury składowanej: myślę, że łatwiej będzie to przeczytać, jeśli zadeklarujesz domyślną wartość parametru i dodasz ją tylko wtedy, gdy jest to konieczne.

SQL:

DECLARE PROCEDURE myprocedure
    @myparameter [int] = NULL
AS BEGIN

DO#:

int? myvalue = initMyValue();
if (myvalue.hasValue) cmd.Parameters.AddWithValue("myparamater", myvalue);

jakiś problem, dozwolony z Koniecznie ustawionym SQLDbType

command.Parameters.Add("@Name", SqlDbType.NVarChar);
command.Parameters.Value=DBNull.Value

gdzie SqlDbType.NVarChar wpisujesz. Koniecznie ustaw typ SQL.