检查 DBNull 然后分配给变量的最有效方法？

Question

这个问题偶尔会出现，但我还没有看到令人满意的答案。

典型的模式是（行是DataRow）：

 if (row["value"] != DBNull.Value)
 {
      someObject.Member = row["value"];
 }

我的第一个问题是哪个更有效（我已经翻转了条件）：

  row["value"] == DBNull.Value; // Or
  row["value"] is DBNull; // Or
  row["value"].GetType() == typeof(DBNull) // Or... any suggestions?

这表明 .GetType() 应该更快，但也许编译器知道一些我不知道的技巧？

第二个问题，是否值得缓存 row["value"] 的值，或者编译器是否会优化索引器？

例如：

  object valueHolder;
  if (DBNull.Value == (valueHolder = row["value"])) {}

注意：

1. row["value"] 存在。
2. 我不知道该列的列索引（因此不知道列名查找）。
3. 我特别询问关于检查 DBNull 然后分配（而不是关于过早优化等）。

我对几个场景进行了基准测试（时间以秒为单位，10,000,000 次试验）：

row["value"] == DBNull.Value: 00:00:01.5478995
row["value"] is DBNull: 00:00:01.6306578
row["value"].GetType() == typeof(DBNull): 00:00:02.0138757

Object.ReferenceEquals 与“==”具有相同的性能

最有趣的结果是什么？ 如果您按大小写不匹配列的名称（例如，“Value”而不是“value”，则大约需要十倍的时间（对于字符串）：

row["Value"] == DBNull.Value: 00:00:12.2792374

这个故事的寓意似乎是，如果您看不到按索引向上查找列，然后确保提供给索引器的列名称与 DataColumn 的名称完全匹配，

缓存该值的速度也几乎两倍：

No Caching: 00:00:03.0996622
With Caching: 00:00:01.5659920

因此，最有效的方法似乎是：

 object temp;
 string variable;
 if (DBNull.Value != (temp = row["value"]))
 {
      variable = temp.ToString();
 }

Answer 1

我肯定错过了什么。 不检查 DBNull 到底是什么 DataRow.IsNull方法有什么作用？

我一直在使用以下两种扩展方法：

public static T? GetValue<T>(this DataRow row, string columnName) where T : struct
{
    if (row.IsNull(columnName))
        return null;

    return row[columnName] as T?;
}

public static string GetText(this DataRow row, string columnName)
{
    if (row.IsNull(columnName))
        return string.Empty;

    return row[columnName] as string ?? string.Empty;
}

用法：

int? id = row.GetValue<int>("Id");
string name = row.GetText("Name");
double? price = row.GetValue<double>("Price");

如果您不希望 Nullable 返回 GetValue 的值，您可以轻松返回< code>default(T) 或其他一些选项。

---

顺便提一下，这里有一个 VB.NET 替代 Stevo3000 的建议：

oSomeObject.IntMember = If(TryConvert(Of Integer)(oRow("Value")), iDefault)
oSomeObject.StringMember = If(TryCast(oRow("Name"), String), sDefault)

Function TryConvert(Of T As Structure)(ByVal obj As Object) As T?
    If TypeOf obj Is T Then
        Return New T?(DirectCast(obj, T))
    Else
        Return Nothing
    End If
End Function

Answer 2

您应该使用该方法：

Convert.IsDBNull()

考虑到它是内置于框架中的，我希望这是最有效的。

我建议这样做：

int? myValue = (Convert.IsDBNull(row["column"]) ? null : (int?) Convert.ToInt32(row["column"]));

是的，编译器应该为您缓存它。

Answer 3

编译器不会优化索引器（即，如果您使用 row["value"] 两次），所以是的，它稍微更快：

object value = row["value"];

然后使用 value 两次； 如果它为 null，则使用 .GetType() 会带来问题...

DBNull.Value 实际上是一个单例，因此要添加第四个选项 - 您也许可以使用 ReferenceEquals - 但实际上，我认为您'我在这里担心太多了...我不认为“is”、“==”等之间的速度差异将成为您所看到的任何性能问题的原因。 分析您的整个代码并专注于重要的事情......不会是这个。

Answer 4

我将在 C# 中使用以下代码（VB.NET 并不那么简单）。

如果该值不为 null/DBNull，则代码会分配该值，否则它会分配默认值，该默认值可以设置为 LHS 值，从而允许编译器忽略分配。

oSomeObject.IntMemeber = oRow["Value"] as int? ?? iDefault;
oSomeObject.StringMember = oRow["Name"] as string ?? sDefault;

Answer 5

我觉得这里只有极少数的方法不会让潜在客户面临最担心的风险（Marc Gravell、Stevo3000、Richard Szalay、Neil、Darren Koppand），而且大多数方法都不必要地复杂。 充分意识到这是无用的微优化，让我说你基本上应该采用这些：

1）不要从 DataReader/DataRow 读取值两次 - 所以要么在空检查和转换/转换之前缓存它，要么最好直接传递你的record[X] 对象到具有适当签名的自定义扩展方法。

