类型反射（Reflection），动态加载

using System.Reflection;

对象

创建对象

        /// <summary>
        /// 动态创建对象实例
        /// </summary>
        /// <typeparam name="T">要创建对象的类型</typeparam>
        /// <param name="fullName">命名空间.类型名</param>
        /// <param name="assemblyName">程序集</param>
        /// <param name="args">参数组（数量、顺序、类型都匹配）</param>
        /// <returns></returns>
        public static object InvokeCreateInstance(string fullName, string assemblyName = null, object[] args = null)
        {
            try
            {
                if (assemblyName == null)   // 本地程序集
                {
                    Type o = Type.GetType(fullName, true, true);
                    object obj = Activator.CreateInstance(o, args);
                    return obj;
                }
                else
                {
                    // 跨程序集
                    object ect = System.Reflection.Assembly.Load(assemblyName).CreateInstance(fullName, true, BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.CreateInstance, Type.DefaultBinder, args, null, null);
                    return ect;
                }
            }
            catch (Exception ex)
            {
                string err = ex.Message;
                return null;
            }
        }

//Example obj = new Example();
var obj = WSComm.InvokeCreateInstance("WpfApp1.Example");

触发事件

        // 声明动态类型
        private dynamic _dynamicObj;
        ......
        // 定义对象事件
        _dynamicObj = WSComm.InvokeCreateInstance("WpfApp1.Example");
        _dynamicObj.MyEvent += new EventHandler(Dosth);
        ......
        // 事件方法
        private void Dosth(object sender, EventArgs e)
        {
            var arg = (MyEventArgs)e;
            lbContent.Text = arg.Args.ToString();
        }

// 响应事件
_dynamicObj.Eventrase = "Exec" + DateTime.Now.ToString();

获取控件

        /// <summary>
        /// 根据控件的字符串名称获取控件对象
        /// </summary>
        /// <typeparam name="T">要获取控件的类型</typeparam>
        /// <param name="obj">控件所属对象</param>
        /// <param name="ctlName">控件的名称</param>
        /// <returns></returns>
        public static T GetControlObject<T>(object obj, string ctlName)
        {
            try
            {
                Type mainType = obj.GetType();
                var fi = mainType.GetField(ctlName, BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.IgnoreCase);
                if (fi != null)
                {
                    T rlst = (T)fi.GetValue(obj);

                    return rlst;
                }
                else
                {
                    return default(T);
                }
            }
            catch (Exception)
            {
                return default(T);
            }
        }

var ctl = WSCommFunc.GetControlObject (this, "txtSpaceCnt1");

设置控件

        public static void CtlIsEnable(this System.Windows.Controls.Control ctl, bool bEnable = true)
        {
            ctl.IsEnabled = bEnable;
            if (bEnable)
            {
                ctl.Background = new SolidColorBrush(Colors.Transparent);
            }
            else
            {
                ctl.Background = new SolidColorBrush(gray);
            }
        }

ctl.CtlIsEnable(false);

方法

一般方法

        /// <summary>
        /// 动态调用对象的方法
        /// </summary>
        /// <param name="obj">指定的对象</param>
        /// <param name="methodName">方法名称</param>
        /// <param name="argsValue">参数值</param>
        /// <param name="argsName">参数名称</param>
        /// <returns></returns>
        public static object InvokeMethod(object obj, string methodName, object[] argsValue, string[] argsName = null)
        {
            Type type = obj.GetType();
#if netle40
            var binderAttr = BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance;
            MethodInfo mi = type.GetMethod(methodName, binderAttr);
            return mi?.Invoke(obj, binderAttr, Type.DefaultBinder, argsValue, null);
#else
            return type.InvokeMember(methodName, BindingFlags.InvokeMethod | BindingFlags.IgnoreCase, Type.DefaultBinder, obj, argsValue, null, null, argsName);
#endif
        }

// obj.FuncMethod("GGGG");
WSComm.InvokeMethod(obj, "FuncMethod", new object[] { "GGGG" });

泛型方法

        /// <summary>
        /// 动态调用对象的泛型方法
        /// </summary>
        /// <param name="obj">指定的对象</param>
        /// <param name="methodName">方法名称</param>
        /// <param name="parameters">参数值</param>
        /// <param name="typeArguments">泛型的类型参数</param>
        /// <returns></returns>
        public static object InvokeGenericMethod(object obj, string methodName, object[] parameters, Type[] typeArguments)
        {
            Type type = obj.GetType();
            MethodInfo mi = type.GetMethod(methodName, BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance);
            MethodInfo generic = mi?.MakeGenericMethod(typeArguments);
            return generic?.Invoke(obj, parameters);
        }

// obj.GenericMethod (42);
WSComm.InvokeGenericMethod(obj, "GenericMethod", new object[] { 42 }, new Type[] { typeof(int) });

静态方法

        /// <summary>
        /// 动态调用对象的静态方法
        /// </summary>
        /// <param name="obj">指定的对象</param>
        /// <param name="methodName">方法名称</param>
        /// <param name="parameters"></param>
        /// <returns></returns>
        public static object InvokeStaticMethod(object obj, string methodName, params object[] parameters)
        {
            Type type = obj.GetType();
            var binderAttr = BindingFlags.InvokeMethod | BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance;
            return type.InvokeMember(methodName, binderAttr, Type.DefaultBinder, obj, parameters);
        }

