C#反射操作工具类

　　在C#中通过反射机制将查询到的DataTable或DataReader转换成相对应的对象类型。

/// <summary>
/// 反射操作工具类
/// </summary>
public class ReflectionUtil
{
    #region 根据反射机制将dataTable中指定行的数据赋给obj对象

    /// <summary>
    /// 根据反射机制将dataTable中指定行的数据赋给obj对象
    /// </summary>
    /// <param name="obj">obj对象</param>
    /// <param name="dataTable">dataTable</param>
    /// <param name="rowIndex">指定行</param>
    public static void ConvertDataRowToModel(object obj, DataTable dataTable, int rowIndex)
    {
        //指定行不存在
        if (dataTable.Rows.Count < (rowIndex + 1))
            throw new Exception("指定行不存在!");

        //DataTable列为空!
        if (dataTable.Columns.Count < 1)
            throw new Exception("DataTable列为空!");

        Type type = obj.GetType();
        PropertyInfo[] pInfos = type.GetProperties();

        try
        {
            for (int i = 0; i < dataTable.Columns.Count; i++)
            {
                for (int j = 0; j < pInfos.Length; j++)
                {
                    //全部转换为小写的作用是防止数据库列名的大小写和属性的大小写不一致
                    if (dataTable.Columns[i].ColumnName.ToLower() == pInfos[j].Name.ToLower())
                    {
                        PropertyInfo pInfo = type.GetProperty(pInfos[j].Name);  //obj某一属性对象
                        object colValue = dataTable.Rows[rowIndex][i]; //DataTable 列值
                        SetObjectValue(obj, colValue, pInfo, pInfos, j);
                        break;
                    }
                }
            }
        }
        catch (Exception ex)
        {
            //LogTxt.LogException(ex.Message + "
" + ex.Source + "
" + ex.TargetSite + "
" + ex.StackTrace + "
");
            throw ex;
        }
    }

    #endregion

    #region 将值赋给object属性