2）要遵守上述规定，请勿在 DataReader/DataRow 上使用内置的 IsDBNull 函数，因为它会在内部调用 record[X] ，因此实际上您将这样做两次。

3) 作为一般规则，类型比较总是比值比较慢。 只需做得更好 record[X] == DBNull.Value 即可。

4) 直接转换比调用 Convert 类进行转换要快，尽管我担心后者会出现更少的问题。

5）最后，通过索引而不是列名访问记录将再次更快。

---

我觉得按照 Szalay、Neil 和 Darren Koppand 的方法会更好。 我特别喜欢 Darren Koppand 的扩展方法方法，它接受 IDataRecord （尽管我想将其进一步缩小到 IDataReader）和索引/列名称。

请小心调用它：

record.GetColumnValue<int?>("field");

以防万一

record.GetColumnValue<int>("field");

您需要区分 0 和 DBNull。 例如，如果枚举字段中有空值，否则 default(MyEnum) 可能会返回第一个枚举值。 因此最好调用 record.GetColumnValue("Field")。

由于您正在从 DataRow 读取数据，因此我将通过 干燥通用代码。

public static T Get<T>(this DataRow dr, int index, T defaultValue = default(T))
{
    return dr[index].Get<T>(defaultValue);
}

static T Get<T>(this object obj, T defaultValue) //Private method on object.. just to use internally.
{
    if (obj.IsNull())
        return defaultValue;

    return (T)obj;
}

public static bool IsNull<T>(this T obj) where T : class 
{
    return (object)obj == null || obj == DBNull.Value;
} 

public static T Get<T>(this IDataReader dr, int index, T defaultValue = default(T))
{
    return dr[index].Get<T>(defaultValue);
}

所以现在这样称呼它：

record.Get<int>(1); //if DBNull should be treated as 0
record.Get<int?>(1); //if DBNull should be treated as null
record.Get<int>(1, -1); //if DBNull should be treated as a custom value, say -1

我相信这就是它在框架中应该的样子（而不是 record.GetInt32、record.GetString 等方法） - 没有运行时异常，使我们能够灵活地处理空值。

根据我的经验，使用一种通用方法从数据库读取数据的运气较差。 我总是必须自定义处理各种类型，因此从长远来看，我必须编写自己的 GetInt、GetEnum、GetGuid 等方法。 如果您想在默认情况下从数据库读取字符串时修剪空格，或者将 DBNull 视为空字符串，该怎么办？ 或者，如果您的小数应该被截断所有尾随零。 我在 Guid 类型上遇到了最大的麻烦，当底层数据库可以将它们存储为字符串或二进制时，不同的连接器驱动程序的行为也不同。 我有这样的重载：

static T Get<T>(this object obj, T defaultValue, Func<object, T> converter)
{
    if (obj.IsNull())
        return defaultValue;

    return converter  == null ? (T)obj : converter(obj);
}

使用 Stevo3000 的方法，我发现调用有点丑陋和乏味，并且很难用它来创建通用函数。

Answer 6

