.net - 检查 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"])) {}

笔记：

行[“值”] 存在。
我不知道列的列索引（因此是列名查找）。
我特别询问是否检查 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();
 }

score 73 · Accepted Answer

我肯定错过了什么。不是检查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<T>返回值GetValue<T>，您可以轻松地返回default(T)或其他选项。

在不相关的说明中，这是 Stevo3000 建议的 VB.NET 替代方案：

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

score 36 · Accepted Answer

您应该使用以下方法：

Convert.IsDBNull()

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

我建议以下内容：

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

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

score 20 · Accepted Answer

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

object value = row["value"];

然后使用 value 两次；如果 .GetType() 为空，则使用 .GetType() 可能会出现问题...

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

score 9 · Accepted Answer

I would use the following code in C# (VB.NET is not as simple).

The code assigns the value if it is not null/DBNull, otherwise it asigns the default which could be set to the LHS value allowing the compiler to ignore the assign.

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

score 8 · Accepted Answer

我觉得这里只有极少数方法不会让潜在的 OP 最担心（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<MyEnum?>("Field")。

由于您正在阅读 a DataRow，因此我将为两者创建扩展方法，DataRow并IDataReader通过DRYing通用代码。

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等方法。如果您想在默认情况下从 db 读取字符串时修剪空格，或者将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 的方法，我觉得调用有点丑陋和乏味，而且很难用它来制作通用函数。

score 7 · Accepted Answer

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

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

score 6 · Accepted Answer

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

为提高可读性而扩展，它类似于：

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 = -1ifrow["Bar"]为 null。

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

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

score 5 · Accepted Answer

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

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

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

只是一个想法。

score 5 · Accepted Answer

我尽量避免这种检查。

对于不能容纳的列，显然不需要这样做null。

如果您存储在 Nullable 值类型（int?等）中，您可以使用as int?.

如果你不需要区分string.Emptyand null，你可以调用.ToString()，因为 DBNull 会返回string.Empty。

score 4 · Accepted Answer

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

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)

score 4 · Accepted Answer

这就是我处理从 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"))
                  };
}

怪物道具得到了我的 .Net用于 ChageTypeTo 代码。

score 4 · Accepted Answer

我总是使用：

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

发现它简短而全面。

score 4 · Accepted Answer

如果在 DataRow 中的 row["fieldname"] isDbNull 用 0 替换它，否则得到十进制值：

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

score 3 · Accepted Answer

我在一个从数据库中读取大量数据的程序中有 IsDBNull。使用 IsDBNull，它会在大约 20 秒内加载数据。没有 IsDBNull，大约 1 秒。

所以我认为最好使用：

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

score 3 · Accepted Answer

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

.net - 检查 DBNull 然后分配给变量的最有效方法是什么？

15 回答 15

Related

Reference