    public static void SetObjectValue(object obj, object colValue, PropertyInfo pInfo, PropertyInfo[] pInfos, int j)
    {
        if (!ObjectIsNull(colValue))
        {
            if (pInfos[j].PropertyType.FullName == "System.String")
            {
                pInfo.SetValue(obj, Convert.ToString(colValue), null);
            }
            else if (pInfos[j].PropertyType.FullName == "System.Int32")
            {
                pInfo.SetValue(obj, Convert.ToInt32(colValue), null);
            }
            else if (pInfos[j].PropertyType.FullName == "System.Int64")
            {
                pInfo.SetValue(obj, Convert.ToInt64(colValue), null);
            }
            else if (pInfos[j].PropertyType.FullName == "System.Single")
            {
                pInfo.SetValue(obj, Convert.ToSingle(colValue), null);
            }
            else if (pInfos[j].PropertyType.FullName == "System.Double")
            {
                pInfo.SetValue(obj, Convert.ToDouble(colValue), null);
            }
            else if (pInfos[j].PropertyType.FullName == "System.Decimal")
            {
                pInfo.SetValue(obj, Convert.ToDecimal(colValue), null);
            }
            else if (pInfos[j].PropertyType.FullName == "System.Char")
            {
                pInfo.SetValue(obj, Convert.ToChar(colValue), null);
            }
            else if (pInfos[j].PropertyType.FullName == "System.Boolean")
            {
                pInfo.SetValue(obj, Convert.ToBoolean(colValue), null);
            }
            else if (pInfos[j].PropertyType.FullName == "System.DateTime")
            {
                pInfo.SetValue(obj, Convert.ToDateTime(colValue), null);
            }
            //可空类型
            else if (pInfos[j].PropertyType.FullName == "System.Nullable`1[[System.DateTime, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]]")
            {
                pInfo.SetValue(obj, Convert.ToDateTime(colValue), null);
            }
            else if (pInfos[j].PropertyType.FullName == "System.Nullable`1[[System.DateTime, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]]")
            {
                pInfo.SetValue(obj, Convert.ToDateTime(colValue), null);
            }
            else if (pInfos[j].PropertyType.FullName == "System.Nullable`1[[System.Int32, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]]")
            {
                pInfo.SetValue(obj, Convert.ToInt32(colValue), null);
            }
            else if (pInfos[j].PropertyType.FullName == "System.Nullable`1[[System.Int32, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]]")
            {
                pInfo.SetValue(obj, Convert.ToInt32(colValue), null);
            }
            else if (pInfos[j].PropertyType.FullName == "System.Nullable`1[[System.Int64, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]]")
            {
                pInfo.SetValue(obj, Convert.ToInt64(colValue), null);
            }
            else if (pInfos[j].PropertyType.FullName == "System.Nullable`1[[System.Int64, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]]")
            {
                pInfo.SetValue(obj, Convert.ToInt64(colValue), null);
            }
            else if (pInfos[j].PropertyType.FullName == "System.Nullable`1[[System.Decimal, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]]")
            {
                pInfo.SetValue(obj, Convert.ToDecimal(colValue), null);
            }
            else if (pInfos[j].PropertyType.FullName == "System.Nullable`1[[System.Decimal, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]]")
            {
                pInfo.SetValue(obj, Convert.ToDecimal(colValue), null);
            }
            else if (pInfos[j].PropertyType.FullName == "System.Nullable`1[[System.Boolean, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]]")
            {
                pInfo.SetValue(obj, Convert.ToBoolean(colValue), null);
            }
            else if (pInfos[j].PropertyType.FullName == "System.Nullable`1[[System.Boolean, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]]")
            {
                pInfo.SetValue(obj, Convert.ToBoolean(colValue), null);
            }
            else
            {
                throw new Exception("属性包含不支持的数据类型!");
            }
        }
        else
        {
            pInfo.SetValue(obj, null, null);
        }
    }

    #endregion

    #region 根据反射机制从obj对象取值并用该值添加datatable行

    /// <summary>
    /// 根据反射机制从obj对象取值并用该值添加datatable行
    /// </summary>
    /// <param name="obj">obj对象</param>
    /// <param name="dataTable">dataTable</param>
    /// <param name="rowIndex">指定行</param>
    public static void ConvertModelToNewDataRow(object obj, DataTable dataTable, int rowIndex)
    {
        //DataTable列为空!
        if (dataTable.Columns.Count < 1)
        {
            throw new Exception("DataTable列为空!");
        }

        DataRow dr = dataTable.NewRow();
        Type type = obj.GetType();
        PropertyInfo[] pInfos = type.GetProperties();

        try
        {
            for (int i = 0; i < dataTable.Columns.Count; i++)
            {
                for (int j = 0; j < pInfos.Length; j++)
                {
                    //全部转换为小写的作用是防止数据库列名的大小写和属性的大小写不一致
                    if (dataTable.Columns[i].ColumnName.ToLower() == pInfos[j].Name.ToLower())
                    {
                        PropertyInfo pInfo = type.GetProperty(pInfos[j].Name);

                        object beanValue = pInfo.GetValue(obj, null);

                        //将bean中属性值赋给datarow
                        if (!ObjectIsNull(beanValue))
                        {
                            dr[i] = beanValue;
                        }
                        else
                        {
                            dr[i] = DBNull.Value;
                        }
                        break;
                    }
                }
            }

            dataTable.Rows.InsertAt(dr, rowIndex);
            dataTable.AcceptChanges();
        }
        catch (Exception ex)
        {
            //LogTxt.LogException(ex.Message + "
" + ex.Source + "
" + ex.TargetSite + "
" + ex.StackTrace + "
");
            throw ex;
        }
    }

    #endregion

    #region 根据反射机制从obj对象取值并赋给datatable的指定行

