C# 反射相关的东西

public class PlugingManager
    {
        //插件装载器
        public ArrayList Plugins = new ArrayList();
        //插件FullName
        public ArrayList PlugFullName = new ArrayList();
        //插件类型
        public ArrayList PlugTypes = new ArrayList();

#region 构造函数
        /// <summary>
        /// PlugingManager插件加载
        /// </summary>
        /// <param name="plugspath">插件所在目录必须是运行目录中的文件夹</param>
        /// <param name="StartsWith">加载指定插件（插件包含的名称）</param>
        /// <param name="InterfaceName">插件接口名称</param>
        public PlugingManager(string plugspath,string StartsWith,string InterfaceName)
        {
            //获取插件目录(plugins)下所有文件
            string[] files = Directory.GetFiles(Application.StartupPath + @"\\" + plugspath);
           
            foreach (string file in files)
            {
                if (file.ToUpper().EndsWith(StartsWith.ToUpper()))
                {
                    try
                    {
                        //Assembly ab = Assembly.LoadFrom(file);
                        Assembly ab = null;

//先将插件拷贝到内存缓冲
                        byte[] addinStream = null;
                        using(FileStream input = new FileStream(file, FileMode.Open, FileAccess.Read, FileShare.Read))
                        {
                            BinaryReader reader = new BinaryReader(input);
                            addinStream = reader.ReadBytes((int) input.Length);

}
                        ab = Assembly.Load(addinStream); //加载内存中的Dll
                        Type[] types = ab.GetTypes();
                        foreach (Type t in types)
                        {
                            if (t.GetInterface(InterfaceName) != null)
                            {
                                Plugins.Add(ab.CreateInstance(t.FullName));
                                PlugFullName.Add(t.FullName);
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        MessageBox.Show(ex.Message);
                    }
                }
            }
        }
        #endregion
    }

PlugingManager plug = new PlugingManager("Plugs", "Garden.Plugs.dll", "IPlug");

var win = plug.Plugins.ToArray().FirstOrDefault(m => ((Type)m.GetType()).Name.ToLower() == this.Tag.ToString().ToLower());
            MethodInfo OnShowDlg = ((Type)win.GetType()).GetMethod("ShowSelf");
            Form cl = (Form)OnShowDlg.Invoke(win, null);
            cl.WindowState = FormWindowState.Maximized;
            cl.MdiParent = this;
            cl.Show();
            foreach (object obj in plug.Plugins)
            {

Type t = obj.GetType();
                MethodInfo OnShowDlg = t.GetMethod("ShowSelf");
                Control cl = (Control)OnShowDlg.Invoke(obj, null);

Control con = GetControlFromForm(t.Name, this);
                if (con != null)
                {
                    con.Controls.Add(cl);
                    cl.Dock = DockStyle.Fill;
                    isbreak = false;
                    con = null;
                }

}

上面是从内存中生成对象

//获取程序集 
            Assembly assembly = Assembly.Load("环环环环环");
            Assembly assembly2 = Assembly.LoadFrom("环环环环环.dll");

//从程序集中获取指定对象类型;
            Type type = assembly.GetType("环环环环环.User");

//使用Activator创建实例(无参数构造函数)
            var user1 = Activator.CreateInstance(type);
            //使用Activator创建实例(带参数构造函数)
            var user2 = Activator.CreateInstance(type, "薄暮");

//使用Assembly创建实例(无参数构造函数)
            var user3 = assembly.CreateInstance("环环环环环.User");

//反射无参构造函数
            ConstructorInfo constructor1 = type.GetConstructor(new Type[] {});
            var user4 = constructor1.Invoke(new object[] { });

//反射有参构造函数 
            ConstructorInfo constructor2 = type.GetConstructor(new Type[] { typeof(string) });
            var user5 = constructor2.Invoke(new object[] { "薄暮" });

//调用public函数(无参数)
            type.InvokeMember("PublicShow",
                              BindingFlags.InvokeMethod | BindingFlags.Public | BindingFlags.Instance, null, user1,
                              null);

//调用public函数(带参数)
            string returnValue =
                type.InvokeMember("GetString",
                                  BindingFlags.InvokeMethod | BindingFlags.OptionalParamBinding, null, user1,
                                  new object[] { "薄暮" }) as string;

// 调用静态方法       
            string returnValue2 =
                type.InvokeMember("StaticMethod", BindingFlags.InvokeMethod | BindingFlags.Public | BindingFlags.Static,
                                  null, null, new object[] {}) as string;

// 调用私有方法 .       
            type.InvokeMember("PrivateShow",
                              BindingFlags.InvokeMethod | BindingFlags.NonPublic | BindingFlags.Instance, null, user1,
                              new object[] {});

//反射属性
            var Name =
                type.InvokeMember("Name", BindingFlags.GetProperty | BindingFlags.Public | BindingFlags.Instance, null,
                                  user1, new object[] {}) as string;

//设置属性(设置Name属性为"新属性")
            type.InvokeMember("Name", BindingFlags.SetProperty | BindingFlags.Public | BindingFlags.Instance, null,
                                  user1, new object[] {"新属性"});

//反射字段
            string Field =
                type.InvokeMember("Field", BindingFlags.GetField | BindingFlags.Public | BindingFlags.Instance, null,
                                  user1, new object[] {}) as string;

//设置字段（设置Field字段为"新字段"）
            type.InvokeMember("Field", BindingFlags.SetField | BindingFlags.Public | BindingFlags.Instance, null,
                                  user1, new object[] { "新字段" });

这是标准的用法,还挺好玩的吧