// obj.StaticMethod("Static");
WSComm.InvokeStaticMethod(obj, "StaticMethod", "Static");

属性

获取属性

        /// <summary>
        /// 动态获取对象的属性值
        /// </summary>
        /// <param name="obj">指定的对象</param>
        /// <param name="propertyName">属性名称（字符串形式）</param>
        /// <param name="args">传递给属性用的参数</param>
        /// <returns></returns>
        public static object InvokeGetProperty(object obj, string propertyName, params object[] args)
        {
            Type type = obj.GetType();
#if netle40
            var pi = type.GetProperty(propertyName);
            if (pi == null)
            {
                return string.Empty;
            }
            object o = pi.GetValue(obj, null);
            if (o == null)
            {
                return string.Empty;
            }
            return o;
#else
            return type.InvokeMember(propertyName, BindingFlags.GetProperty, Type.DefaultBinder, obj, args);
#endif
        } 

// var val = obj.Value;
var val = WSComm.InvokeGetProperty(obj, "Value");

设置属性

        /// <summary>
        /// 动态设置对象的属性
        /// </summary>
        /// <param name="obj">指定的对象</param>
        /// <param name="propertyName">属性名称（字符串形式）</param>
        /// <param name="value">属性值</param>
        public static void InvokeSetProperty(object obj, string propertyName, object value)
        {
            Type type = obj.GetType();
#if netle40
            var pi = type.GetProperty(propertyName);
            if (pi != null)
            {
                pi.SetValue(obj, GetObject(pi, value), null);
            }
#else
            type.InvokeMember(propertyName, BindingFlags.SetProperty, Type.DefaultBinder, obj, new object[] { value });
#endif
        }
        private static object GetObject(PropertyInfo pi, object value)
        {
            switch (pi.PropertyType.Name.ToLower())
            {
                case "int16":
                    return Convert.ToInt16(value);
                case "int32":
                    return Convert.ToInt32(value);
                case "int64":
                    return Convert.ToInt64(value);
                case "string":
                    return Convert.ToString(value);
                case "datetime":
                    return Convert.ToDateTime(value);
                case "boolean":
                    return Convert.ToBoolean(value);
                case "char":
                    return Convert.ToChar(value);
                case "double":
                    return Convert.ToDouble(value);
                case "decimal":
                    return Convert.ToDecimal(value);

                default:
                    return value;
            }
        }

// obj.Value = 30;
WSComm.InvokeSetProperty(obj, "Value", 30);

字段

获取字段

        /// <summary>
        /// 动态获取对象的字段值
        /// </summary>
        /// <param name="obj">指定的对象</param>
        /// <param name="fieldName">字段名称（字符串形式）</param>
        /// <param name="args">传递给字段用的参数</param>
        /// <returns></returns>
        public static object InvokeGetField(object obj, string fieldName, params object[] args)
        {
            Type type = obj.GetType();
            return type.InvokeMember(fieldName, BindingFlags.GetField, Type.DefaultBinder, obj, args);
        }

// var val = obj.Name;
var val = WSComm.InvokeGetField(obj, "Name", null);

设置字段

        /// <summary>
        /// 动态设置对象的字段值
        /// </summary>
        /// <param name="obj">指定的对象</param>
        /// <param name="fieldName">字段名称（字符串形式）</param>
        /// <param name="value">字段值</param>
        public static void InvokeSetField(object obj, string fieldName, object value)
        {
            Type type = obj.GetType();
            type.InvokeMember(fieldName, BindingFlags.SetField, Type.DefaultBinder, obj, new object[] { value });
        }

// obj.Name = "NewName";
WSComm.InvokeSetField(obj, "Name", "NewName");

Demo

    public class Example
    {
        /// <summary>
        /// 字段
        /// </summary>
        public string Name = "initialName";
        /// <summary>
        /// 属性
        /// </summary>
        public int Value { get; set; } = 20;

        /// <summary>
        /// 事件
        /// </summary>
        public event EventHandler MyEvent;
        private string _eventrase;
        public string Eventrase
        {
            get => _eventrase;
            set
            {
                if (_eventrase != value)
                {
                    _eventrase = value;
                    MyEvent?.Invoke(this, new MyEventArgs { Args = _eventrase });
                }
            }
        }
        /// <summary>
        /// 一般方法
        /// </summary>
        /// <param name="prefix"></param>
        /// <returns></returns>
        public string FuncMethod(string prefix)
        {
            return prefix + "REST";
        }
        /// <summary>
        /// 泛型方法
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="display"></param>
        /// <returns></returns>
        public string GenericMethod<T>(T display)
        {
            return "Here it is: " + display.ToString();
        }
        /// <summary>
        /// 全局静态方法
        /// </summary>
        /// <param name="arg"></param>
        /// <returns></returns>
        public string StaticMethod(string arg)
        {
            return arg + "1234";
        }
    }
    public class MyEventArgs : EventArgs
    {
        public object Args { get; set; }
    }