存在一种麻烦的情况，即该对象可能是字符串。 下面的扩展方法代码处理所有情况。 以下是您将如何使用它：

    static void Main(string[] args)
    {
        object number = DBNull.Value;

        int newNumber = number.SafeDBNull<int>();

        Console.WriteLine(newNumber);
    }



    public static T SafeDBNull<T>(this object value, T defaultValue) 
    {
        if (value == null)
            return default(T);

        if (value is string)
            return (T) Convert.ChangeType(value, typeof(T));

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

    public static T SafeDBNull<T>(this object value) 
    { 
        return value.SafeDBNull(default(T)); 
    } 

Answer 7

我个人比较喜欢这种语法，它使用 IDataRecord 公开的显式 IsDbNull 方法，并缓存列索引以避免重复的字符串查找。

为了便于阅读，它进行了扩展，如下所示：

int columnIndex = row.GetOrdinal("Foo");
string foo; // the variable we're assigning based on the column value.
if (row.IsDBNull(columnIndex)) {
  foo = String.Empty; // or whatever
} else { 
  foo = row.GetString(columnIndex);
}

为了 DAL 代码的紧凑性而重写为适合单行 - 请注意，在本示例中，我们将分配 int bar = -1 if row[" Bar"] 为空。

int i; // can be reused for every field.
string foo  = (row.IsDBNull(i  = row.GetOrdinal("Foo")) ? null : row.GetString(i));
int bar = (row.IsDbNull(i = row.GetOrdinal("Bar")) ? -1 : row.GetInt32(i));

如果您不知道内联赋值的存在，它可能会令人困惑，但它将整个操作保留在一行上，我认为当您从一个代码块中的多个列填充属性时，这会增强可读性。

Answer 8

并不是说我已经这样做了，但是您可以通过使用静态/扩展方法来绕过双索引器调用并仍然保持代码干净。

IE。

public static IsDBNull<T>(this object value, T default)
{
    return (value == DBNull.Value)
        ? default
        : (T)value;
}

public static IsDBNull<T>(this object value)
{
    return value.IsDBNull(default(T));
}

然后：

IDataRecord record; // Comes from somewhere

entity.StringProperty = record["StringProperty"].IsDBNull<string>(null);
entity.Int32Property = record["Int32Property"].IsDBNull<int>(50);

entity.NoDefaultString = record["NoDefaultString"].IsDBNull<string>();
entity.NoDefaultInt = record["NoDefaultInt"].IsDBNull<int>();

还有将空检查逻辑保留在一处的好处。 当然，缺点是这是一个额外的方法调用。

只是一个想法。

Answer 9

我尽量避免这种检查。

显然不需要对不能容纳 null 的列执行此操作。

如果您存储为 Nullable 值类型（int? 等），则只需使用 as int? 进行转换。

如果您不需要区分 string.Empty 和 null，您可以直接调用 .ToString()，因为 DBNull 将返回 <代码>字符串.空。

Answer 10

我总是使用：

if (row["value"] != DBNull.Value)
  someObject.Member = row["value"];

发现它简短而全面。

Answer 11

这就是我处理从 DataRows 读取的方式

///<summary>
/// Handles operations for Enumerations
///</summary>
public static class DataRowUserExtensions
{
    /// <summary>
    /// Gets the specified data row.
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="dataRow">The data row.</param>
    /// <param name="key">The key.</param>
    /// <returns></returns>
    public static T Get<T>(this DataRow dataRow, string key)
    {
        return (T) ChangeTypeTo<T>(dataRow[key]);
    }

    private static object ChangeTypeTo<T>(this object value)
    {
        Type underlyingType = typeof (T);
        if (underlyingType == null)
            throw new ArgumentNullException("value");

        if (underlyingType.IsGenericType && underlyingType.GetGenericTypeDefinition().Equals(typeof (Nullable<>)))
        {
            if (value == null)
                return null;
            var converter = new NullableConverter(underlyingType);
            underlyingType = converter.UnderlyingType;
        }

        // Try changing to Guid  
        if (underlyingType == typeof (Guid))
        {
            try
            {
                return new Guid(value.ToString());
            }
            catch

            {
                return null;
            }
        }
        return Convert.ChangeType(value, underlyingType);
    }
}

用法示例：

if (dbRow.Get<int>("Type") == 1)
{
    newNode = new TreeViewNode
                  {
                      ToolTip = dbRow.Get<string>("Name"),
                      Text = (dbRow.Get<string>("Name").Length > 25 ? dbRow.Get<string>("Name").Substring(0, 25) + "..." : dbRow.Get<string>("Name")),
                      ImageUrl = "file.gif",
                      ID = dbRow.Get<string>("ReportPath"),
                      Value = dbRow.Get<string>("ReportDescription").Replace("'", "\'"),
                      NavigateUrl = ("?ReportType=" + dbRow.Get<string>("ReportPath"))
                  };
}

Props to Monsters得到了我的 .Net 的 ChageTypeTo 代码。

Answer 12

我已经用扩展方法做了类似的事情。 这是我的代码：

public static class DataExtensions
{
    /// <summary>
    /// Gets the value.
    /// </summary>
    /// <typeparam name="T">The type of the data stored in the record</typeparam>
    /// <param name="record">The record.</param>
    /// <param name="columnName">Name of the column.</param>
    /// <returns></returns>
    public static T GetColumnValue<T>(this IDataRecord record, string columnName)
    {
        return GetColumnValue<T>(record, columnName, default(T));
    }

    /// <summary>
    /// Gets the value.
    /// </summary>
    /// <typeparam name="T">The type of the data stored in the record</typeparam>
    /// <param name="record">The record.</param>
    /// <param name="columnName">Name of the column.</param>
    /// <param name="defaultValue">The value to return if the column contains a <value>DBNull.Value</value> value.</param>
    /// <returns></returns>
    public static T GetColumnValue<T>(this IDataRecord record, string columnName, T defaultValue)
    {
        object value = record[columnName];
        if (value == null || value == DBNull.Value)
        {
            return defaultValue;
        }
        else
        {
            return (T)value;
        }
    }
}

要使用它，您需要执行类似的操作

int number = record.GetColumnValue<int>("Number",0)

Answer 13

如果在 DataRow 中 row["fieldname"] isDbNull 将其替换为 0，否则获取十进制值：

decimal result = rw["fieldname"] as decimal? ?? 0;

Answer 14

public static class DBH
{
    /// <summary>
    /// Return default(T) if supplied with DBNull.Value
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="value"></param>
    /// <returns></returns>
    public static T Get<T>(object value)
    {   
        return value == DBNull.Value ? default(T) : (T)value;
    }
}

像这样使用

DBH.Get<String>(itemRow["MyField"])

Answer 15

我的程序中有 IsDBNull，它从数据库读取大量数据。 使用 IsDBNull，它可以在大约 20 秒内加载数据。
如果没有 IsDBNull，大约需要 1 秒。

所以我认为最好使用：

public String TryGetString(SqlDataReader sqlReader, int row)
{
    String res = "";
    try
    {
        res = sqlReader.GetString(row);
    }
    catch (Exception)
    { 
    }
    return res;
}