    /// <summary>
    /// 根据反射机制从obj对象取值并赋给datatable的指定行
    /// </summary>
    /// <param name="obj">obj对象</param>
    /// <param name="dataTable">dataTable</param>
    /// <param name="rowIndex">指定行</param>
    public static void ConvertModelToSpecDataRow(object obj, DataTable dataTable, int rowIndex)
    {
        //指定行不存在
        if (dataTable.Rows.Count < (rowIndex + 1))
        {
            throw new Exception("指定行不存在!");
        }

        //DataTable列为空!
        if (dataTable.Columns.Count < 1)
        {
            throw new Exception("DataTable列为空!");
        }

        Type type = obj.GetType();
        PropertyInfo[] pInfos = type.GetProperties();

        try
        {
            for (int i = 0; i < dataTable.Columns.Count; i++)
            {
                for (int j = 0; j < pInfos.Length; j++)
                {
                    //全部转换为小写的作用是防止数据库列名的大小写和属性的大小写不一致

                    if (dataTable.Columns[i].ColumnName.ToLower() == pInfos[j].Name.ToLower())
                    {
                        PropertyInfo pInfo = type.GetProperty(pInfos[j].Name);
                        object beanValue = pInfo.GetValue(obj, null);

                        //将bean中属性值赋给datarow
                        if (!ObjectIsNull(beanValue))
                        {
                            dataTable.Rows[rowIndex][i] = beanValue;
                        }
                        else
                        {
                            dataTable.Rows[rowIndex][i] = DBNull.Value;
                        }
                        break;
                    }
                }
            }
            dataTable.AcceptChanges();
        }
        catch (Exception ex)
        {
            //LogTxt.LogException(ex.Message + "
" + ex.Source + "
" + ex.TargetSite + "
" + ex.StackTrace + "
");
            throw ex;
        }
    }

    #endregion

    #region 根据对象名返回类实例

    /// <summary>
    /// 根据对象名返回类实例
    /// </summary>
    /// <param name="parObjectName">对象名称</param>
    /// <returns>对象实例（可强制转换为对象实例）</returns>
    public static object GetObjectByObjectName(string parObjectName)
    {
        Type t = Type.GetType(parObjectName); //找到对象
        return System.Activator.CreateInstance(t);         //实例化对象
    }

    #endregion

    #region 判断对象是否为空

    /// <summary>
    /// 判断对象是否为空
    /// </summary>
    /// <param name="obj">对象</param>
    /// <returns></returns>
    static public bool ObjectIsNull(Object obj)
    {
        //如果对象引用为null 或者 对象值为null 或者对象值为空
        if (obj == null || obj == DBNull.Value || obj.ToString().Equals("") || obj.ToString() == "")
        {
            return true;
        }
        return false;
    }

    #endregion

    #region 根据反射机制将DataTable转换为实体集合

    /// <summary>
    /// 根据反射机制将DataTable转换为实体集合
    /// </summary>
    /// <typeparam name="T">实体类型</typeparam>
    /// <param name="dt">DataTable</param>
    /// <returns>实体集合</returns>
    public static List<T> ConvertDataTableToModelList<T>(DataTable dt)
    {
        if (dt == null)
        {
            return null;
        }
        List<T> result = new List<T>();
        for (int i = 0; i < dt.Rows.Count; i++)
        {
            T t = Activator.CreateInstance<T>();
            ConvertDataRowToModel(t, dt, i);
            result.Add(t);
        }
        return result;
    }

    #endregion

    #region 根据反射机制将DataReader转换为实体集合

