Самый эффективный способ проверить DBNull, а затем присвоить переменной?

Я, должно быть, что-то упускаю. Разве не проверяет 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) или другой вариант.

На несвязанном примечании, вот альтернатива 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

Вам следует использовать метод:

Convert.IsDBNull()

Учитывая, что он встроен в Framework, я ожидал, что он будет наиболее эффективным.

Я бы предложил что-то вроде:

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

И да, компилятор должен кэшировать это за вас.

Компилятор не будет оптимизировать индексатор (т.е. если вы дважды используете row ["value"]), поэтому да, это немного быстрее:

object value = row["value"];

а затем используйте значение дважды; использование .GetType () рискует проблемами, если оно равно нулю ...

DBNull.Value на самом деле синглтон, поэтому, чтобы добавить 4-й вариант - вы, возможно, могли бы использовать ReferenceEquals - но на самом деле, я думаю, вы здесь слишком сильно беспокоитесь ... Я не думаю, что скорость различается между "is", "= = "etc будет причиной любой проблемы с производительностью, которую вы видите. Профилируйте весь код и сосредоточьтесь на чем-то важном ... это не будет этим.

Я бы использовал следующий код на C # (VB.NET не так прост).

Код присваивает значение, если оно не равно null / DBNull, в противном случае он присваивает значение по умолчанию, которое может быть установлено равным значению LHS, позволяя компилятору игнорировать присвоение.

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

Я чувствую, что лишь очень немногие подходы здесь не рискуют больше всего беспокоить потенциального ОП (Марк Гравелл, Stevo3000, Ричард Салай, Нил, Даррен Коппанд), и большинство из них излишне сложны. Полностью осознавая, что это бесполезная микрооптимизация, позвольте мне сказать, что вы должны в основном использовать это:

1) Не считывайте значение из DataReader / DataRow дважды - поэтому либо кешируйте его перед проверками на null и преобразованиями / преобразованиями, либо, что еще лучше, напрямую передавайте свой объект record[X] в специальный метод расширения с соответствующей подписью.

2) Чтобы подчиниться вышеизложенному, не используйте встроенную функцию IsDBNull в вашем DataReader / DataRow, так как это вызывает record[X] внутри, поэтому, по сути, вы будете делать это дважды.

3) Как правило, сравнение типов всегда будет медленнее, чем сравнение значений. Просто делай record[X] == DBNull.Value лучше.

4) Прямое приведение будет быстрее, чем вызов класса Convert для преобразования, хотя я боюсь, что последний будет меньше давать сбои.

5) Наконец, доступ к записи по индексу, а не по имени столбца, снова будет быстрее.

Я чувствую, что подход Салая, Нила и Даррена Коппанда будет лучше. Мне особенно нравится метод расширения Даррена Коппанда, который учитывает IDataRecord (хотя я хотел бы сузить его до IDataReader) и имя индекса / столбца.

Позаботьтесь называть это:

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

и не

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

на случай, если вам нужно различать 0 и DBNull. Например, если у вас есть нулевые значения в полях перечисления, иначе default(MyEnum) рискует вернуть первое значение перечисления. Так что лучше позвоните record.GetColumnValue<MyEnum?>("Field").

Поскольку вы читаете 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

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

Есть неприятный случай, когда объект может быть строкой. Приведенный ниже код метода расширения обрабатывает все случаи. Вот как вы бы это использовали:

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

Я лично предпочитаю этот синтаксис, который использует явный метод 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 = -1, если 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));

Встроенное присваивание может сбивать с толку, если вы не знаете, что оно есть, но оно сохраняет всю операцию в одной строке, что, как мне кажется, улучшает читаемость, когда вы заполняете свойства из нескольких столбцов в одном блоке кода.

Не то чтобы я сделал это, но вы можете обойти вызов двойного индексатора и при этом сохранить свой код чистым, используя статический метод / метод расширения.

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

Также имеет преимущество хранения логики нулевой проверки в одном месте. Обратной стороной, конечно же, является то, что это дополнительный вызов метода.

Просто мысль.

Я стараюсь по возможности избегать этой проверки.

Очевидно, это не нужно делать для столбцов, которые не могут содержать null.

Если вы сохраняете значение типа Nullable (int? и т. Д.), Вы можете просто преобразовать с помощью as int?.

Если вам не нужно различать string.Empty и null, вы можете просто вызвать .ToString(), поскольку DBNull вернет string.Empty.

Я всегда использую:

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

Нашел краткое и исчерпывающее.

Вот как я обрабатываю чтение из 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"))
                  };
}

Реквизит для Monsters Got My .Net для кода ChageTypeTo .

Я сделал нечто подобное с методами расширения. Вот мой код:

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)

если в DataRow строка ["fieldname"] isDbNull замените ее на 0, иначе получите десятичное значение:

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

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

У меня есть IsDBNull в программе, которая читает много данных из базы данных. С IsDBNull он загружает данные примерно за 20 секунд. Без IsDBNull около 1 секунды.

Поэтому я считаю, что лучше использовать:

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