asp.net MVC三层结构代码生成器
- 一.使用MVC开发的朋友都有一个苦恼,那就是三层结构大量重复代码比较鸡肋,写之无味,不写不行.最近也是从网上找了一些资料,自己又简单加工下,完善了该工具.
- 1.1 支持sqlserver 2012 2014 2016 2017等
- 1.2 代码目录结构如下
- 1.3 使用前,修改默认本地库 登录名,密码
- 二.每个团队开发使用的框架都不一样,我这里写了一个小Demo,根据该Demo框架,生成对应的三层代码.这里把原始 ModelBase , DalBase 和 BllBase 代码贴出
- 2.1EntityModel , 对字段应用了反射,过滤器等相关知识作参考
- 2.2 EntityDal部分
- 2.3 EntityBll部分
- 三.下面提供三层代码生成器下载地址
- 3.1 [下载地址](https://download.csdn.net/download/qq_38933182/11611800)
一.使用MVC开发的朋友都有一个苦恼,那就是三层结构大量重复代码比较鸡肋,写之无味,不写不行.最近也是从网上找了一些资料,自己又简单加工下,完善了该工具.
1.1 支持sqlserver 2012 2014 2016 2017等
1.2 代码目录结构如下
1.3 使用前,修改默认本地库 登录名,密码
///
/// 数据库
///
private string Database = ".";
///
/// 用户名
///
private string UserId = "你想要登录数据库的登录名";
///
/// 密码
///
private string Password = "登录密码";
二.每个团队开发使用的框架都不一样,我这里写了一个小Demo,根据该Demo框架,生成对应的三层代码.这里把原始 ModelBase , DalBase 和 BllBase 代码贴出
2.1EntityModel , 对字段应用了反射,过滤器等相关知识作参考
///
/// 实体类基类
///
public class EntityModel
{
private const BindingFlags BindingFlag = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance;
//将类型与该类型所有的可写且未被忽略属性之间建立映射
private static Dictionary> propertyMappings = new Dictionary>();
//存储Nullable与T的对应关系
private static Dictionary genericTypeMappings = new Dictionary();
static EntityModel()
{
genericTypeMappings.Add(typeof(Byte?), typeof(Byte));
genericTypeMappings.Add(typeof(SByte?), typeof(SByte));
genericTypeMappings.Add(typeof(Char?), typeof(Char));
genericTypeMappings.Add(typeof(Boolean?), typeof(Boolean));
genericTypeMappings.Add(typeof(Guid?), typeof(Guid));
genericTypeMappings.Add(typeof(Int16), typeof(Int16));
genericTypeMappings.Add(typeof(UInt16), typeof(UInt16));
genericTypeMappings.Add(typeof(Int32), typeof(Int32));
genericTypeMappings.Add(typeof(UInt32), typeof(UInt32));
genericTypeMappings.Add(typeof(Int64), typeof(Int64));
genericTypeMappings.Add(typeof(UInt64), typeof(UInt64));
genericTypeMappings.Add(typeof(Single), typeof(Single));
genericTypeMappings.Add(typeof(Double), typeof(Double));
genericTypeMappings.Add(typeof(Decimal), typeof(Decimal));
genericTypeMappings.Add(typeof(DateTime), typeof(DateTime));
genericTypeMappings.Add(typeof(TimeSpan), typeof(TimeSpan));
genericTypeMappings.Add(typeof(Enum), typeof(Enum));
}
///
/// 将DataTable中的所有数据转换成List>T<集合
///
/// DataTable中每条数据可以转换的数据类型
/// 包含有可以转换成数据类型T的数据集合
///
public static List GetEntities(DataTable dataTable) where T : new()
{
if (dataTable == null)
{
throw new ArgumentNullException("dataTable");
}
//如果T的类型满足以下条件：字符串、ValueType或者是Nullable
if (typeof(T) == typeof(string) || typeof(T).IsValueType)
{
return GetSimpleEntities(dataTable);
}
else
{
return GetComplexEntities(dataTable);
}
}
///
/// 将DbDataReader中的所有数据转换成List>T<集合
///
/// DbDataReader中每条数据可以转换的数据类型
/// 包含有可以转换成数据类型T的DbDataReader实例
///
public static List GetEntities(DbDataReader reader) where T : new()
{
List list = new List();
if (reader == null)
{
throw new ArgumentNullException("reader");
}
//如果T的类型满足以下条件：字符串、ValueType或者是Nullable
if (typeof(T) == typeof(string) || typeof(T).IsValueType)
{
return GetSimpleEntities(reader);
}
else
{
return GetComplexEntities(reader);
}
}
///
/// 从DataTable中将每一行的第一列转换成T类型的数据
///
/// 要转换的目标数据类型
/// 包含有可以转换成数据类型T的数据集合
///
private static List GetSimpleEntities(DataTable dataTable) where T : new()
{
List list = new List();
foreach (DataRow row in dataTable.Rows)
{
list.Add((T)GetValueFromObject(row[0], typeof(T)));
}
return list;
}
///
/// 将指定的 Object 的值转换为指定类型的值。
///
/// 实现 IConvertible 接口的 Object，或者为 null
/// 要转换的目标数据类型
///
private static object GetValueFromObject(object value, Type targetType)
{
if (targetType == typeof(string))//如果要将value转换成string类型
{
return GetString(value);
}
else if (targetType.IsGenericType)//如果目标类型是泛型
{
return GetGenericValueFromObject(value, targetType);
}
else//如果是基本数据类型（包括数值类型、枚举和Guid）
{
return GetNonGenericValueFromObject(value, targetType);
}
}
///
/// 从DataTable中读取复杂数据类型集合
///
/// 要转换的目标数据类型
/// 包含有可以转换成数据类型T的数据集合
///
private static List GetComplexEntities(DataTable dataTable) where T : new()
{
if (!propertyMappings.ContainsKey(typeof(T)))
{
GenerateTypePropertyMapping(typeof(T));
}
List list = new List();
Dictionary properties = propertyMappings[typeof(T)];
//Dictionary propertyColumnOrdinalMapping = GetPropertyColumnIndexMapping(dataTable.Columns, properties);
T t;
foreach (DataRow row in dataTable.Rows)
{
t = new T();
foreach (KeyValuePair item in properties)
{
//int ordinal = -1;
//if (propertyColumnOrdinalMapping.TryGetValue(item.Key, out ordinal))
//{
// item.Value.SetValue(t, GetValueFromObject(row[ordinal], item.Value.PropertyType), null);
//}
item.Value.SetValue(t, GetValueFromObject(row[item.Key], item.Value.PropertyType), null);
}
list.Add(t);
}
return list;
}
///
/// 从DbDataReader的实例中读取复杂的数据类型
///
/// 要转换的目标类
/// DbDataReader的实例
///
private static List GetComplexEntities(DbDataReader reader) where T : new()
{
if (!propertyMappings.ContainsKey(typeof(T)))//检查当前是否已经有该类与类的可写属性之间的映射
{
GenerateTypePropertyMapping(typeof(T));
}
List list = new List();
Dictionary properties = propertyMappings[typeof(T)];
//Dictionary propertyColumnOrdinalMapping = GetPropertyColumnIndexMapping(reader, properties);
T t;
while (reader.Read())
{
t = new T();
foreach (KeyValuePair item in properties)
{
//int ordinal = -1;
//if (propertyColumnOrdinalMapping.TryGetValue(item.Key, out ordinal))
//{
// item.Value.SetValue(t, GetValueFromObject(reader[ordinal], item.Value.PropertyType), null);
//}
item.Value.SetValue(t, GetValueFromObject(reader[item.Key], item.Value.PropertyType), null);
}
list.Add(t);
}
return list;
}
///
/// 从DbDataReader的实例中读取简单数据类型（String,ValueType)
///
/// 目标数据类型
/// DbDataReader的实例
///
private static List GetSimpleEntities(DbDataReader reader)
{
List list = new List();
while (reader.Read())
{
list.Add((T)GetValueFromObject(reader[0], typeof(T)));
}
return list;
}
///
/// 将Object转换成字符串类型
///
/// object类型的实例
///
private static object GetString(object value)
{
return Convert.ToString(value);
}
///
/// 将指定的 Object 的值转换为指定枚举类型的值。
///
/// 实现 IConvertible 接口的 Object，或者为 null
///
///
private static object GetEnum(object value, Type targetType)
{
return Enum.Parse(targetType, value.ToString());
}
///
/// 将指定的 Object 的值转换为指定枚举类型的值。
///
/// 实现 IConvertible 接口的 Object，或者为 null
///
private static object GetBoolean(object value)
{
if (value is Boolean)
{
return value;
}
else
{
byte byteValue = (byte)GetByte(value);
if (byteValue == 0)
{
return false;
}
else
{
return true;
}
}
}
///
/// 将指定的 Object 的值转换为指定枚举类型的值。
///
/// 实现 IConvertible 接口的 Object，或者为 null
///
private static object GetByte(object value)
{
if (value is Byte)
{
return value;
}
else
{
return byte.Parse(value.ToString());
}
}
///
/// 将指定的 Object 的值转换为指定枚举类型的值。
///
/// 实现 IConvertible 接口的 Object，或者为 null
///
private static object GetSByte(object value)
{
if (value is SByte)
{
return value;
}
else
{
return SByte.Parse(value.ToString());
}
}
///
/// 将指定的 Object 的值转换为指定枚举类型的值。
///
/// 实现 IConvertible 接口的 Object，或者为 null
///
private static object GetChar(object value)
{
if (value is Char)
{
return value;
}
else
{
return Char.Parse(value.ToString());
}
}
///
/// 将指定的 Object 的值转换为指定枚举类型的值。
///
/// 实现 IConvertible 接口的 Object，或者为 null
///
private static object GetGuid(object value)
{
if (value is Guid)
{
return value;
}
else
{
return new Guid(value.ToString());
}
}
///
/// 将指定的 Object 的值转换为指定枚举类型的值。
///
/// 实现 IConvertible 接口的 Object，或者为 null
///
private static object GetInt16(object value)
{
if (value is Int16)
{
return value;
}
else
{
return Int16.Parse(value.ToString());
}
}
///
/// 将指定的 Object 的值转换为指定枚举类型的值。
///
/// 实现 IConvertible 接口的 Object，或者为 null
///
private static object GetUInt16(object value)
{
if (value is UInt16)
{
return value;
}
else
{
return UInt16.Parse(value.ToString());
}
}
///
/// 将指定的 Object 的值转换为指定枚举类型的值。
///
/// 实现 IConvertible 接口的 Object，或者为 null
///
private static object GetInt32(object value)
{
if (value is Int32)
{
return value;
}
else
{
return Int32.Parse(value.ToString());
}
}
///
/// 将指定的 Object 的值转换为指定枚举类型的值。
///
/// 实现 IConvertible 接口的 Object，或者为 null
///
private static object GetUInt32(object value)
{
if (value is UInt32)
{
return value;
}
else
{
return UInt32.Parse(value.ToString());
}
}
///
/// 将指定的 Object 的值转换为指定枚举类型的值。
///
/// 实现 IConvertible 接口的 Object，或者为 null
///
private static object GetInt64(object value)
{
if (value is Int64)
{
return value;
}
else
{
return Int64.Parse(value.ToString());
}
}
///
/// 将指定的 Object 的值转换为指定枚举类型的值。
///
/// 实现 IConvertible 接口的 Object，或者为 null
///
private static object GetUInt64(object value)
{
if (value is UInt64)
{
return value;
}
else
{
return UInt64.Parse(value.ToString());
}
}
///
/// 将指定的 Object 的值转换为指定枚举类型的值。
///
/// 实现 IConvertible 接口的 Object，或者为 null
///
private static object GetSingle(object value)
{
if (value is Single)
{
return value;
}
else
{
return Single.Parse(value.ToString());
}
}
///
/// 将指定的 Object 的值转换为指定枚举类型的值。
///
/// 实现 IConvertible 接口的 Object，或者为 null
///
private static object GetDouble(object value)
{
if (value is Double)
{
return value;
}
else
{
return Double.Parse(value.ToString());
}
}
///
/// 将指定的 Object 的值转换为指定枚举类型的值。
///
/// 实现 IConvertible 接口的 Object，或者为 null
///
private static object GetDecimal(object value)
{
if (value is Decimal)
{
return value;
}
else
{
return Decimal.Parse(value.ToString());
}
}
///
/// 将指定的 Object 的值转换为指定枚举类型的值。
///
/// 实现 IConvertible 接口的 Object，或者为 null
///
private static object GetDateTime(object value)
{
if (value is DateTime)
{
return value;
}
else
{
return DateTime.Parse(value.ToString());
}
}
///
/// 将指定的 Object 的值转换为指定枚举类型的值。
///
/// 实现 IConvertible 接口的 Object，或者为 null
///
private static object GetTimeSpan(object value)
{
if (value is TimeSpan)
{
return value;
}
else
{
return TimeSpan.Parse(value.ToString());
}
}
///
/// 将Object类型数据转换成对应的可空数值类型表示
///
/// 实现 IConvertible 接口的 Object，或者为 null
/// 可空数值类型
///
private static object GetGenericValueFromObject(object value, Type targetType)
{
if (value == DBNull.Value)
{
return null;
}
else
{
//获取可空数值类型对应的基本数值类型，如int?->int,long?->long
Type nonGenericType = genericTypeMappings[targetType];
return GetNonGenericValueFromObject(value, nonGenericType);
}
}
///
/// 将指定的 Object 的值转换为指定类型的值。
///
/// 实现 IConvertible 接口的 Object，或者为 null
/// 目标对象的类型
///
private static object GetNonGenericValueFromObject(object value, Type targetType)
{
if (targetType.IsEnum)//因为
{
return GetEnum(value, targetType);
}
else
{
switch (targetType.Name)
{
case "Byte": return GetByte(value);
case "SByte": return GetSByte(value);
case "Char": return GetChar(value);
case "Boolean": return GetBoolean(value);
case "Guid": return GetGuid(value);
case "Int16": return GetInt16(value);
case "UInt16": return GetUInt16(value);
case "Int32": return GetInt32(value);
case "UInt32": return GetUInt32(value);
case "Int64": return GetInt64(value);
case "UInt64": return GetUInt64(value);
case "Single": return GetSingle(value);
case "Double": return GetDouble(value);
case "Decimal": return GetDecimal(value);
case "DateTime": return GetDateTime(value);
case "TimeSpan": return GetTimeSpan(value);
default: return null;
}
}
}
///
/// 获取该类型中属性与数据库字段的对应关系映射
///
///
private static void GenerateTypePropertyMapping(Type type)
{
if (type != null)
{
PropertyInfo[] properties = type.GetProperties(BindingFlag);
Dictionary propertyColumnMapping = new Dictionary(properties.Length);
string description = string.Empty;
Attribute[] attibutes = null;
string columnName = string.Empty;
bool ignorable = false;
foreach (PropertyInfo p in properties)
{
ignorable = false;
columnName = string.Empty;
attibutes = Attribute.GetCustomAttributes(p);
foreach (Attribute attribute in attibutes)
{
//检查是否设置了ColumnName属性
if (attribute.GetType() == typeof(ColumnNameAttribute))
{
columnName = ((ColumnNameAttribute)attribute).ColumnName;
ignorable = ((ColumnNameAttribute)attribute).Ignorable;
break;
}
}
//如果该属性是可读并且未被忽略的，则有可能在实例化该属性对应的类时用得上
if (p.CanWrite && !ignorable)
{
//如果没有设置ColumnName属性，则直接将该属性名作为数据库字段的映射
if (string.IsNullOrEmpty(columnName))
{
columnName = p.Name;
}
propertyColumnMapping.Add(columnName, p);
}
}
propertyMappings.Add(type, propertyColumnMapping);
}
}
//private static Dictionary GetPropertyColumnIndexMapping(DataColumnCollection dataSource, Dictionary properties)
//{
// Stopwatch watch = new Stopwatch();
// watch.Start();
// Dictionary propertyColumnIndexMapping=new Dictionary(dataSource.Count);
// foreach(KeyValuePair item in properties)
// {
// for (int i = 0; i < dataSource.Count; i++)
// {
// if (item.Key.Equals(dataSource[i].ColumnName, StringComparison.InvariantCultureIgnoreCase))
// {
// propertyColumnIndexMapping.Add(item.Key, i);
// break;
// }
// }
// }
// watch.Stop();
// Debug.WriteLine("Elapsed:" + watch.ElapsedMilliseconds);
// return propertyColumnIndexMapping;
//}
//private static Dictionary GetPropertyColumnIndexMapping(DbDataReader dataSource, Dictionary properties)
//{
// Dictionary propertyColumnIndexMapping = new Dictionary(dataSource.FieldCount);
// foreach (KeyValuePair item in properties)
// {
// for (int i = 0; i < dataSource.FieldCount; i++)
// {
// if (item.Key.Equals(dataSource.GetName(i), StringComparison.InvariantCultureIgnoreCase))
// {
// propertyColumnIndexMapping.Add(item.Key, i);
// continue;
// }
// }
// }
// return propertyColumnIndexMapping;
//}
}
///
/// 自定义属性，用于指示如何从DataTable或者DbDataReader中读取类的属性值
///
public class ColumnNameAttribute : Attribute
{
///
/// 类属性对应的列名
///
public string ColumnName { get; set; }
///
/// 指示在从DataTable或者DbDataReader中读取类的属性时是否可以忽略这个属性
///
public bool Ignorable { get; set; }
///
/// 构造函数
///
/// 类属性对应的列名
public ColumnNameAttribute(string columnName)
{
ColumnName = columnName;
Ignorable = false;
}
///
/// 构造函数
///
/// 指示在从DataTable或者DbDataReader中读取类的属性时是否可以忽略这个属性
public ColumnNameAttribute(bool ignorable)
{
Ignorable = ignorable;
}
///
/// 构造函数
///
/// 类属性对应的列名
/// 指示在从DataTable或者DbDataReader中读取类的属性时是否可以忽略这个属性
public ColumnNameAttribute(string columnName, bool ignorable)
{
ColumnName = columnName;
Ignorable = ignorable;
}
}
///
/// 主键属性
///
public class KeyFlagAttribute : Attribute
{
private bool _bIsKey;
public bool IsKey { get { return _bIsKey; } }
public KeyFlagAttribute(bool bIsKey)
{
_bIsKey = bIsKey;
}
}
2.2 EntityDal部分
///
/// 操作数据库的方法
/// 约定:
/// 1)对象属性必须有public string TableName
/// 2)属性名与字段名一样
/// 3)主键属性需标记自定义特性KeyFlagAttribute，表示此属性是数据表中的主键
/// 4)数据表中每个表必须设有主键
///
public class EntityDal
{
#region 属性
///
/// 构造
///
public EntityDal()
{
}
///
/// 构造
///
///
public EntityDal(string conn)
{
this.connectionString = conn;
}
///
/// 构造
///
///
public EntityDal(SqlConnection conn)
{
this.sqlConnection = conn;
}
///
/// 数据库连接字符串
///
private string connectionString
{
get;
set;
}
///
/// 数据库连接对象
///
private SqlConnection sqlConnection
{
get;
set;
}
#endregion
#region 数据库增、删、改、查
///
/// 增
///
/// 要存入数据库的对象
public int Insert(object obj)
{
int n = 0;
using (SqlConnection conn = new SqlConnection(connectionString))
{
conn.Open();
StringBuilder sql = new StringBuilder();
StringBuilder sqlend = new StringBuilder();
//获取对象的属性数组
PropertyInfo[] pro = obj.GetType().GetProperties();
//主键属性数组
List idlist = GetIdProperty(pro);
//要更新的数据表
string table = FindPropertyInfoValue(obj, "TableName").ToString();
//执行的sql语句
string sqltext = string.Empty;
//INSERT INTO table_name (列1, 列2,...) VALUES (值1, 值2,....)
sql.Append("INSERT INTO " + table + "(");
sqlend.Append(" VALUES (");
foreach (PropertyInfo item in pro)
{
//拼接sql语句主体,插入数据时,主键不能显示插入值
if (item.Name == "TableName" || idlist.Any(w => w.Name == item.Name))
{
continue;
}
else
{
string columnValue = item.GetValue(obj, null) + "";
if (string.IsNullOrEmpty(columnValue))
{//去掉空属性
continue;
}
if (item.PropertyType == typeof(DateTime))
{//时间属性初始化时未赋值会变为默认最小值
DateTime dt;
DateTime.TryParse(columnValue, out dt);
if (dt <= SqlDateTime.MinValue.Value)
continue;
}
sql.Append(" " + item.Name + ",");
sqlend.Append(" '" + columnValue + "',");
}
}
string start = sql.ToString();
start = start.Substring(0, start.Length - 1) + ")";
string end = sqlend.ToString();
end = end.Substring(0, end.Length - 1) + ")";
sqltext = start + end;
using (SqlCommand cmd = new SqlCommand(sqltext, conn))
{
n = cmd.ExecuteNonQuery();
}
}
return n;
}
///
/// 改
///
///
///
public int Update(object obj)
{
int n = 0;
using (SqlConnection conn = new SqlConnection(connectionString))
{
conn.Open();
StringBuilder sql = new StringBuilder();
StringBuilder sqlend = new StringBuilder();
//获取对象的属性数组
PropertyInfo[] pro = obj.GetType().GetProperties();
//主键属性数组
List idlist = GetIdProperty(pro);
//要更新的数据表
string table = FindPropertyInfoValue(obj, "TableName").ToString();
//执行的sql语句
string sqltext = string.Empty;
//UPDATE 表名称 SET 列名称 = 新值 WHERE 列名称 = 某值 and 列2=某值
sql.Append("UPDATE " + table + " set");
sqlend.Append("WHERE");
//拼接sql语句主体
foreach (PropertyInfo item in pro)
{
if (item.Name == "TableName")
{
continue;
}
else
{
sql.Append(" " + item.Name + "= " + item.GetValue(obj, null));
}
}
//根据主键增加定位条件
foreach (PropertyInfo item in idlist)
{
sqlend.Append(" " + item.Name + "= '" + item.GetValue(obj, null) + ", and ");
}
string start = sql.ToString();
start = start.Substring(0, start.Length - 1) + " ";
string end = sqlend.ToString();
end = end.Substring(0, end.Length - 5) + " ";
sqltext = start + end;
using (SqlCommand cmd = new SqlCommand(sqltext, conn))
{
n = cmd.ExecuteNonQuery();
}
}
return n;
}
///
/// 查
///
/// 要填充的对象
/// 赋值后的对象
public object Select(object pdata)
{
PropertyInfo[] pro = pdata.GetType().GetProperties();//获取传来的对象的属性
List idlist = GetIdProperty(pro);
using (SqlConnection conn = new SqlConnection(connectionString))
{
conn.Open();
StringBuilder sql = new StringBuilder();
StringBuilder sqlend = new StringBuilder();
string table = FindPropertyInfoValue(pdata, "TableName").ToString();
string sqltext = string.Empty;
sql.AppendFormat("select * from {0} with(nolock) where", table);
foreach (PropertyInfo item in idlist)
{
if (item.Name == "TableName")
{
continue;
}
else
{
sql.Append(" " + item.Name + " = '" + item.GetValue(pdata, null) + "'");
}
}
sqltext = sql.ToString();
using (SqlCommand cmd = new SqlCommand(sqltext, conn))
{
SqlDataReader dr = cmd.ExecuteReader(CommandBehavior.SingleRow);
dr.Read();
foreach (PropertyInfo item in pro)
{
if (item.Name == "TableName")
{
continue;
}
else
{
if (string.IsNullOrEmpty(dr[item.Name].ToString()))
{
continue;
}
item.SetValue(pdata, dr[item.Name], null);
}
}
}
}
return pdata;
}
///
/// 删
///
///
///
public int Delete(object pdata)
{
int n = 0;//影响的行数
PropertyInfo[] pro = pdata.GetType().GetProperties();//获取传来的对象的属性
List idlist = GetIdProperty(pro);//找到主键属性
using (SqlConnection conn = new SqlConnection(connectionString))
{
conn.Open();
StringBuilder sql = new StringBuilder();
StringBuilder sqlend = new StringBuilder();
string table = FindPropertyInfoValue(pdata, "TableName").ToString();
string sqltext = string.Empty;
sql.AppendFormat("delete from {0} where", table);
foreach (PropertyInfo item in idlist)
{
sql.Append(" " + item.Name + " = '" + item.GetValue(pdata, null) + "'");
}
sqltext = sql.ToString();
using (SqlCommand cmd = new SqlCommand(sqltext, conn))
{
n = cmd.ExecuteNonQuery();
}
}
return n;
}
//public static List GetPagedList(T obj, int pPageIndex, int pPageSize, string pOrderBy, string pSortExpression, out int pRecordCount)
//{
// if (pPageIndex <= 1)
// pPageIndex = 1;
// List list = new List();
// Query q = Repair.CreateQuery();
// pRecordCount = q.GetRecordCount();
// q.PageIndex = pPageIndex;
// q.PageSize = pPageSize;
// q.ORDER_BY(pSortExpression, pOrderBy.ToString());
// RepairCollection collection = new RepairCollection();
// collection.LoadAndCloseReader(q.ExecuteReader());
// foreach (Repair repair in collection)
// {
// T repairInfo = new T();
// LoadFromDAL(T, repair);
// list.Add(repairInfo);
// }
// return list;
//}
#endregion
#region 辅助方法
///
/// 查找返回属性数组中指定名称的属性
///
///
///
///
private object FindPropertyInfoValue(object pdata, string proName)
{
PropertyInfo pro = pdata.GetType().GetProperty(proName);
return pro.GetValue(pdata, null);
}
///
/// 返回对应名称的属性
///
///
///
///
private PropertyInfo FindPropertyInfo(PropertyInfo[] pros, string proName)
{
foreach (PropertyInfo item in pros)
{
if (item.Name == proName)
{
return item;
}
}
return null;
}
///
/// 返回主键属性
/// add cjk
///
/// 属性数组
/// 主键属性
private List GetIdProperty(PropertyInfo[] pros)
{
List keyIds = new List();
foreach (PropertyInfo item in pros)
{
//KeyFlagAttribute flag = item.GetCustomAttributes(typeof(KeyFlagAttribute), false)[0] as KeyFlagAttribute;
//if (flag.IsKey)
//{
// return item;
//}
object[] attrs = item.GetCustomAttributes(false);
foreach (var id in attrs)
{
if (id.GetType().Name == "KeyFlagAttribute")
{
keyIds.Add(item);
}
}
}
return keyIds;
}
#endregion
}
///
/// 主键属性
///
public class KeyFlagAttribute : Attribute
{
private bool _bIsKey;
public bool IsKey { get { return _bIsKey; } }
public KeyFlagAttribute(bool bIsKey)
{
_bIsKey = bIsKey;
}
}
2.3 EntityBll部分
public class EntityBll
{
private string _conn;
///
/// 连接数据库字符
///
protected string conn
{
get
{
if (string.IsNullOrEmpty(_conn))
{
return ConnectionSql.ConnectionString_CN_DB;
}
else
{
return _conn;
}
}
set
{
_conn = value;
}
}
#region 基本的增删改查
///
/// 增
///
///
///
public bool Insert(T t)
{
if (new DAL.Base.EntityDal(conn).Insert(t) > 0)
{
return true;
}
else
{
return false;
}
}
///
/// 删
///
///
///
public bool Delete(T t)
{
if (new DAL.Base.EntityDal(conn).Delete(t) > 0)
{
return true;
}
else
{
return false;
}
}
///
/// 改
///
///
///
public bool Update(T t)
{
if (new DAL.Base.EntityDal(conn).Update(t) > 0)
{
return true;
}
else
{
return false;
}
}
///
/// 查
///
///
///
public T Select(T t)
{
return (T)new DAL.Base.EntityDal(conn).Select(t);
}
#endregion
}
三.下面提供三层代码生成器下载地址
3.1 下载地址
