Возможен ли тип, допускающий значение NULL, в качестве универсального параметра?

Измените тип возвращаемого значения на Nullable<T> и вызовите метод с параметром, не допускающим значения NULL.

static void Main(string[] args)
{
    int? i = GetValueOrNull<int>(null, string.Empty);
}


public static Nullable<T> GetValueOrNull<T>(DbDataRecord reader, string columnName) where T : struct
{
    object columnValue = reader[columnName];

    if (!(columnValue is DBNull))
        return (T)columnValue;

    return null;
}

Просто сделайте две вещи с исходным кодом - удалите ограничение where и измените последний return с return null на return default(T). Таким образом, вы можете вернуть любой желаемый тип.

Кстати, вы можете избежать использования is, изменив оператор if на if (columnValue != DBNull.Value).

Просто пришлось сделать что-то невероятное, подобное этому. Мой код:

public T IsNull<T>(this object value, T nullAlterative)
{
    if (value != DBNull.Value)
    {
        Type type = typeof(T);
        if (type.IsGenericType && 
            type.GetGenericTypeDefinition() == typeof(Nullable<>).GetGenericTypeDefinition())
        {
            type = Nullable.GetUnderlyingType(type);
        }

        return (T)(type.IsEnum ? Enum.ToObject(type, Convert.ToInt32(value)) :
            Convert.ChangeType(value, type));
    }
    else 
        return nullAlternative;
}

public static T GetValueOrDefault<T>(this IDataRecord rdr, int index)
{
    object val = rdr[index];

    if (!(val is DBNull))
        return (T)val;

    return default(T);
}

Просто используйте это так:

decimal? Quantity = rdr.GetValueOrDefault<decimal?>(1);
string Unit = rdr.GetValueOrDefault<string>(2);

Я думаю, вы хотите обрабатывать ссылочные типы и типы структур. Я использую его для преобразования строк элемента XML в более типизированный тип. Вы можете удалить nullAlternative с помощью отражения. Formatprovider должен обрабатывать зависящий от языка и региональных параметров '.' или разделитель ',', например, десятичные или целые и двойные. Это может сработать:

public T GetValueOrNull<T>(string strElementNameToSearchFor, IFormatProvider provider = null ) 
    {
        IFormatProvider theProvider = provider == null ? Provider : provider;
        XElement elm = GetUniqueXElement(strElementNameToSearchFor);

        if (elm == null)
        {
            object o =  Activator.CreateInstance(typeof(T));
            return (T)o; 
        }
        else
        {
            try
            {
                Type type = typeof(T);
                if (type.IsGenericType &&
                type.GetGenericTypeDefinition() == typeof(Nullable<>).GetGenericTypeDefinition())
                {
                    type = Nullable.GetUnderlyingType(type);
                }
                return (T)Convert.ChangeType(elm.Value, type, theProvider); 
            }
            catch (Exception)
            {
                object o = Activator.CreateInstance(typeof(T));
                return (T)o; 
            }
        }
    }

Вы можете использовать это так:

iRes = helper.GetValueOrNull<int?>("top_overrun_length");
Assert.AreEqual(100, iRes);



decimal? dRes = helper.GetValueOrNull<decimal?>("top_overrun_bend_degrees");
Assert.AreEqual(new Decimal(10.1), dRes);

String strRes = helper.GetValueOrNull<String>("top_overrun_bend_degrees");
Assert.AreEqual("10.1", strRes);

Заявление об ограничении ответственности: Этот ответ работает, но предназначен только для образовательных целей. :) Решение Джеймса Джонса, вероятно, здесь лучший, и я бы выбрал его.

Ключевое слово dynamic в C# 4.0 делает это еще проще, хотя и менее безопасно:

public static dynamic GetNullableValue(this IDataRecord record, string columnName)
{
  var val = reader[columnName];

  return (val == DBNull.Value ? null : val);
}

Теперь вам не нужно явное указание типа на RHS:

int? value = myDataReader.GetNullableValue("MyColumnName");

На самом деле, он вам нигде не нужен!

var value = myDataReader.GetNullableValue("MyColumnName");

value теперь будет int, строкой или любым другим типом, возвращенным из БД.

Единственная проблема заключается в том, что это не мешает вам использовать в LHS типы, не допускающие значения NULL, и в этом случае вы получите довольно неприятное исключение времени выполнения, например:

Microsoft.CSharp.RuntimeBinder.RuntimeBinderException: Cannot convert null to 'int' because it is a non-nullable value type

Как и весь код, использующий dynamic: caveat coder.

Это может быть мертвый поток, но я обычно использую следующее:

public static T? GetValueOrNull<T>(this DbDataRecord reader, string columnName)
where T : struct 
{
    return reader[columnName] as T?;
}

Я знаю, что это устарело, но вот еще одно решение:

public static bool GetValueOrDefault<T>(this SqlDataReader Reader, string ColumnName, out T Result)
{
    try
    {
        object ColumnValue = Reader[ColumnName];

        Result = (ColumnValue!=null && ColumnValue != DBNull.Value) ? (T)ColumnValue : default(T);

        return ColumnValue!=null && ColumnValue != DBNull.Value;
    }
    catch
    {
        // Possibly an invalid cast?
        return false;
    }
}

Теперь вам все равно, был ли T значением или ссылочным типом. Только если функция возвращает истину, у вас есть разумное значение из базы данных. Использование:

...
decimal Quantity;
if (rdr.GetValueOrDefault<decimal>("YourColumnName", out Quantity))
{
    // Do something with Quantity
}

Этот подход очень похож на int.TryParse("123", out MyInt);.

Я сам столкнулся с той же проблемой.

... = reader["myYear"] as int?; работает и чисто.

Он работает с любым типом без проблем. Если результатом является DBNull, он возвращает null, поскольку преобразование завершается ошибкой.

Множественные общие ограничения не могут быть объединены ИЛИ (менее строго), только И (более строго). Это означает, что один метод не может обрабатывать оба сценария. Общие ограничения также нельзя использовать для создания уникальной подписи для метода, поэтому вам придется использовать два отдельных имени метода.

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

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

Я использовал слова «Null» и «Nullable», чтобы различать ссылочные типы и типы значений. А вот пример пары методов расширения, которые я написал, которые дополняют метод FirstOrDefault в классе System.Linq.Enumerable.

    public static TSource FirstOrNull<TSource>(this IEnumerable<TSource> source)
        where TSource: class
    {
        if (source == null) return null;
        var result = source.FirstOrDefault();   // Default for a class is null
        return result;
    }

    public static TSource? FirstOrNullable<TSource>(this IEnumerable<TSource?> source)
        where TSource : struct
    {
        if (source == null) return null;
        var result = source.FirstOrDefault();   // Default for a nullable is null
        return result;
    }

Более короткий путь:

public static T ValueOrDefault<T>(this DataRow reader, string columnName) => 
        reader.IsNull(columnName) ? default : (T) reader[columnName];

вернуть 0 для int и null для int?

Если это кому-то помогает - я использовал это раньше и, кажется, делаю то, что мне нужно ...

public static bool HasValueAndIsNotDefault<T>(this T? v)
    where T : struct
{
    return v.HasValue && !v.Value.Equals(default(T));
}