Conversion Helper with support for enumerations and Nullable - The Remix I recently wrote this code as a more versatile stand-in for Convert.ChangeType. I very recently posted an earlier version, for which I received some good feedback. I've incorporated that feedback and further refactored in an attempt to streamline the flow of the method.

    /// &lt;summary&gt;
    ///     Returns an object of type &lt;typeparamref name="T"/&gt; whose value is equivalent to that of the specified 
    ///     object.
    /// &lt;/summary&gt;
    /// &lt;param name="value"&gt;
    ///     An object that implements &lt;see cref="IConvertible"/&gt; or is &lt;see cref="Nullable{T}"/&gt; where the underlying
    ///     type implements &lt;see cref="IConvertible"/&gt;.
    /// &lt;/param&gt;
    /// Other XML comments removed for brevity's sake.
    internal static T ChangeType&lt;T&gt;(object value) {

        Type originalType = typeof(T);
        Type nullableType = Nullable.GetUnderlyingType(originalType);

        if (value != null &amp;&amp; value.GetType() == originalType) 
        {
            return (T)value;
        }

        if (value == null || DBNull.Value.Equals(value)) 
        {
            if (nullableType != null || !originalType.IsValueType) 
            {
                return default(T);
            }

            throw new InvalidCastException(string.Format("Cannot convert null to {0} because it is a non-nullable value type.", originalType.Name));
        }

        Type conversionType = nullableType ?? originalType;

        if (!conversionType.IsEnum) 
        {
            return (T)Convert.ChangeType(value, conversionType);
        }

        object result = (value is string) ? Enum.Parse(conversionType, (string)value) : Enum.ToObject(conversionType, value);

        if (!Enum.IsDefined(conversionType, result)) 
        {
            throw new ArgumentException("The specified value is not defined by the enumeration.", "value");
        }

        return (T)result;
    }
As a good bit of time has passed, and no additional feedback seems to be incoming, I'm posting this answer so that I can close the loop on this question. 

The only feedback I might give -- and it's a small optimization -- is to move this code:

Type nullableType = Nullable.GetUnderlyingType(originalType)

I think it would be slightly better to put it after the check to see if the value parameter's type equals the generic type parameter's type, as there exists a chance that the method will not need that variable at all if the types are equal.