Nullable type as a generic parameter possible?

Question

I want to do something like this :

myYear = record.GetValueOrNull<int?>("myYear"),

Notice the nullable type as the generic paramater.

Since the GetValueOrNull function could return null my first attempt was this :

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

    if (!(columnValue is DBNull))
    {
        return (T)columnValue;
    }
    return null;
}

But the error I get now is

The type 'int?' must be a reference type in order to use it as parameter 'T' in the generic type or method

Right! Nullable is a stuct! So I tried changing the class contstrainted to a stuct constrained (and as a side effect can't return null anymore) :

public static T GetValueOrNull<T>(this DbDataRecord reader, string columnName) where T : stuct

Now the assingment

myYear = record.GetValueOrNull("myYear")

Gives the following error

The type 'int?' must be a non-nullable value type in order to use it as parameter 'T' in the generic type or method

Is specifying a nullable type as a generic parameter at all possible?

Answer 1

Change the return type to Nullable, and call the method with the non nullable parameter

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

Answer 2

Just do two things to your original code. Remove the where constraint, and change the last return from return null to return default(T). This way you can return whatever type you want.

By the way, you can avoid the use of "is" by changing your if statement to if (columnValue != DBNull.Value).

Answer 3

Just had to do something incredible similar to this. My code:

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