/// <summary>
/// 由一行数据生成一个实体
/// </summary>
/// <typeparam name="T">实体类型</typeparam>
/// <param name="dataRow">数据行</param>
/// <param name="smartMappingType">反射方式</param>
/// <returns>反射后的实体</returns>
public static T GetEntity <T>(this DataRow dataRow, FrameMappingType smartMappingType)
{
T item = Activator.CreateInstance <T>();
GetEntity <T>(dataRow, smartMappingType, ref item);
return(item);
}
/// <summary>
/// 由一个DataTable返回一个实体列表
/// </summary>
/// <typeparam name="T">实体类型</typeparam>
/// <param name="dataTable">数据表</param>
/// <param name="smartMappingType">反射的方式</param>
/// <returns>反射后的实体列表</returns>
public static List <T> GetEntityList <T>(this DataTable dataTable, FrameMappingType smartMappingType)
{
if (dataTable.Rows.Count > 0)
{
return(GetEntityList <T>(dataTable.Rows, smartMappingType));
}
return(new List <T>());
}
/// <summary>
/// 获取某个实体或匿名类型的由某特性标识的字段集合，包括公共字段和非公共字段
/// </summary>
/// <typeparam name="TAttribute">特性的类型</typeparam>
/// <param name="type">实体或匿名对象的类型</param>
/// <param name="frameMappingType">应用的反射方式</param>
/// <returns>字段数组</returns>
public static FieldInfo[] GetFieldInfoByAttribute <TAttribute>(Type type, FrameMappingType frameMappingType) where TAttribute : Attribute
{
List <FieldInfo> listFieldInfo = new List <FieldInfo>();
foreach (FieldInfo fieldInfo in GetFieldInfos(type, frameMappingType))
{
TAttribute attribute = Attribute.GetCustomAttribute(fieldInfo, typeof(TAttribute), false) as TAttribute;
if (attribute != null)
{
listFieldInfo.Add(fieldInfo);
}
}
return(listFieldInfo.ToArray());
}
/// <summary>
/// 由一个DataRow集合返回一个实体列表
/// </summary>
/// <typeparam name="T">实体类型</typeparam>
/// <param name="dataRowCollection">数据行的集合</param>
/// <param name="smartMappingType">反射的方式</param>
/// <returns>反射后的实体列表</returns>
public static List <T> GetEntityList <T>(DataRowCollection dataRowCollection, FrameMappingType smartMappingType)
{
List <T> list = new List <T>();
PropertyInfo[] propertyInfos = null;
FieldInfo[] fieldInfos = null;
foreach (DataRow row in dataRowCollection)
{
T item = Activator.CreateInstance <T>();
GetEntity <T>(row, smartMappingType, ref item, propertyInfos, fieldInfos);
list.Add(item);
}
return(list);
}
/// <summary>
/// 由一个DataRow集合返回一个实体列表
/// </summary>
/// <typeparam name="T">实体类型</typeparam>
/// <param name="dataRowCollection">数据行的集合</param>
/// <param name="smartMappingType">反射的方式</param>
/// <returns>反射后的实体列表</returns>
public static List <T> GetEntityList <T>(DataRowCollection dataRowCollection, FrameMappingType smartMappingType)
{
return(FrameWork.Core.DataCommon.GetEntityList <T>(dataRowCollection, smartMappingType));
}
/// <summary>
/// 根据映射方式获取实体或匿名对象的字段以及对应值的 Dictionary 列表
/// </summary>
/// <param name="item">实体或匿名实体</param>
/// <param name="smartMappingType">映射方式</param>
/// <returns>字段或属性名称，值列表</returns>
public static Dictionary <string, object> GetColumnDic(object item, FrameMappingType smartMappingType)
{
Type itemType = item.GetType();
Dictionary <string, object> list = new Dictionary <string, object>();
switch (smartMappingType)
{
case FrameMappingType.FrameAttributePublic: ////公有特性
case FrameMappingType.FrameAttributePrivate: ////私有特性
case FrameMappingType.FrameAttribute: ////根据特性映射，不区分公有私有
{
////根据特性标识设置属性
foreach (PropertyInfo propertyInfo in FrameReflection.GetPropertyInfoByAttribute <FrameColumnMappingAttributes>(itemType, smartMappingType))
{
FrameColumnMappingAttributes attribute = Attribute.GetCustomAttribute(propertyInfo, typeof(FrameColumnMappingAttributes), false) as FrameColumnMappingAttributes;
object value = propertyInfo.GetValue(item, null);
list.Add(attribute.ColumnName, value);
}
////根据特性标识设置字段
foreach (FieldInfo fieldInfo in FrameReflection.GetFieldInfoByAttribute <FrameColumnMappingAttributes>(itemType, smartMappingType))
{
FrameColumnMappingAttributes attribute = Attribute.GetCustomAttribute(fieldInfo, typeof(FrameColumnMappingAttributes), false) as FrameColumnMappingAttributes;
object value = fieldInfo.GetValue(item);
list.Add(attribute.ColumnName, value);
}
}
break;
case FrameMappingType.XmlElementPublic: ////公有XmlElement
case FrameMappingType.XmlElementPrivate: ////私有XmlElement
case FrameMappingType.XmlElement: ////根据XmlElement映射，不区分公有私有
{
////根据特性标识设置属性
foreach (PropertyInfo propertyInfo in FrameReflection.GetPropertyInfoByAttribute <System.Xml.Serialization.XmlElementAttribute>(itemType, smartMappingType))
{
System.Xml.Serialization.XmlElementAttribute attribute = Attribute.GetCustomAttribute(propertyInfo, typeof(System.Xml.Serialization.XmlElementAttribute), false) as System.Xml.Serialization.XmlElementAttribute;
object value = propertyInfo.GetValue(item, null);
list.Add(attribute.ElementName, value);
}
////根据特性标识设置字段
foreach (FieldInfo fieldInfo in FrameReflection.GetFieldInfoByAttribute <System.Xml.Serialization.XmlElementAttribute>(itemType, smartMappingType))
{
System.Xml.Serialization.XmlElementAttribute attribute = Attribute.GetCustomAttribute(fieldInfo, typeof(System.Xml.Serialization.XmlElementAttribute), false) as System.Xml.Serialization.XmlElementAttribute;
object value = fieldInfo.GetValue(item);
list.Add(attribute.ElementName, value);
}
}
break;
case FrameMappingType.Field: ////根据字段映射，私有公有均可
case FrameMappingType.FieldPrivate: ////根据私有字段映射
case FrameMappingType.FieldPublic: ////根据公有字段映射
{
foreach (FieldInfo fieldInfo in FrameReflection.GetFieldInfos(itemType, smartMappingType))
{
object value = fieldInfo.GetValue(item);
list.Add(fieldInfo.Name, value);
}
}
break;
case FrameMappingType.Property: ////根据属性映射 私有公有均可
case FrameMappingType.PropertyPublic: ////根据公有属性映射
case FrameMappingType.ProertyPrivate: ////根据私有属性映射
{
foreach (PropertyInfo propertyInfo in FrameReflection.GetPropertyInfos(itemType, smartMappingType))
{
object value = propertyInfo.GetValue(item, null);
list.Add(propertyInfo.Name, value);
}
}
break;
}
return(list);
}
/// <summary>
/// 取某个实体或匿名类型的字段集合
/// </summary>
/// <param name="type">实体类型或匿名类型</param>
/// <param name="frameMappingType">映射类型</param>
/// <returns>字段数组</returns>
public static FieldInfo[] GetFieldInfos(Type type, FrameMappingType frameMappingType)
{
return(type.GetFields(FrameReflection.GetBindingFlagsByFrameMappingType(frameMappingType)));
}
/// <summary>
/// 提供修改传入实体的方法
/// 条件为主键相同，该实体必须有且仅有一个字段被特性 [PrimaryKeyAttribute] 标识为主键
/// 默认使用框架的数据库连接
/// </summary>
/// <param name="frameMappingType">自定义的 映射方式</param>
/// <returns>返回影响的 行数</returns>
public int Update(FrameMappingType frameMappingType)
{
return(FrameEntityBLL.Update(this, FrameWork.Core.DataCommon.DataBaseConnectionString, FrameWork.Core.DataCommon.FrameDataBaseType, frameMappingType));
}
/// <summary>
/// 由一个DataTable返回一个实体列表
/// </summary>
/// <typeparam name="T">实体类型</typeparam>
/// <param name="dataTable">数据表</param>
/// <param name="smartMappingType">反射的方式</param>
/// <returns>反射后的实体列表</returns>
internal static List <T> GetEntityList <T>(DataTable dataTable, FrameMappingType smartMappingType)
{
return(FrameWork.Core.FrameData.FrameDataBase.GetEntityList <T>(dataTable, smartMappingType));
}
/// <summary>
/// 提供修改传入实体的方法
/// 条件为主键相同，该实体必须有且仅有一个字段被特性 [PrimaryKeyAttribute] 标识为主键
/// 默认使用框架的数据库连接
/// </summary>
/// <param name="item">要修改的 实体</param>
/// <param name="frameMappingType">自定义的 映射方式</param>
/// <returns>返回影响的 行数</returns>
internal static int Update(object item, FrameMappingType frameMappingType)
{
return(Update(item, FrameWork.Core.DataCommon.DataBaseConnectionString, FrameWork.Core.DataCommon.FrameDataBaseType, frameMappingType));
}
/// <summary>
/// 提供将提供的实体添加到数据库的方法
/// </summary>
/// <param name="connectionString">自定应的连接字符串</param>
/// <param name="dataBaseType">自定应数据库类型</param>
/// <param name="frameMappingType">所应用的映射类型</param>
/// <returns>返回影响的行数</returns>
public int Add(string connectionString, FrameData.DataBaseType dataBaseType, FrameMappingType frameMappingType)
{
return(FrameEntityBLL.Add(this, connectionString, dataBaseType, frameMappingType));
}
/// <summary>
/// 提供将提供的实体添加到数据库的方法
/// </summary>
/// <param name="item">增加的实体</param>
/// <param name="connectionString">自定应的连接字符串</param>
/// <param name="dataBaseType">自定应数据库类型</param>
/// <param name="frameMappingType">所应用的映射类型</param>
/// <returns>返回影响的行数</returns>
internal static int Add(object item, string connectionString, FrameData.DataBaseType dataBaseType, FrameMappingType frameMappingType)
{
Dictionary <string, object> columnDic = FrameData.FrameDataBase.GetColumnDic(item, frameMappingType);
string insertSql = FrameGenerateSql.GenerateInsertSql(item.GetType().ToString(), columnDic, dataBaseType);
return(FrameData.FrameDataBase.ExecuteNonQuery(connectionString, insertSql, System.Data.CommandType.Text, FrameDataBase.GetParameters(columnDic, dataBaseType), dataBaseType));
}
/// <summary>
/// 提供修改传入实体的方法
/// 条件为主键相同，该实体必须有且仅有一个字段被特性 [PrimaryKeyAttribute] 标识为主键
/// </summary>
/// <param name="item">要修改的 实体</param>
/// <param name="connectionString">自定应的 连接字符串</param>
/// <param name="dataBaseType">自定应 数据库类型</param>
/// <param name="frameMappingType">所应用的 映射类型</param>
/// <returns>返回影响的行数</returns>
internal static int Update(object item, string connectionString, FrameData.DataBaseType dataBaseType, FrameMappingType frameMappingType)
{
Dictionary <string, object> columnDic = FrameData.FrameDataBase.GetColumnDic(item, frameMappingType);
Dictionary <string, object> primaryKeyDic = FrameData.FrameDataBase.GetColumnDicByUserAttribute <CoreAttribute.PrimaryKeyAttribute>(item, "PrimaryKeyName");
if (primaryKeyDic.Count > 1)
{
throw new Exception(FrameWork.Core.Resources.Exceptions.FrameCHExceptionResource.__FrameEntityPrimaryKeyToMary);
}
if (primaryKeyDic.Count < 1)
{
throw new Exception(FrameWork.Core.Resources.Exceptions.FrameCHExceptionResource.__FrameEntityPrimaryKeyNull);
}
string updateSql = FrameGenerateSql.GenerateUpdateSql(item.GetType().ToString(), primaryKeyDic.First().Key, columnDic, dataBaseType);
return(FrameData.FrameDataBase.ExecuteNonQuery(connectionString, updateSql, System.Data.CommandType.Text, FrameDataBase.GetParameters(columnDic, dataBaseType), dataBaseType));
}
/// <summary>
/// 由一个DataTable返回一个实体列表
/// </summary>
/// <typeparam name="T">实体类型</typeparam>
/// <param name="dataTable">数据表</param>
/// <param name="smartMappingType">反射的方式</param>
/// <returns>反射后的实体列表</returns>
internal static List <T> GetEntityList <T>(DataTable dataTable, FrameMappingType smartMappingType)
{
return(FrameWork.Core.DataCommon.GetEntityList <T>(dataTable.Rows, smartMappingType));
}
/// <summary>
/// 由一行数据生成一个实体
/// </summary>
/// <typeparam name="T">目标实体类型</typeparam>
/// <param name="dataRow">数据行</param>
/// <param name="smartMappingType">反射方式</param>
/// <param name="item">已实例化的实体</param>
/// <param name="propertyInfos">属性</param>
/// <param name="fieldInfos">字段</param>
private static void GetEntity <T>(this DataRow dataRow, FrameMappingType smartMappingType, ref T item, PropertyInfo[] propertyInfos = null, FieldInfo[] fieldInfos = null)
{
Type itemType = item.GetType();
switch (smartMappingType)
{
case FrameMappingType.FrameAttributePublic: ////在公有字段或属性中查找特性
case FrameMappingType.FrameAttributePrivate: ////在私有字段或属性中查找特性
case FrameMappingType.FrameAttribute: ////在所有字段或属性中查找特性
{
////设置属性的值
foreach (PropertyInfo propertyInfo in propertyInfos = propertyInfos != null ? propertyInfos : FrameReflection.GetPropertyInfoByAttribute <FrameColumnMappingAttributes>(itemType, smartMappingType))
{
FrameColumnMappingAttributes attribute = Attribute.GetCustomAttribute(propertyInfo, typeof(FrameColumnMappingAttributes), false) as FrameColumnMappingAttributes;
if (dataRow.Table.Columns.Contains(attribute.ColumnName))
{
object value = dataRow[attribute.ColumnName];
if (value == null || value.ToString().Trim() == string.Empty)
{
propertyInfo.SetValue(item, attribute.DefaultVale, null);
}
else
{
propertyInfo.SetValue(item, (value.GetType() == propertyInfo.PropertyType ? value : FrameReflection.ConvertTo(value.ToString().Trim(), propertyInfo.PropertyType)), null);
}
}
else
{
propertyInfo.SetValue(item, attribute.DefaultVale, null);
}
}
////设置字段的值
foreach (FieldInfo fieldInfo in fieldInfos = fieldInfos != null ? fieldInfos : FrameReflection.GetFieldInfoByAttribute <FrameColumnMappingAttributes>(itemType, smartMappingType))
{
FrameColumnMappingAttributes attribute = Attribute.GetCustomAttribute(fieldInfo, typeof(FrameColumnMappingAttributes), false) as FrameColumnMappingAttributes;
if (dataRow.Table.Columns.Contains(attribute.ColumnName))
{
object value = dataRow[attribute.ColumnName];
if (value == null || value.ToString().Trim() == string.Empty)
{
fieldInfo.SetValue(item, attribute.DefaultVale);
}
else
{
fieldInfo.SetValue(item, (value.GetType() == fieldInfo.FieldType ? value : FrameReflection.ConvertTo(value.ToString().Trim(), fieldInfo.FieldType)));
}
}
else
{
fieldInfo.SetValue(item, attribute.DefaultVale);
}
}
}
break;
case FrameMappingType.XmlElement:
case FrameMappingType.XmlElementPrivate:
case FrameMappingType.XmlElementPublic:
{
////设置属性的值
foreach (PropertyInfo propertyInfo in propertyInfos = propertyInfos != null ? propertyInfos : FrameReflection.GetPropertyInfoByAttribute <System.Xml.Serialization.XmlElementAttribute>(itemType, smartMappingType))
{
System.Xml.Serialization.XmlElementAttribute attribute = Attribute.GetCustomAttribute(propertyInfo, typeof(System.Xml.Serialization.XmlElementAttribute), false) as System.Xml.Serialization.XmlElementAttribute;
if (dataRow.Table.Columns.Contains(attribute.ElementName))
{
object value = dataRow[attribute.ElementName];
if (value == null || value.ToString().Trim() == string.Empty)
{
propertyInfo.SetValue(item, null, null);
}
else
{
propertyInfo.SetValue(item, (value.GetType() == propertyInfo.PropertyType ? value : FrameReflection.ConvertTo(value.ToString().Trim(), propertyInfo.PropertyType)), null);
}
}
else
{
propertyInfo.SetValue(item, null, null);
}
}
////设置字段的值
foreach (FieldInfo fieldInfo in fieldInfos = fieldInfos != null ? fieldInfos : FrameReflection.GetFieldInfoByAttribute <System.Xml.Serialization.XmlElementAttribute>(itemType, smartMappingType))
{
System.Xml.Serialization.XmlElementAttribute attribute = Attribute.GetCustomAttribute(fieldInfo, typeof(System.Xml.Serialization.XmlElementAttribute), false) as System.Xml.Serialization.XmlElementAttribute;
if (dataRow.Table.Columns.Contains(attribute.ElementName))
{
object value = dataRow[attribute.ElementName];
if (value == null || value.ToString().Trim() == string.Empty)
{
fieldInfo.SetValue(item, null);
}
else
{
fieldInfo.SetValue(item, (value.GetType() == fieldInfo.FieldType ? value : FrameReflection.ConvertTo(value.ToString().Trim(), fieldInfo.FieldType)));
}
}
else
{
fieldInfo.SetValue(item, null);
}
}
}
break;
case FrameMappingType.Field: ////按字段映射，不区分公有私有
case FrameMappingType.FieldPrivate: ////按私有字段映射
case FrameMappingType.FieldPublic: ////按公有字段映射
{
////设置字段的值
foreach (FieldInfo fieldInfo in fieldInfos = fieldInfos != null ? fieldInfos : FrameReflection.GetFieldInfos(itemType, smartMappingType))
{
if (dataRow.Table.Columns.Contains(fieldInfo.Name))
{
object value = dataRow[fieldInfo.Name];
if (value != null && value.ToString().Trim() != string.Empty)
{
fieldInfo.SetValue(item, (value.GetType() == fieldInfo.FieldType ? value : FrameReflection.ConvertTo(value.ToString(), fieldInfo.FieldType)));
}
}
}
}
break;
case FrameMappingType.Property:
case FrameMappingType.ProertyPrivate:
case FrameMappingType.PropertyPublic:
{
////设置属性的值
foreach (PropertyInfo propertyInfo in propertyInfos = propertyInfos != null ? propertyInfos : FrameReflection.GetPropertyInfos(itemType, smartMappingType))
{
if (dataRow.Table.Columns.Contains(propertyInfo.Name))
{
object value = dataRow[propertyInfo.Name];
if (value != null && value.ToString().Trim() != string.Empty)
{
propertyInfo.SetValue(item, (value.GetType() == propertyInfo.PropertyType ? value : FrameReflection.ConvertTo(value.ToString(), propertyInfo.PropertyType)), null);
}
}
}
}
break;
}
}
/// <summary>
/// 根据不同的映射类型及数据库类型返回实体对象的Parameter参数列表
/// </summary>
/// <param name="item">实体或匿名实体</param>
/// <param name="smartDataBaseType">数据库类型</param>
/// <param name="smartMappingType">映射方式</param>
/// <returns>Parameter参数列表</returns>
public static List <DbParameter> GetParameters(object item, FrameWork.Core.FrameData.DataBaseType smartDataBaseType, FrameMappingType smartMappingType)
{
return(FrameWork.Core.FrameData.FrameDataBase.GetParameters(item, smartDataBaseType, smartMappingType));
}
/// <summary>
/// 根据不同的映射类型及数据库类型返回实体对象的Parameter参数列表
/// </summary>
/// <param name="item">实体或匿名实体</param>
/// <param name="smartDataBaseType">数据库类型</param>
/// <param name="smartMappingType">映射方式</param>
/// <returns>Parameter参数列表</returns>
public static List <DbParameter> GetParameters(object item, DataBaseType smartDataBaseType, FrameMappingType smartMappingType)
{
return(GetParameters(GetColumnDic(item, smartMappingType), smartDataBaseType));
}
/// <summary>
/// 由一行数据生成一个实体
/// </summary>
/// <typeparam name="T">实体类型</typeparam>
/// <param name="dataRow">数据行</param>
/// <param name="smartMappingType">反射方式</param>
/// <returns>反射后的实体</returns>
public static T GetEntity <T>(DataRow dataRow, FrameMappingType smartMappingType)
{
return(FrameWork.Core.FrameData.FrameDataBase.GetEntity <T>(dataRow, smartMappingType));
}
/// <summary>
/// 根据映射方式取某个实体或匿名类型的属性集合
/// </summary>
/// <param name="type">实体类型或匿名类型</param>
/// <param name="frameMappingType">映射方式</param>
/// <returns>属性数组</returns>
public static PropertyInfo[] GetPropertyInfos(Type type, FrameMappingType frameMappingType)
{
return(type.GetProperties(FrameReflection.GetBindingFlagsByFrameMappingType(frameMappingType)));
}
/// <summary>
/// 由一行数据生成一个实体,获取第一行数据
/// </summary>
/// <typeparam name="T">实体类型</typeparam>
/// <param name="dataRowCollection">数据行的集合</param>
/// <param name="smartMappingType">反射方式</param>
/// <returns>反射后的实体</returns>
public static T GetEntity <T>(DataRowCollection dataRowCollection, FrameMappingType smartMappingType)
{
return(FrameWork.Core.FrameData.FrameDataBase.GetEntity <T>(dataRowCollection[0], smartMappingType));
}
/// <summary>
/// 获取某个实体或匿名类型的由某特性标识的属性集合，包括公共属性和非公共属性
/// </summary>
/// <typeparam name="TAttribute">特性的类型</typeparam>
/// <param name="type">实体或匿名对象的类型</param>
/// <param name="frameMappingType">应用的反射类型</param>
/// <returns>属性数组</returns>
public static PropertyInfo[] GetPropertyInfoByAttribute <TAttribute>(Type type, FrameMappingType frameMappingType) where TAttribute : Attribute
{
List <PropertyInfo> listPropertyinfo = new List <PropertyInfo>();
foreach (PropertyInfo propertyinfo in GetPropertyInfos(type, frameMappingType))
{
TAttribute attribute = System.Attribute.GetCustomAttribute(propertyinfo, typeof(TAttribute), false) as TAttribute;
if (attribute != null)
{
listPropertyinfo.Add(propertyinfo);
}
}
return(listPropertyinfo.ToArray());
}
/// <summary>
/// 由一行数据生成一个实体,获取第一行数据
/// </summary>
/// <typeparam name="T">实体类型</typeparam>
/// <param name="dataTable">数据表</param>
/// <param name="smartMappingType">反射方式</param>
/// <returns>反射后的实体</returns>
public static T GetEntity <T>(DataTable dataTable, FrameMappingType smartMappingType)
{
return(FrameWork.Core.FrameData.FrameDataBase.GetEntity <T>(dataTable.Rows[0], smartMappingType));
}
/// <summary>
/// 获取某个实体或匿名类型的方法
/// </summary>
/// <param name="type">实体或匿名类型</param>
/// <param name="frameMappingType">映射类型</param>
/// <returns>方法数组</returns>
public static MethodInfo[] GetMethodInfoByMappingType(Type type, FrameMappingType frameMappingType)
{
BindingFlags bindingFlags = FrameReflection.GetBindingFlagsByFrameMappingType(frameMappingType);
return(type.GetMethods(bindingFlags));
}
/// <summary>
/// 由一行数据生成一个实体
/// </summary>
/// <typeparam name="T">实体类型</typeparam>
/// <param name="dataRow">数据行</param>
/// <param name="smartMappingType">反射方式</param>
/// <returns>反射后的实体</returns>
public static T GetEntity <T>(DataRow dataRow, FrameMappingType smartMappingType)
{
return(FrameWork.Core.DataCommon.GetEntity <T>(dataRow, smartMappingType));
}