    /// <summary>
    /// 根据反射机制将DataReader转换为实体集合
    /// </summary>
    /// <typeparam name="T">实体类型</typeparam>
    /// <param name="dr">DataReader</param>
    /// <returns>实体</returns>
    public static T ConvertDataReaderToModel<T>(MySqlDataReader dr)
    {
        T obj = Activator.CreateInstance<T>();
        if (dr == null)
            throw new Exception("制定对象不存在。");

        if (!dr.Read())
            throw new Exception("无法读取数据。");

        Type type = obj.GetType();
        PropertyInfo[] pInfos = type.GetProperties();
        for (int i = 0; i < dr.FieldCount; i++)
        {
            for (int j = 0; j < pInfos.Length; j++)
            {
                if (dr.GetName(i).ToLower() == pInfos[j].Name.ToLower())
                {
                    PropertyInfo pInfo = type.GetProperty(pInfos[j].Name);  //obj某一属性对象                        
                    object colValue = dr[i]; //DataTable 列值
                    SetObjectValue(obj, colValue, pInfo, pInfos, j);
                    break;
                }
            }
        }
        //关闭
        if (!dr.IsClosed)
        {
            dr.Close();
        }
        return (T)obj;
    }

    #endregion

    /// <summary>
    /// 通用（调用对象方法前先new一遍对象，故对象的状态无法保留；无用有无参构造函数，并调用无参方法），
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="methodName"></param>
    public static void InvokeMethod<T>(string methodName, object[] param = null) where T : new()
    {
        T instance = new T();
        MethodInfo method = typeof(T).GetMethod(methodName, new Type[] { });
        method.Invoke(instance, param);
    }

    /// <summary>
    /// 调用一个具体实例对象的方法，会保留对象状态
    /// </summary>
    /// <param name="o"></param>
    /// <param name="methodName"></param>
    public static void InvokeMethod(object o, string methodName, object[] param = null)
    {
        o.GetType().GetMethod(methodName, new Type[] { }).Invoke(o, param);
    }
}

　　调用方式

　　一、将查询到的DataTable转换成对象集合

/// <summary>
/// 获取列表
/// </summary>
/// <typeparam name="T">数据类型</typeparam>
/// <param name="_connectionString">数据库连接字符串</param>
/// <param name="_sql">SQL语句</param>
/// <returns>数据集合</returns>
public static List<T> GetDataListBySQL<T>(string _connectionString, string _sql)
{
    try
    {
        //读取数据库
        DataTable dt = MySqlHelper.ExecuteDataset(_connectionString, _sql).Tables[0];
        //通过反射获取实体集合
        return ReflectionUtil.ConvertDataTableToModelList<T>(dt);
    }
    catch (Exception _ex)
    {
        //定义异常处理
        return default(List<T>);
    }
}

　　

　　二、将查询到的DataReader转换成对象（以MySQL为例）

/// <summary>
/// 获取对象
/// </summary>
/// <typeparam name="T">数据类型</typeparam>
/// <param name="_connectionString">数据库连接字符串</param>
/// <param name="_sql">SQL语句</param>
/// <returns>数据对象</returns>
public static T GetObjBySQL<T>(string _connectionString, string _sql)
{
    try
    {
        //读取数据库
        MySqlDataReader dr = MySqlHelper.ExecuteReader(_connectionString, _sql);
        //通过反射获取实体
        return ReflectionUtil.ConvertDataReaderToModel<T>(dr);
    }
    catch (Exception _ex)
    {
        //定义异常处理
        return default(T);
    }
}

　　

　　三、调用实体的对象方法

　　1.调用一个具体实例对象的方法，会保留对象状态。

/// <summary>
/// 打开窗体
/// </summary>
private void OpenDialog()
{
    Form form = new Form();
    ReflectionUtil.InvokeMethod(form, "ShowDialog");
    ReflectionUtil.InvokeMethod(form, "Dispose");
}

　　2.通过类型调用对象的方法，调用时会先new 一个实例，对象的状态无法保留。

/// <summary>
/// 打开窗体
/// </summary>
private void OpenDialog()
{
    ReflectionUtil.InvokeMethod<Form>("ShowDialog");
    ReflectionUtil.InvokeMethod<Form>("Dispose");
}