使用反射实例化对象（代码）

注：目前还不能完全理解“反射”，故只记录代码，待思维成熟后补全理解

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Data;

using System.Reflection;
namespace LoadCode
{
    /// <summary>
    /// 反射实例化对象
    /// </summary>
    public class CreateObject
    {
        public bool Success { get; set; } = true;
        public string ErrorMessage { get; set; } = string.Empty;

        private T Invoke<T>(Func<T> func) where T : class, new()
        {
            T obj = default(T);
            try
            {
                Success = true;
                ErrorMessage = string.Empty;
                obj = func.Invoke();
            }
            catch (Exception ex)
            {
                Success = false;
                ErrorMessage = string.Format("对象实例化异常：{0}->{1}", ex.Message, ex.StackTrace);
            }
            return obj;
        }

        private List<T> Invoke<T>(Func<List<T>> func) where T : class, new()
        {
            List<T> objList = new List<T>();
            try
            {
                Success = true;
                ErrorMessage = string.Empty;
                objList = func.Invoke();
            }
            catch (Exception ex)
            {
                Success = false;
                ErrorMessage = string.Format("对象实例化异常：{0}->{1}", ex.Message, ex.StackTrace);
            }
            return objList;
        }

        /// <summary>
        /// 使用DataSet实例化对象
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="ds"></param>
        /// <returns></returns>
        public T CreateObjectByDataSet<T>(DataSet ds) where T : class, new()
        {
            return Invoke(() =>
            {
                T obj = default(T);
                Type _type = typeof(T);
                if (ds.Equals(null))
                {
                    return obj;
                }
                PropertyInfo[] propertys = _type.GetProperties(BindingFlags.Instance | BindingFlags.Public);
                ConstructorInfo info = _type.GetConstructor(new Type[] { });
                obj = (T)info.Invoke(new object[] { });
                for (int i = 0; i < propertys.Length; i++)
                {
                    PropertyInfo ProInfo = propertys[i];
                    if (ds.Tables[0].Columns.IndexOf(ProInfo.Name) != -1 && !obj.Equals(null))
                    {
                        ProInfo.SetValue(obj, ds.Tables[0].Rows[0][ProInfo.Name]);
                    }
                }
                return obj;
            });
        }

        /// <summary>
        /// 使用DataSet实例化对象列表
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="ds"></param>
        /// <returns></returns>
        public List<T> CreateObjectsByDataSet<T>(DataSet ds) where T : class, new()
        {
            return Invoke(() =>
            {
                List<T> objList = new List<T>();
                Type _type = typeof(T);
                if (ds.Equals(null))
                {
                    return objList;
                }
                PropertyInfo[] ProInfos = _type.GetProperties(BindingFlags.Public | BindingFlags.Instance);
                for (int i = 0; i < ds.Tables[0].Rows.Count; i++)
                {
                    ConstructorInfo ConstInfo = _type.GetConstructor(new Type[] { });
                    T obj = (T)ConstInfo.Invoke(new object[] { });
                    for (int j = 0; j < ProInfos.Length; j++)
                    {
                        PropertyInfo ProInfo = ProInfos[j];
                        if (ds.Tables[0].Columns.IndexOf(ProInfo.Name) != -1 && !obj.Equals(null))
                        {
                            ProInfo.SetValue(obj, ds.Tables[0].Rows[i][ProInfo.Name]);
                        }
                    }
                    objList.Add(obj);
                }
                return objList;
            });
        }


        /// <summary>
        /// 使用DataSet根据对象构造函数实例化
        /// Column数量对应构造函数参数数量
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="ds"></param>
        /// <returns></returns>
        public T CreateObjectByConstructor<T>(DataSet ds) where T : class, new()
        {
            return Invoke(() =>
              {
                  T obj = default(T);
                  if (ds == null || ds.Tables.Count <= 0)
                  {
                      return obj;
                  }
                  int cLenght = ds.Tables[0].Columns.Count;
                  Type _type = typeof(T);
                  Type[] types = new Type[cLenght];
                  object[] objects = new object[cLenght];
                  for (int i = 0; i < ds.Tables[0].Columns.Count; i++)
                  {
                      types[i] = ds.Tables[0].Rows[0][i].GetType();
                      objects[i] = ds.Tables[0].Rows[0][i];
                  }
                  ConstructorInfo ConstInfo = _type.GetConstructor(types);
                  obj = (T)ConstInfo.Invoke(objects);
                  return obj;
              });
        }

        /// <summary>
        /// 使用DataSet根据对象构造函数实例化
        /// Column数量对应构造函数参数数量
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="arges"></param>
        /// <returns></returns>
        public List<T> CreateObjectsByConstructor<T>(DataSet arges) where T : class, new()
        {
            return Invoke(() =>
            {
                List<T> list = new List<T>();
                Type t = typeof(T); //获取类型？
                if (arges.Equals(null))  //几列代表几个字段
                {
                    return list;
                }
                int cLenght = arges.Tables[0].Columns.Count, rLenght = arges.Tables[0].Rows.Count;
                Type[] types = new Type[cLenght]; //反射对象的类型集合
                object[] param = new object[cLenght]; //反射对象的数据集合
                for (int i = 0; i < rLenght; i++)
                {
                    for (int j = 0; j < cLenght; j++)
                    {
                        types[j] = arges.Tables[0].Rows[i][j].GetType();
                        param[j] = arges.Tables[0].Rows[i][j];
                    }
                    ConstructorInfo info = t.GetConstructor(types);
                    if (info != null)
                    {
                        list.Add((T)info.Invoke(param));
                    }
                    else
                    {
                        list.Add((T)Activator.CreateInstance(t, null));
                    }
                }
                return list;
            });
        }


        /// <summary>
        /// 使用object[]实例化对象
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="arges"></param>
        /// <returns></returns>
        public T CreateObjectsByParams<T>(params object[] arges) where T : class, new()
        {
            return Invoke(() =>
            {
                T obj = default(T);
                Type t = typeof(T); //获取类型？
                if (arges.Equals(null))
                {
                    return obj;
                }
                int lenght = arges.Length;
                Type[] types = new Type[lenght]; //类型集合？
                object[] param = new object[lenght]; //数据集合？ 对象集合？
                for (int i = 0; i < lenght; i++)
                {
                    types[i] = arges[i].GetType(); //添加类型？
                    param[i] = arges[i]; //添加对象？上面为获取类型，这里为数据？数据的格式是什么？失去了类型数据会以什么样的形式表现？
                }
                ConstructorInfo info = t.GetConstructor(types); //获取类型集合里面所有的类型？
                if (info != null)
                {
                    obj = (T)info.Invoke(param);
                }
                else
                {
                    obj = (T)Activator.CreateInstance(t, null);
                }
                return obj;
            });
        }
    }
}