C# 中反射获取某类的子类和根据类型名动态创建对象

有时候，为了快速批量处理已经实现某个基类或者某个接口的子类，需要通过反射的方式获取到他们的类类型(Type),然后再通过

Activator.CreateInstance(objType);

或者

Assembly.Load(path).CreateInstance(typeName);

或者

Assembly.LoadFile(filePath).CreateInstance(typeName);

创建对象实例。

以下通过一个简单的示例来展示：
1，获取当前程序集中的全部类型；
2，判断某一类型是否是继承与另一类型；
3，根据类型名动态创建对象。

目前还有个疑问，不知道谁能解答：
1，如何判断某个类是否实现了某个接口，目前只能先 new 一个对象，然后再用 is 判断。

using System;
using System.Collections.Generic;
using System.Text;
using System.Reflection;
using System.Diagnostics;
 
namespace com.hetaoos
{
 
    class Test
    {
        public Test()
        {
            var types = Assembly.GetExecutingAssembly().GetTypes();
            var baseType = typeof(BaseProcessor);
            List<BaseProcessor> processors = new List<BaseProcessor>();
            foreach (var t in types)
            {
                var tmp = t.BaseType;
                while (tmp != null)
                {
                    if (tmp == baseType)
                    {
                        BaseProcessor obj = MethodMaker.CreateObject(t.FullName) as BaseProcessor;
                        if (obj != null)
                        {
                            processors.Add(obj);
                        }
                        break;
                    }
                    else
                    {
                        tmp = tmp.BaseType;
                    }
                }
            }
 
            Debug.Print("Processor Count:{0}", processors.Count);
            foreach (var p in processors)
            {
                Debug.Print("{0}	:{1}", p, p.Calc(2, 5));
            }
        }
    }
 
    public class MethodMaker
    {
 
        /// <summary>
        /// 创建对象（当前程序集）
        /// </summary>
        /// <param name="typeName">类型名</param>
        /// <returns>创建的对象，失败返回 null</returns>
        public static object CreateObject(string typeName)
        {
            object obj = null;
            try
            {
                Type objType = Type.GetType(typeName, true);
                obj = Activator.CreateInstance(objType);
            }
            catch (Exception ex)
            {
                Debug.Write(ex);
            }
            return obj;
        }
 
        /// <summary>
        /// 创建对象(外部程序集)
        /// </summary>
        /// <param name="path"></param>
        /// <param name="typeName">类型名</param>
        /// <returns>创建的对象，失败返回 null</returns>
        public static object CreateObject(string path, string typeName)
        {
            object obj = null;
            try
            {
 
                obj = Assembly.Load(path).CreateInstance(typeName);
            }
            catch (Exception ex)
            {
                Debug.Write(ex);
            }
 
            return obj;
        }
    }
 
    public abstract class BaseProcessor
    {
        public abstract int Calc(int a, int b);
    }
 
    public class Adder : BaseProcessor
    {
        public override int Calc(int a, int b)
        {
            return a + b;
        }
    }
 
    public class Multiplier : BaseProcessor
    {
        public override int Calc(int a, int b)
        {
            return a * b;
        }
    }
}

输出结果为：

Processor Count:2
com.hetaoos.Adder   :7
com.hetaoos.Multiplier  :10

PS:
判断某个类是否继承自某个接口、类的方法：

public static bool IsParent(Type test, Type parent)
{
    if (test == null || parent == null || test == parent || test.BaseType == null)
    {
        return false;
    }
    if (parent.IsInterface)
    {
        foreach (var t in test.GetInterfaces())
        {
            if (t == parent)
            {
                return true;
            }
        }
    }
    else
    {
        do
        {
            if (test.BaseType == parent)
            {
                return true;
            }
            test = test.BaseType;
        } while (test != null);
 
    }
    return false;
}