使用反射的方法加载DLL

公司内部的接口走的是WCF,接口使用功能号调用的方式。

定义了WPFunction(方法),WPFunctionModule(方法模块),FunctionManager(方法管理类)管理方法，通过反射的方式加载DLL到FunctionManager,调用的时候通过WPFunction GetFuncByID(string funid)得到方法。

注意: Assembly asm = Assembly.Load(b);的方式dll加载到内存就会被释放掉,Assembly asm = Assembly.LoadFile(fileName);的方式dll则会一直被占用。

其它实现如下:

WPFunction

    public class WPFunction
    {
        private string FFunID = "";         //函数标识
        private string FClsID = "";         //所属函数类
        private string FFunDesc = "";       //函数简述

        private string FDllName = "";       //Dll文件名称
        private string FFunName = "";       //函数名称

        private System.Reflection.Assembly FAsmbly = null;  //载入Dll的Assembly
        private string FObjName = "";   //调用的类的名称(包括命名空间)
        private Type FObjType = null;   //调用的类类型
        private object FObjInstance = null; //调用的类的实例

        private MethodInfo FFunInfo = null; //函数信息
        private bool FIsFunLoaded = false;
        private WPFunctionModule FFunModule = null;
        
        public WPFunction(WPFunctionModule fmodule, string fid,string funname, string desc, Type tp)
        {
            FunModule = fmodule;
            FunID = fid;
            FunDesc = desc;
            ObjType = tp;
            FunInfo = tp.GetMethod(funname);
        }

        [DefaultValue("")]
        public string FunID
        {
            get { return FFunID; }
            set { FFunID = value; }
        }

        [DefaultValue("")]
        public string ClsID
        {
            get { return FClsID; }
            set { FClsID = value; }
        }

        [DefaultValue("")]
        public string FunDesc
        {
            get { return FFunDesc; }
            set { FFunDesc = value; }
        }

        [DefaultValue("")]
        public string DllName
        {
            get { return FDllName; }
            set { FDllName = value; }
        }

        [DefaultValue("")]
        public string FunName
        {
            get { return FFunName; }
            set { FFunName = value; }
        }

        [DefaultValue(null)]
        public System.Reflection.Assembly Asmbly
        {
            get { return FAsmbly; }
            set { FAsmbly = value; }
        }

        [DefaultValue("")]
        public string ObjName
        {
            get { return FObjName; }
            set { FObjName = value; }
        }

        [DefaultValue(null)]
        public Type ObjType
        {
            get { return FObjType; }
            set { FObjType = value; }
        }

        [DefaultValue(null)]
        public object ObjInstance
        {
            get { return FObjInstance; }
            set { FObjInstance = value; }
        }

        [DefaultValue(null)]
        public MethodInfo FunInfo
        {
            get { return FFunInfo; }
            set { FFunInfo = value; }
        }

        [DefaultValue(false)]
        public bool IsFunLoaded
        {
            get { return FIsFunLoaded; }
            set { FIsFunLoaded = value; }
        }

        [DefaultValue(null)]
        public WPFunctionModule FunModule
        {
            get { return FFunModule; }
            set { FFunModule = value; }
        }
    }

WPFunctionModule:

    public class WPFunctionModule
    {
        public string DllName;
        public string DllDesc;
        public List<WPFunction> Functions;

        public WPFunctionModule(string name, string desc)
        {
            DllName = name;
            DllDesc = desc;
            Functions = new List<WPFunction>();
        }

        private bool IsFunctionReg(string funid)
        {
            int i;
            for (i = 0; i < Functions.Count; i++)
                if (Functions[i].FunID == funid)
                    return true;
            return false;
        }

        public void RegisterFunction(string funid,string funname, string desc, Type tp)
        {
            if (!IsFunctionReg(funid))
                Functions.Add(new WPFunction(this, funid, funname, desc, tp));
        }
    }

