检查一个类是否派生自某个泛型基类

/// <summary>
/// 扩展类：检查一个类是否派生自某个泛型基类
/// </summary>
public static class ReflexionExtension
{
    /// <summary>
    /// 检查是否派生自某个泛型基类
    /// </summary>
    /// <param name="child">派生类</param>
    /// <param name="parent">基类</param>
    /// <returns></returns>
    public static bool IsSubClassOfGeneric(this Type child, Type parent)
    {
        if (child == parent)
            return false;
        if (child.IsSubclassOf(parent))
            return true;
        var parameters = parent.GetGenericArguments();
        var isParameterLessGeneric = !(parameters != null && parameters.Length > 0 &&
         ((parameters[0].Attributes & TypeAttributes.BeforeFieldInit) == TypeAttributes.BeforeFieldInit));
        while (child != null && child != typeof(object))
        {
            var cur = GetFullTypeDefinition(child);
            if (parent == cur || (isParameterLessGeneric && cur.GetInterfaces().Select(i => GetFullTypeDefinition(i)).Contains(GetFullTypeDefinition(parent))))
                return true;
            else if (!isParameterLessGeneric)
                if (GetFullTypeDefinition(parent) == cur && !cur.IsInterface)
                {
                    if (VerifyGenericArguments(GetFullTypeDefinition(parent), cur))
                        return true;
                }
                else
                    foreach (var item in child.GetInterfaces().Where(i => GetFullTypeDefinition(parent) == GetFullTypeDefinition(i)))
                        if (VerifyGenericArguments(parent, item))
                            return true;
            child = child.BaseType;
        }
        return false;
    }
    /// <summary>
    /// 返回一个泛型类型
    /// </summary>
    /// <param name="type">子类</param>
    /// <returns></returns>
    private static Type GetFullTypeDefinition(Type type)
    {
        return type.IsGenericType ? type.GetGenericTypeDefinition() : type;
    }
    /// <summary>
    /// 验证泛型参数是否一致
    /// </summary>
    /// <param name="parent">基类</param>
    /// <param name="child">派生类</param>
    /// <returns></returns>
    private static bool VerifyGenericArguments(Type parent, Type child)
    {
        Type[] childArguments = child.GetGenericArguments();
        Type[] parentArguments = parent.GetGenericArguments();
        if (childArguments.Length == parentArguments.Length)
            for (int i = 0; i < childArguments.Length; i++)
                if (childArguments[i].Assembly == parentArguments[i].Assembly && childArguments[i].Name == parentArguments[i].Name && childArguments[i].Namespace == parentArguments[i].Namespace)
                    return true;
        return false;
    }
    /// <summary>
    /// Find out if a child type implements or inherits from the parent type.
    /// The parent type can be an interface or a concrete class, generic or non-generic.
    /// </summary>
    /// <param name="child"></param>
    /// <param name="parent"></param>
    /// <returns></returns>
    public static bool InheritsOrImplements2(this Type child, Type parent)
    {
        var currentChild = parent.IsGenericTypeDefinition && child.IsGenericType ? child.GetGenericTypeDefinition() : child;
        while (currentChild != typeof(object))
        {
            if (parent == currentChild || HasAnyInterfaces2(parent, currentChild))
                return true;
            currentChild = currentChild.BaseType != null && parent.IsGenericTypeDefinition && currentChild.BaseType.IsGenericType
                 ? currentChild.BaseType.GetGenericTypeDefinition()
                 : currentChild.BaseType;
            if (currentChild == null)
                return false;
        }
        return false;
    }
    private static bool HasAnyInterfaces2(Type parent, Type child)
    {
        return child.GetInterfaces().Any(childInterface =>
        {
            var currentInterface = parent.IsGenericTypeDefinition && childInterface.IsGenericType
             ? childInterface.GetGenericTypeDefinition()
             : childInterface;
            return currentInterface == parent;
        });
    }
    /// <summary>
    /// Checks whether this type has the specified definition in its ancestry.
    /// </summary> 
    public static bool HasGenericDefinition(this Type type, Type definition)
    {
        return GetTypeWithGenericDefinition(type, definition) != null;
    }
    /// <summary>
    /// Returns the actual type implementing the specified definition from the
    /// ancestry of the type, if available. Else, null.
    /// </summary>
    public static Type GetTypeWithGenericDefinition(this Type type, Type definition)
    {
        if (type == null)
            throw new ArgumentNullException("type");
        if (definition == null)
            throw new ArgumentNullException("definition");
        if (!definition.IsGenericTypeDefinition)
            throw new ArgumentException(
             "The definition needs to be a GenericTypeDefinition", "definition");
        if (definition.IsInterface)
            foreach (var interfaceType in type.GetInterfaces())
                if (interfaceType.IsGenericType
                 && interfaceType.GetGenericTypeDefinition() == definition)
                    return interfaceType;
        for (Type t = type; t != null; t = t.BaseType)
            if (t.IsGenericType && t.GetGenericTypeDefinition() == definition)
                return t;
        return null;
    }
    static bool IsSubclassOfRawGeneric2(Type generic, Type toCheck)
    {
        while (toCheck != typeof(object))
        {
            var cur = toCheck.IsGenericType ? toCheck.GetGenericTypeDefinition() : toCheck;
            if (cur.IsGenericType && generic.GetGenericTypeDefinition() == cur.GetGenericTypeDefinition())
            {
                return true;
            }
            toCheck = toCheck.BaseType;
        }
        return false;
    }
    static bool IsSubclassOfRawGeneric1(Type generic, Type toCheck)
    {
        while (toCheck != null && toCheck != typeof(object))
        {
            var cur = toCheck.IsGenericType ? toCheck.GetGenericTypeDefinition() : toCheck;
            if (generic == cur)
            {
                return true;
            }
            toCheck = toCheck.BaseType;
        }
        return false;
    }
    /// <summary>
    /// 深度查找基类是否派生自某个泛型类
    /// </summary>
    /// <param name="typeToCheck"></param>
    /// <param name="genericType"></param>
    /// <returns></returns>
    public static bool IsTypeDerivedFromGenericType(this Type typeToCheck, Type genericType)
    {
        if (typeToCheck == typeof(object))
        {
            return false;
        }
        else if (typeToCheck == null)
        {
            return false;
        }
        else if (typeToCheck.IsGenericType && typeToCheck.GetGenericTypeDefinition() == genericType)
        {
            return true;
        }
        else
        {
            return IsTypeDerivedFromGenericType(typeToCheck.BaseType, genericType);
        }
    }
    /// <summary>
    /// 检查一个对象是从一个特定的类型派生创造
    /// </summary>
    /// <param name="t"></param>
    /// <param name="typeToCompare"></param>
    /// <returns></returns>
    internal static bool IsDerivativeOf(this Type t, Type typeToCompare)
    {
        if (t == null) throw new NullReferenceException();
        if (t.BaseType == null) return false;
        if (t.BaseType == typeToCompare) return true;
        else return t.BaseType.IsDerivativeOf(typeToCompare);
    }
    public static bool InheritsOrImplements1(this Type child, Type parent)
    {
        parent = ResolveGenericTypeDefinition(parent);
        var currentChild = child.IsGenericType
              ? child.GetGenericTypeDefinition()
              : child;
        while (currentChild != typeof(object))
        {
            if (parent == currentChild || HasAnyInterfaces1(parent, currentChild))
                return true;
            currentChild = currentChild.BaseType != null
                && currentChild.BaseType.IsGenericType
                 ? currentChild.BaseType.GetGenericTypeDefinition()
                 : currentChild.BaseType;
            if (currentChild == null)
                return false;
        }
        return false;
    }
    private static bool HasAnyInterfaces1(Type parent, Type child)
    {
        return child.GetInterfaces()
         .Any(childInterface =>
         {
             var currentInterface = childInterface.IsGenericType
              ? childInterface.GetGenericTypeDefinition()
              : childInterface;
             return currentInterface == parent;
         });
    }
    private static Type ResolveGenericTypeDefinition(Type parent)
    {
        var shouldUseGenericType = true;
        if (parent.IsGenericType && parent.GetGenericTypeDefinition() != parent)
            shouldUseGenericType = false;
        if (parent.IsGenericType && shouldUseGenericType)
            parent = parent.GetGenericTypeDefinition();
        return parent;
    }

}