In my previous blog, I wrote about how to create generic utility classes that would cast or convert any object to a given type, returning a default if the value was DBNull. I quickly discovered that this code will work just fine as long as the passed type is not nullable. For example, this will work:
int i = ConvertDBNull.To<int>( value, 0 );
But this won't:
int? i = ConvertDBNull.To<int?>( value, null );
The line that fails within the To<>() method is this:
return (T) Convert.ChangeType( value, t );
The reason the call to ChangeType() fails is that there are no conversions defined for the Nullable<> struct, a fact that I find rather puzzling, since it would have been quite easy to do. All you have to do is get the underlying type and convert to it instead. We will still cast the result to the nullable version of the type, because casting a value type to its nullable counterpart is allowed. Here is how to extract that underlying type:
How To Detect Nullable Types Using Reflection
First of all, we will need to be able to detect when a nullable type is passed to the conversion method. The .NET Framework doesn't provide anything that explicitly tests for nullable types, but we can use reflection to determine whether a type is nullable or not. The first thing you need to know is that nullable types are implemented by the framework by using a generic struct called Nullable<>. For example, the following two declarations are identical:
int? i;
Nullable<int> i;
Therefore, if a given type is nullable, it is a generic type whose type is Nullable<>.
private static bool IsNullable( Type t )
{
if ( !t.IsGenericType ) return false;
Type g = t.GetGenericTypeDefinition();
return ( g.Equals( typeof( Nullable<> ) ) );
}
Solving The Conversion Problem
Now that we can detect a nullable type when it's passed, we will need to extract the underlying type. The underlying type is the first and only generic argument passed to the Nullable<> struct. Therefore, the underlying type can be obtained like this:
private static Type UnderlyingTypeOf( Type t )
{
return t.GetGenericArguments()[ 0 ];
}
We simply need to substitute the underlying type for the nullable type in our original code to get the desired results:
public static T To<T>( object value, T defaultValue )
{
if ( value == DBNull.Value ) return defaultValue;
Type t = typeof( T );
if ( IsNullable( t ) )
t = UnderlyingTypeOf( t );
return (T) Convert.ChangeType( value, t );
}
But wait! If you use this method to attempt to convert a null value to a nullable type, the result will be an invalid conversion, because you will be trying to convert null to a value type. We'll have to return without converting if the passed value is null:
public static T To<T>( object value, T defaultValue )
{
if ( value == DBNull.Value ) return defaultValue;
Type t = typeof( T );
if ( IsNullable( t ) )
{
if ( value == null ) return default( T );
t = UnderlyingTypeOf( t );
}
return (T) Convert.ChangeType( value, t );
}
Finally, we have a method that will convert any type, including nullable types, to any other type, including nullable types. I hope that you've enjoyed today's submission. If you need training or consulting, contact us and get the Falafel team working for you!