如何将 Nullable Bit 类型值传递给 SQL Server 存储过程？

Question

I want to pass null value to where clause bit type variable to get all rows in a table. But also when I pass true or false where clause should work in order to that.

Error:

Type of conditional expression cannot be determined because there is no implicit conversion between 'bool?'and 'System.DBNull'

Stored procedure:

CREATE PROCEDURE [dbo].[SelectAllUIDs] 
    @enable bit
AS
BEGIN
    SET NOCOUNT ON;

    SELECT 
        [UID], [fEnable] [Enable],
        [AddedDate] [Added Date]
    FROM 
        [VehicleService].[dbo].[NFCCard] 
    WHERE
        fEnable = @enable OR fEnable IS NOT NULL
    ORDER BY 
        NfcKy
END

C# code:

 public DataSet SelectUid(bool? status)
 {
        DataSet ds = new DataSet();

        try
        {
            SqlCommand com = new SqlCommand("SelectAllUIDs", con);
            com.CommandType = CommandType.StoredProcedure;
            com.Parameters.Add(new SqlParameter("@enable", SqlDbType.Bit)
                                   { Value = status != null ? status : DBNull.Value });

            SqlDataAdapter adp = new SqlDataAdapter(com);
            adp.Fill(ds);
        }
        catch (Exception ex)
        {
            ds = null;
            throw ex;
        }
        return ds;
    }

Calling:

DataSet ds = SelectUid(null); // should return all rows

DataSet ds = SelectUid(true); // should return fEnable = true rows

DataSet ds = SelectUid(false); // should return fEnable = false rows

Answer 1

You can use the ?? operator to provide an alternative for when the status is null . Like @user2864740 commented, both sides have to be compatible types. This won't work:

var x = true ?? DBNull.Value;  // "no implicit conversion" error

The left hand value of ?? is a bool , but the right hand value is not. So the compiler will complain DBNull.Value cannot be "implicitly cast" to bool . To solve this, cast the left hand side to object :

var x = (object) true ?? DBNull.Value;

Now ?? will evaluate to an object, which can contain both a bool and a DNull.Value . Applying that to your problem, you get:

com.Parameters.AddWithValue("@parname", (object) status ?? DBNull.Value);

Answer 2

I have a Nullable project, the above code generates compiler warnings and use this pattern

static object Nullable(bool? value)
{
    if (value is null)
        return DBNull.Value;
    else
        return value.Value;
}
static object Nullable(int? value)
{
    if (value is null)
        return DBNull.Value;
    else
        return value.Value;
}

The compiler knows what to pick so that gets solved without any issue during compile time no matter how many nullable data types I use.

my parameters I declare like this

com.Parameters.Add(
new SqlParameter("parameterName", SqlDbType.Bit) { Value  = Nullable(visitStat.Interactive), IsNullable=true });

I like to reduce reflection when I can and AddWithValue will cause reflection in MS code and you usually end up with the wrong data type in your parameterised queries when there is no need for it as you know the datatype when you write the code.

using reflection-based SQLParameter constructors is not too smart as when you do that SQL server will cast it into the proper data type in the execution plan making it a Row-By-Row operation. Particularly bad when using TSQL data types like SmallDatetime, date, TinyInt, CHAR, and VarChar data types as they always come out wrong.

You see this when passing strings as they always get reflected in nvarchar(max) compare an indexed email field with a nvarchar(max) parameter... have a look at implicit conversions , we know the data type it needs, the few extra characters we need to type in our program code are worth the hassle when "they say" that the "database is to slow" when it starts bigger than the tiny developer database that probably fits in memory.

Just because you can make a 1 liner in your code doesn't make it performant