FunctionManager:

    /// <summary>
    /// 管理中间件功能管理类
    /// </summary>
    public static class FunctionManager
    {
        public static Dictionary<string, string> FunctionKeyValueDic = new Dictionary<string, string>();

        public static List<WPFunctionModule> Modules = new List<WPFunctionModule>();

        /// <summary>
        /// 查找窗体
        /// </summary>
        public static WPFunction FindFunc(string funid)
        {
            foreach (WPFunctionModule md in Modules)
            {
                WPFunction fun = md.Functions.Find(delegate(WPFunction f) { return f.FunID == funid; });
                if (fun != null)
                    return fun;
            }
            return null;
        }

        /// <summary>
        /// 加载方法
        /// </summary>
        /// <param name="fun"></param>
        public static void LoadFunc(WPFunction fun)
        {
            if (!IsInstanced(fun))
            {
                try
                {
                    fun.ObjInstance = Activator.CreateInstance(fun.ObjType);
                    fun.IsFunLoaded = true;
                }
                catch
                {

                }
            }
        }

        /// <summary>
        /// 根据ID获得方法
        /// </summary>
        public static WPFunction GetFuncByID(string funid)
        {
            WPFunction fun = FindFunc(funid);
            if (fun == null) return null;

            if (!fun.IsFunLoaded) LoadFunc(fun);
            return fun;
        }

        /// <summary>
        /// 方法数量
        /// </summary>
        /// <returns></returns>
        public static int FunctionCount()
        {
            int cnt = 0;
            foreach (WPFunctionModule md in Modules)
            {
                cnt += md.Functions.Count();
            }
            return cnt;
        }

        /// <summary>
        /// 查找类是否创建
        /// </summary>
        /// <param name="fun"></param>
        /// <returns></returns>
        public static bool IsInstanced(WPFunction fun)
        {
            foreach (WPFunction f in fun.FunModule.Functions)
            {
                if ((f.IsFunLoaded) && (f.ObjType == fun.ObjType))
                {
                    fun.ObjInstance = f.ObjInstance;
                    return true;
                }
            }
            return false;
        }

        /// <summary>
        /// 增加模块
        /// </summary>
        static void AddModule(WPFunctionModule module)
        {
            if (Modules.IndexOf(module) < 0)
            {
                Modules.Add(module);
                module.Functions.Sort(delegate(WPFunction f1, WPFunction f2) { return Comparer<string>.Default.Compare(f1.FunID, f2.FunID); });
            }
        }

        public static bool IsSubTypeOf(this Type objType, Type baseType)
        {
            if (objType == null) return false;
            if (baseType == null) return false;

            // 基类型不是接口
            if (!baseType.IsInterface)
            {
                return objType.IsSubclassOf(baseType);
            }
            else // 基类型是接口
            {
                return objType.GetInterfaces().Where(tp => tp == baseType).Any();
            }
        }

        /// <summary>
        /// 加载功能方法
        /// </summary>
        public static void LoadFunctions()
        {
            try
            {
                Modules.Clear();
                //string[] files = Directory.GetFiles(@System.Windows.Forms.Application.StartupPath + "\bin", "mngfunc_*.dll");
                string[] files = Directory.GetFiles(@System.AppDomain.CurrentDomain.BaseDirectory + "\bin", "mngfunc_*.dll");
                foreach (string fileName in files)
                {
                    try
                    {
                        byte[] b = File.ReadAllBytes(fileName);
                        Assembly asm = Assembly.Load(b);
                        //Assembly asm = Assembly.LoadFile(fileName);

                        if (asm != null)
                        {
                            var query = (from tp in asm.GetTypes()
                                         where tp.IsSubTypeOf(typeof(IWPFunctionBuilder))
                                         select tp).ToArray();

                            foreach (var tp in query)
                            {
                                var obj = Activator.CreateInstance(tp) as IWPFunctionBuilder;
                                AddModule(obj.GetModule());
                            }
                        }
                    }
                    catch { }
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
        }
    }