Dapper小型ORM的使用（随便吐槽下公司）
2024-09-26 00:01:34
近来公司又有新项目要做，之前做项目用过蛮多ORM，包括ef,NetTiers,ServiceStack.OrmLite等ROM，每种ORM都有一定的坑（或者说是使用者的问题吧~~）。用来用去都觉的有一定的不爽。这次打算用Dapper这个ORM来做项目看看。首先感谢http://www.cnblogs.com/wywnet/p/33422150.html这位老兄给出的文章还有demo（建议大家可以看看），看了后深受启发。所以也确定用Dapper来练练手。好了，先介绍下Dapper这个ORM
1，Dapper是一个轻型的ORM类。代码就一个SqlMapper.cs文件，编译后就40K的一个很小的Dll. 小型ORM
2，Dapper很快。Dapper的速度接近与IDataReader，取列表的数据超过了DataTable。 速度快
3，Dapper支持什么数据库。Dapper支持Mysql,SqlLite,Mssql2000,Mssql2005,Oracle等一系列的数据库 支持多数据库
4，Dapper的r支持多表并联的对象。支持一对多 多对多的关系。并且没侵入性，想用就用，不想用就不用。无XML无属性。代码以前怎么写现在还怎么写。 灵活性高
5，Dapper原理通过Emit反射IDataReader的序列队列，来快速的得到和产生对象。性能实在高高高。 性能高
6，Dapper支持net2.0,3.0,3.5,4.0。【如果想在Net2.0下使用，可以去网上找一下Net2.0下如何配置运行Net3.5即可。】 支持多个.net版本
7，Dapper语法十分简单。并且无须迁就数据库的设计。 语法简单，可扩展性强
Dapper官网：https://code.google.com/p/dapper-dot-net/
Dapper简单使用：http://www.cnblogs.com/wywnet/p/3422150.html
SqlMapper.cs 是最基础的底层文件，为了更好的运用，先对Dapper进行扩展，这里写一个Dapper的扩展类（这里只列出主要的类，一些辅助类就不列出了）
Dapper扩展类，DapperEx.cs
public static class DapperEx
{ /// <summary>
/// 插入数据
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="dbs"></param>
/// <param name="t"></param>
/// <param name="transaction"></param>
/// <param name="commandTimeout"></param>
/// <returns></returns>
public static int Insert<T>(this DbBase dbs, T t, IDbTransaction transaction = null, int? commandTimeout = null) where T : class
{
var db = dbs.DbConnecttion;
var sql = SqlQuery<T>.Builder(dbs);
var flag = db.Execute(sql.InsertSql, t, transaction, commandTimeout);
int KeyID = ;
SetIdentity(db, (id) => { KeyID = id; }, transaction);
return KeyID;
//return flag == 1;
} /// <summary>
/// 批量插入数据
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="dbs"></param>
/// <param name="lt"></param>
/// <param name="transaction"></param>
/// <param name="commandTimeout"></param>
/// <returns></returns>
public static bool InsertBatch<T>(this DbBase dbs, IList<T> lt, IDbTransaction transaction = null, int? commandTimeout = null) where T : class
{
var db = dbs.DbConnecttion;
var sql = SqlQuery<T>.Builder(dbs);
var flag = db.Execute(sql.InsertSql, lt, transaction, commandTimeout);
return flag == lt.Count;
} /// <summary>
/// 按条件删除
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="dbs"></param>
/// <param name="sql"></param>
/// <returns></returns>
public static bool Delete<T>(this DbBase dbs, SqlQuery sql = null, IDbTransaction transaction = null) where T : class
{
var db = dbs.DbConnecttion;
if (sql == null)
{
sql = SqlQuery<T>.Builder(dbs);
}
var f = db.Execute(sql.DeleteSql, sql.Param, transaction);
return f > ;
} /// <summary>
/// 按指定某型删除
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="dbs"></param>
/// <param name="sql">如果sql为null，则根据t的主键进行修改</param>
/// <returns></returns>
public static bool Delete<T>(this DbBase dbs, T t, IDbTransaction transaction = null) where T : class
{
var db = dbs.DbConnecttion;
SqlQuery sql = SqlQuery<T>.Builder(dbs);
sql = sql.AppendParam<T>(t);
var f = db.Execute(sql.DeleteSql, sql.Param, transaction);
return f > ;
} /// <summary>
/// 指定主键ID删除数据
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="dbs"></param>
/// <param name="ID"></param>
/// <param name="transaction"></param>
/// <returns></returns>
public static bool DeleteByID<T>(this DbBase dbs, object ID, IDbTransaction transaction = null) where T : class
{
var db = dbs.DbConnecttion;
SqlQuery sql = SqlQuery<T>.Builder(dbs);
sql.KeyValue = ID;
var f = db.Execute(sql.DeleteKeySql, sql.Param, transaction);
return f > ;
} /// <summary>
/// 修改
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="dbs"></param>
/// <param name="t">如果sql为null，则根据t的主键进行修改</param>
/// <param name="sql">按条件修改</param>
/// <returns></returns>
public static bool Update<T>(this DbBase dbs, T t, SqlQuery sql = null, IDbTransaction transaction = null) where T : class
{
var db = dbs.DbConnecttion;
if (sql == null)
{
sql = SqlQuery<T>.Builder(dbs);
}
sql = sql.AppendParam<T>(t);
var f = db.Execute(sql.UpdateSql, sql.Param, transaction);
return f > ;
} /// <summary>
/// 修改
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="dbs"></param>
/// <param name="t">如果sql为null，则根据t的主键进行修改</param>
/// <param name="updateProperties">要修改的属性集合</param>
/// <param name="sql">按条件修改</param>
/// <returns></returns>
public static bool Update<T>(this DbBase dbs, T t, IList<string> updateProperties, SqlQuery sql = null, IDbTransaction transaction = null) where T : class
{
var db = dbs.DbConnecttion;
if (sql == null)
{
sql = SqlQuery<T>.Builder(dbs);
}
sql = sql.AppendParam<T>(t)
.SetExcProperties<T>(updateProperties);
var f = db.Execute(sql.UpdateSql, sql.Param, transaction);
return f > ;
} /// <summary>
/// 获取默认一条数据，没有则为NULL
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="dbs"></param>
/// <param name="sql"></param>
/// <returns></returns>
public static T SingleOrDefault<T>(this DbBase dbs, SqlQuery sql, IDbTransaction transaction = null) where T : class
{
var db = dbs.DbConnecttion;
if (sql == null)
{
sql = SqlQuery<T>.Builder(dbs);
}
sql = sql.Top();
var result = db.Query<T>(sql.QuerySql, sql.Param, transaction);
return result.FirstOrDefault();
} /// <summary>
/// 分页查询
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="dbs"></param>
/// <param name="pageIndex"></param>
/// <param name="pageSize"></param>
/// <param name="dataCount"></param>
/// <param name="sqlQuery"></param>
/// <returns></returns>
public static IList<T> Page<T>(this DbBase dbs, int pageIndex, int pageSize, out long dataCount, SqlQuery sqlQuery = null, IDbTransaction transaction = null) where T : class
{
var db = dbs.DbConnecttion;
var result = new List<T>();
dataCount = ;
if (sqlQuery == null)
{
sqlQuery = SqlQuery<T>.Builder(dbs);
}
sqlQuery = sqlQuery.Page(pageIndex, pageSize);
var para = sqlQuery.Param;
var cr = db.Query(sqlQuery.CountSql, para, transaction).SingleOrDefault();
dataCount = (long)cr.DataCount;
result = db.Query<T>(sqlQuery.PageSql, para, transaction).ToList();
return result;
} /// <summary>
/// 查询
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="dbs"></param>
/// <param name="sql"></param>
/// <returns></returns>
public static IList<T> Query<T>(this DbBase dbs, SqlQuery sql = null, IDbTransaction transaction = null) where T : class
{
var db = dbs.DbConnecttion;
if (sql == null)
{
sql = SqlQuery<T>.Builder(dbs);
}
var result = db.Query<T>(sql.QuerySql, sql.Param, transaction);
return result.ToList();
} /// <summary>
/// 通过主键查询
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="dbs"></param>
/// <param name="sql"></param>
/// <returns></returns>
public static T QueryByID<T>(this DbBase dbs, object ID, IDbTransaction transaction = null) where T : class
{
var db = dbs.DbConnecttion;
SqlQuery sql = SqlQuery<T>.Builder(dbs);
sql.KeyValue = ID;
var result = db.Query<T>(sql.QueryKeySql, sql.Param, transaction).FirstOrDefault();
return result;
} /// <summary>
/// 数据数量
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="dbs"></param>
/// <param name="sql"></param>
/// <returns></returns>
public static long Count<T>(this DbBase dbs, SqlQuery sql = null, IDbTransaction transaction = null) where T : class
{
var db = dbs.DbConnecttion;
if (sql == null)
{
sql = SqlQuery<T>.Builder(dbs);
}
var cr = db.Query(sql.CountSql, sql.Param, transaction).SingleOrDefault();
return (long)cr.DataCount;
} public static void SetIdentity(IDbConnection conn, Action<int> setId, IDbTransaction transaction = null)
{
dynamic identity = conn.Query("SELECT @@IDENTITY AS Id", null, transaction).Single();
int newId = (int)identity.Id;
setId(newId);
} /// <summary>
/// 判断对象是否存在
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="dbs"></param>
/// <param name="ID"></param>
/// <param name="transaction"></param>
/// <returns></returns>
public static bool Exists<T>(this DbBase dbs, object ID, IDbTransaction transaction = null) where T : class
{
var db = dbs.DbConnecttion;
SqlQuery sql = SqlQuery<T>.Builder(dbs);
sql.KeyValue = ID;
var f = db.Query(sql.ExistsSql, sql.Param, transaction).SingleOrDefault();
return f.DataCount > ; ;// f > 0;
} /// <summary>
///自定义语句和存储过程查询--返回集合
/// </summary>
/// <typeparam name="T">返回集合</typeparam>
/// <param name="sql">sql语句或存储过程名字</param>
/// <param name="p">参数</param>
/// <param name="cmdType">执行的命令类型</param>
/// <param name="transaction">事物控制</param>
/// DynamicParameters
/// <returns></returns>
public static IEnumerable<T> Query<T>(this DbBase dbs, string query, object p = null, CommandType cmdType = CommandType.Text, IDbTransaction transaction = null)
{
var db = dbs.DbConnecttion;
return db.Query<T>(query, p, transaction, true, null, cmdType);
} /// <summary>
/// 自定义语句和存储过程的增删改--返回影响的行数
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="dbs"></param>
/// <param name="query">执行的语句</param>
/// <param name="parans">参数</param>
/// <param name="transaction">事物控制</param>
/// <returns>影响的行数</returns>
public static int Execute(this DbBase dbs, string query, object parans, CommandType cmdType = CommandType.Text,IDbTransaction transaction = null)
{
var db = dbs.DbConnecttion;
int row = db.Execute(query, parans, transaction,null,cmdType);
return row;
} }
DapperEx.cs
有这个扩展类后面的操作的方便了，接下来是用DAL层来调用，这里写个封装个基类
DAL基类 DataAccessBase.cs
public class DataAccessBase
{
public DbBase db { get; private set; } public DataAccessBase(DbBase Db)
{
this.db = Db;
}
#region 自定义其他方法 #endregion
}
public class DataAccessBase<T> : DataAccessBase where T : class
{
public DataAccessBase(DbBase db) : base(db) { } #region INSERT
/// <summary>
/// //插入一条数据
/// </summary>
/// <param name="user"></param>
/// <returns></returns>
public int Insert(T model, IDbTransaction tran = null)
{
var result = db.Insert<T>(model, tran);
return result;
} /// <summary>
/// 插入批量数据
/// </summary>
/// <param name="models"></param>
public bool InsertBatch(List<T> models, IDbTransaction tran = null)
{
var result = db.InsertBatch<T>(models, tran);
return result; }
#endregion #region SELECT
/// <summary>
/// 获取默认一条数据，没有则为NULL
/// </summary>
/// <param name="sqlWhere"></param>
/// <returns></returns>
public T SingleOrDefault(SqlQuery sqlWhere = null, IDbTransaction tran = null)
{
var result = db.SingleOrDefault<T>(sqlWhere, tran);
return result;
} /// <summary>
/// 根据主键查询
/// </summary>
/// <param name="ID"></param>
/// <returns></returns>
public T GetByID(object ID, IDbTransaction tran = null)
{
var result = db.QueryByID<T>(ID, tran);
return result;
} /// <summary>
/// 获取全部数据
/// </summary>
/// <returns></returns>
public IList<T> GetAll(IDbTransaction tran = null)
{
var result = db.Query<T>(null, tran);
return result; } /// <summary>
/// 带条件查询
/// </summary>
/// <param name="d"></param>
/// <returns></returns>
public IList<T> GetAll(SqlQuery sqlWhere, IDbTransaction tran = null)
{
var result = db.Query<T>(sqlWhere, tran);
return result;
} /// <summary>
/// 分页查询
/// </summary>
/// <param name="PageIndex"></param>
/// <param name="PageSize"></param>
/// <param name="row"></param>
/// <param name="sql"></param>
/// <returns></returns>
public IList<T> Page(int PageIndex, int PageSize, out long row, SqlQuery sql = null, IDbTransaction tran = null)
{
var result = db.Page<T>(PageIndex, PageSize, out row, sql, tran);
return result; }
#endregion #region DELETE
/// <summary>
/// 自定义条件删除
/// </summary>
/// <param name="sqlWhere"></param>
/// <returns></returns>
public bool Delete(SqlQuery sqlWhere, IDbTransaction tran = null)
{
var result = db.Delete<T>(sqlWhere, tran);
return result;
} /// <summary>
/// 按模型删除
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public bool Delete(T model, IDbTransaction tran = null)
{
var result = db.Delete<T>(model, tran);
return result;
} /// <summary>
/// 根据主键ID删除
/// </summary>
/// <param name="ID"></param>
/// <returns></returns>
public bool DeleteByID(object ID, IDbTransaction tran = null)
{
var result = db.DeleteByID<T>(ID, tran);
return result;
} /// <summary>
/// 按主键批量删除
/// </summary>
/// <param name="idValues"></param>
/// <returns></returns>
public bool DeleteByIds(IEnumerable idValues, IDbTransaction tran = null)
{
bool result = false;
//开启事务
if (tran == null)
{
tran = db.DbTransaction;
}
foreach (var item in idValues)
{
result = db.DeleteByID<T>(item, tran);
if (!result)
{
break;
}
}
if (result)
{
tran.Commit();
}
else
{
tran.Rollback();
}
return result;
} /// <summary>
/// 批量删除
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public bool DeleteBatch(List<T> model, IDbTransaction tran = null)
{
bool result = false;
//开启事务
if (tran == null)
{
tran = db.DbTransaction;
}
foreach (var item in model)
{
result = db.Delete<T>(item, tran);
if (!result)
{
break;
}
}
if (result)
{
tran.Commit();
}
else
{
tran.Rollback();
}
return result;
}
#endregion #region UPDATE
/// <summary>
/// 修改--（带T和sqlWhere时可实现统一修改）
/// </summary>
/// <param name="model">如果sql为null，则根据model的主键进行修改</param>
/// <param name="sqlWhere">按条件修改</param>
public bool Update(T model, SqlQuery sqlWhere = null, IDbTransaction tran = null)
{
var result = db.Update<T>(model, sqlWhere, tran);
return result;
} /// <summary>
/// 修改--可指定属性修改
/// </summary>
/// <param name="model">如果sql为null，则根据t的主键进行修改</param>
/// <param name="updateProperties">要修改的属性集合</param>
/// <param name="sqlWhere">按条件修改</param>
/// <returns></returns>
public bool Update(T model, IList<string> updateProperties, SqlQuery sqlWhere = null, IDbTransaction tran = null)
{
var result = db.Update<T>(model, updateProperties, sqlWhere, tran);
return result; } /// <summary>
/// 批量插入
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public bool UpdateBatch(List<T> model, IDbTransaction tran = null)
{
bool result = false;
//开启事务
if (tran == null)
{
tran = db.DbTransaction;
}
foreach (var item in model)
{
result = db.Update<T>(item, null, tran);
if (!result)
{
break;
}
}
if (result)
{
tran.Commit();
}
else
{
tran.Rollback();
}
return result;
}
#endregion #region ORTHER
/// <summary>
/// 获取数量
/// </summary>
/// <param name="sqlWhere"></param>
/// <returns></returns>
public long GetCount(SqlQuery sqlWhere = null, IDbTransaction tran = null)
{
return db.Count<T>(sqlWhere, tran);
} /// <summary>
/// 判断对象是否存在
/// </summary>
/// <param name="ID"></param>
/// <returns></returns>
public bool Exists(object ID, IDbTransaction tran = null)
{
return db.Exists<T>(ID, tran);
} /// <summary>
/// 自定义语句和存储过程查询--返回集合
/// </summary>
/// <param name="sql">自定的语句或存储过程名字</param>
/// <param name="param">参数</param>
/// <param name="cmdType">类型</param>
/// <returns></returns>
public IEnumerable<T> Query<T>(string sql, object param = null, CommandType cmdType = CommandType.Text, IDbTransaction tran = null)
{
return db.Query<T>(sql, param, cmdType, tran);
} /// <summary>
/// 自定义语句和存储过程的增删改--返回影响的行数
/// </summary>
/// <param name="sql">自定的语句或存储过程名字</param>
/// <param name="param">参数</param>
/// <param name="cmdType">类型</param>
/// <returns></returns>
public int Execute(string sql, object param = null, CommandType cmdType = CommandType.Text, IDbTransaction tran = null)
{
return db.Execute(sql, param, cmdType, tran);
} /// <summary>
/// 使用DynamicParameters方式
/// </summary>
/// <param name="sql"></param>
/// <param name="param"></param>
/// <param name="cmdType"></param>
/// <returns></returns>
public int Execute(string sql, DynamicParameters param = null, CommandType cmdType = CommandType.Text, IDbTransaction tran = null)
{
//param.Add("@ID", 123);
return db.Execute(sql, param, cmdType, tran);
}
#endregion }
DataAccessBase.cs
再写个生成DAL的T4模板
DALAuto.tt
<#@ template debug="true" hostspecific="true" language="C#" #>
<#@ output extension=".cs" #>
<#@ assembly name="System.Core"#>
<#@ import namespace="System"#>
<#@ import namespace="System.Collections.Generic"#>
<#@ include file="DBSchema.ttinclude"#> using DapperEx;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Entity; namespace DAL
{ <#
var dbSchema=DBSchemaFactory.GetDBSchema();
List<string> tableList=dbSchema.GetTablesList();
string Extension="Info";
foreach(string tableName in tableList)
{ #>
public partial class <#=tableName#>DAL: DataAccessBase<<#=tableName#><#=Extension#>>
{
public <#=tableName#>DAL(DbBase db) : base(db) { }
}
<# } #>
}
DALAuto.tt
然后通过BLL层调用，也封装个基类和生成BLL的T4模板
BLL 基类 BusinessBase.cs
public class BusinessBase
{
public DbBase OpenConnection(string name = null)
{
if (String.IsNullOrWhiteSpace(name))
{
name = "strSqlCe";
}
return new DbBase(name);
}
} public class BusinessBase<T> : BusinessBase where T : class
{
public int Insert(T model)
{
using (var db = OpenConnection())
{
DataAccessBase<T> dal = new DataAccessBase<T>(db);
return dal.Insert(model);
}
}
public bool InsertBatch(List<T> models)
{
using (var db = OpenConnection())
{
DataAccessBase<T> dal = new DataAccessBase<T>(db);
return dal.InsertBatch(models);
}
}
public T SingleOrDefault(SqlQuery sqlWhere = null)
{
using (var db = OpenConnection())
{
DataAccessBase<T> dal = new DataAccessBase<T>(db);
var result = dal.SingleOrDefault(sqlWhere);
return result;
}
}
public T GetByID(object ID)
{
using (var db = OpenConnection())
{
DataAccessBase<T> dal = new DataAccessBase<T>(db);
var result = dal.GetByID(ID);
return result;
}
}
public IList<T> GetAll()
{
using (var db = OpenConnection())
{
DataAccessBase<T> dal = new DataAccessBase<T>(db);
return dal.GetAll();
}
}
public IList<T> GetAll(SqlQuery<T> sqlWhere)
{
using (var db = OpenConnection())
{
if (sqlWhere == null)
{
sqlWhere = SqlQuery<T>.Builder(db);
}
DataAccessBase<T> dal = new DataAccessBase<T>(db);
return dal.GetAll(sqlWhere);
}
}
public IList<T> Page(int PageIndex, int PageSize, out long row, SqlQuery sql = null)
{
using (var db = OpenConnection())
{
DataAccessBase<T> dal = new DataAccessBase<T>(db);
var result = dal.Page(PageIndex, PageSize, out row, sql);
return result;
} }
public bool Delete(SqlQuery sqlWhere)
{
using (var db = OpenConnection())
{
DataAccessBase<T> dal = new DataAccessBase<T>(db);
var result = dal.Delete(sqlWhere);
return result;
}
}
public bool Delete(T model)
{
using (var db = OpenConnection())
{
DataAccessBase<T> dal = new DataAccessBase<T>(db);
var result = dal.Delete(model);
return result;
}
}
public bool DeleteByID(object ID)
{
using (var db = OpenConnection())
{
DataAccessBase<T> dal = new DataAccessBase<T>(db);
var result = dal.DeleteByID(ID);
return result;
}
}
public bool DeleteByIds(IEnumerable idValues)
{
using (var db = OpenConnection())
{
DataAccessBase<T> dal = new DataAccessBase<T>(db);
var result = dal.DeleteByIds(idValues);
return result;
}
}
public bool DeleteBatch(List<T> model)
{
using (var db = OpenConnection())
{
DataAccessBase<T> dal = new DataAccessBase<T>(db);
var result = dal.DeleteBatch(model);
return result;
}
}
public bool Update(T Model, SqlQuery sqlWhere = null)
{
using (var db = OpenConnection())
{
DataAccessBase<T> dal = new DataAccessBase<T>(db);
var result = dal.Update(Model, sqlWhere);
return result;
}
}
public bool UpdateAll(List<T> model)
{
using (var db = OpenConnection())
{
DataAccessBase<T> dal = new DataAccessBase<T>(db);
var result = dal.UpdateBatch(model);
return result;
}
}
public long GetCount(SqlQuery sqlWhere = null)
{
using (var db = OpenConnection())
{
DataAccessBase<T> dal = new DataAccessBase<T>(db);
var result = dal.GetCount(sqlWhere);
return result;
}
}
public bool Exists(object ID)
{
using (var db = OpenConnection())
{
DataAccessBase<T> dal = new DataAccessBase<T>(db);
var result = dal.Exists(ID);
return result;
}
}
public IEnumerable<T> Query<T>(string sql, object param = null, CommandType cmdType = CommandType.Text) where T : class
{
using (var db = OpenConnection())
{
DataAccessBase<T> dal = new DataAccessBase<T>(db);
return dal.Query<T>(sql, param, cmdType);
}
}
public int Execute(string sql, object param = null, CommandType cmdType = CommandType.Text)
{
using (var db = OpenConnection())
{
DataAccessBase<T> dal = new DataAccessBase<T>(db);
return dal.Execute(sql, param, cmdType);
}
} }
BusinessBase.cs
BLLAuto.tt
<#@ template debug="true" hostspecific="true" language="C#" #>
<#@ output extension=".cs" #>
<#@ assembly name="System.Core"#>
<#@ import namespace="System"#>
<#@ import namespace="System.Collections.Generic"#>
<#@ include file="DBSchema.ttinclude"#> using Entity;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using DapperEx;
using System.Collections;
using System.Data;
using DAL; namespace BLL
{ <#
var dbSchema=DBSchemaFactory.GetDBSchema();
List<string> tableList=dbSchema.GetTablesList();
foreach(string tableName in tableList)
{
string Entity=tableName+"Info";
string DAL=tableName+"DAL";
#> public partial class <#=tableName#>BLL : BusinessBase<<#=Entity#>>
{ }
<# } #>
}
BLLAuto.tt
噢~~这里一开始少了个Model层，同样，也是写个生成Model的T4模板
ModelAuto.tt
<#@ template debug="true" hostspecific="true" language="C#" #>
<#@ output extension=".cs" #>
<#@ assembly name="System.Core"#>
<#@ import namespace="System"#>
<#@ import namespace="System.Collections.Generic"#>
<#@ include file="DBSchema.ttinclude"#> using System;
using System.Collections.Generic;
using System.Text;
using System.IO;
using System.Runtime.Serialization.Formatters.Binary;
using DapperEx; namespace Entity
{ <#
var dbSchema=DBSchemaFactory.GetDBSchema();
List<string> tableList=dbSchema.GetTablesList();
string Extension="Info";
foreach(string tableName in tableList)
{
Table table=dbSchema.GetTableMetadata(tableName);
#> [Serializable]
[TableAttribute(Name = "<#=tableName#>")]
/// <summary>
///<#=tableName#><#=Extension#><#= table.TableExplain??""#>
/// </summary>
public partial class <#=tableName#><#=Extension#>
{
#region 构造函数
public <#=tableName#><#=Extension#>() { } public <#=tableName#><#=Extension#>(<#=table.ColumnTypeNames#>)
{
<#
foreach(Column c in table.Columns)
{
#>
this.<#=c.LowerColumnName#> = <#=c.LowerColumnName#>;
<#
}
#>
}
#endregion #region 属性
<#
foreach(Column c in table.Columns)
{
#> private <#=GeneratorHelper.GetQuesMarkByType(c.AllowDBNull,c.TypeName)#> <#=c.LowerColumnName#>; /// <summary>
<#
string ColumnExplain="";
if(!String.IsNullOrWhiteSpace(c.ColumnExplain))
{
string [] ColumnExplains = c.ColumnExplain.Split(new [] {'\r', '\n'}, StringSplitOptions.RemoveEmptyEntries);
foreach (var line in ColumnExplains)
{#>
///<#=line#>
<# }
}
#>
/// </summary>
<#
if(c.AutoIncrement)
{#>
[Id(true)]
<# }
#>
public <#=GeneratorHelper.GetQuesMarkByType(c.AllowDBNull,c.TypeName)#> <#=c.UpColumnName#>
{
get { return <#=c.LowerColumnName#>; }
set { <#=c.LowerColumnName#> = value; }
}
<#
}
#>
#endregion #region 验证
public List<string> ErrorList = new List<string>();
private bool Validator()
{
bool validatorResult = true;
<#
foreach(Column c in table.Columns)
{
if(!c.AllowDBNull)
{
if(c.TypeName==GeneratorHelper.StringType)
{
#>
if (string.IsNullOrEmpty(this.<#=c.UpColumnName#>))
{
validatorResult = false;
this.ErrorList.Add("The <#=c.UpColumnName#> should not be empty!");
}
<#
}
if(c.TypeName==GeneratorHelper.DateTimeType)
{
#>
if (this.<#=c.UpColumnName#>==null)
{
validatorResult = false;
this.ErrorList.Add("The <#=c.UpColumnName#> should not be empty!");
}
<#
}
}
if(c.TypeName==GeneratorHelper.StringType)
{
#>
if (this.<#=c.UpColumnName#> != null && <#=c.MaxLength#> < this.<#=c.UpColumnName#>.Length)
{
validatorResult = false;
this.ErrorList.Add("The length of <#=c.UpColumnName#> should not be greater then <#=c.MaxLength#>!");
}
<#
}
}
#>
return validatorResult;
} #endregion #region 辅助方法
public <#=tableName#><#=Extension#> Clone(bool isDeepCopy)
{
<#=tableName#><#=Extension#> footman;
if (isDeepCopy)
{
MemoryStream memoryStream = new MemoryStream();
BinaryFormatter formatter = new BinaryFormatter();
formatter.Serialize(memoryStream, this);
memoryStream.Position = ;
footman = (<#=tableName#><#=Extension#>)formatter.Deserialize(memoryStream);
}
else
{
footman = (<#=tableName#><#=Extension#>)this.MemberwiseClone();
}
return footman;
}
#endregion } <#
}
dbSchema.Dispose();
#>
}
ModelAuto.tt
这样基础的框架就算搭好了。表达能力上有点差，所以描述上也有点粗糙，希望路过的朋友们不要见怪。后面会跟同事探讨这个ORM，补充完善再后写一个Demo分享出来给大家。
这里也发下牢骚，吐槽下公司：
- 人员变动太大了， 领导上台1-2个月就下台，换来换去，项目一手接一手，中间都不知道丢了多少......
- 公司制度不好，就更新一个xml文件，还要跑一天的流程，早上申请更新，快到晚上下班才走完更新流程......（效率上来讲实在太慢了）
- 忽悠能力强，每次开会老板都会说： 大家好好努力，等过阵子带大家去旅游，出去搞个活动，或者聚个餐，只要大家努力，都是有回报的（然后，然后也只是说说而已）
- 公司是做产品的，算是中小型公司，年底了项目越来越多，旧项目还没维护好，就着急开发新项目
- 项目时间紧，需求还没做好就开始开发，后面改需求的程度大于前期的开发
- 天天加班没加班费就算了，人手还不够，几个人同时要搞几个项目，赶时间做出来后面太多BUG要维护不说，代码乱到....（真心担忧这种产品以后的维护）
- 年底了，还期待天天努力加班最后会不会有点物质上的鼓励，结果是：年终奖也没，年货也没，年会也没 老板一句“今年公司没赚~~”（后面听老同事说，老板每年都是这样说），我能不能大逆不道的说一句”老板太抠了“。
- 公司发展不明朗：公司后期打算申请上市，可是公司人员变动实在太大，很多项目留下来都没人维护，甚至有部分项目出现代码遗失。自我感觉公司产品还不太完美吧~~~
公司也不是没有好的地方，自我感觉：
部门同事团结，遇到问题大家都很热情，一起研究，气氛很不错。很多都会技术相互交流，真的很有团队合作精神。这点是我非常喜欢的
我该不该有换工作的念头：
到公司也快一年了，接触了很多的人和事，初进公司，就明显感觉到公司人员的不稳定性，最初在部门的一些老员工都是走到只剩一个（我都快成老员工了...），领导变动性就更不用说，到现在我的领导都换了5个了。一路走来都是M多次加班，M多次去适应每个领导带来的新制度。再累的时候都没想过换工作。但是 累，辛苦 都不算什么，毕竟每次做完项目都是有一个满足感，加班再多，再辛苦都期待这年底能有点奖金来补充下能量，曾经还怀着” 找一下公司，好好努力，争取力争上流 “的希望，可是差强人意，感觉一切都是想得太好了，是不是每个员工都必须要无私的工作（好吧，我承认我不是好员工，没法做到这么无私）。回去近一年的努力还是有点心寒，突然开始想明年是否应该换工作，不过毕竟才在公司待一年，这样走是不是也不好，而且部门同事的那种一起开发，一起交流的劲还是很值吸引我。 之后跟其他同事聊起，有几个同事表示明年回来就想走了，所以目前是属于又想走，又不好意思走的状态。
呵呵，说的有点多了，还是继续学习了，明天晚上估计是加班的前奏~~加油咯！！！（勿喷，勿喷）
最新文章
- Java（接口与继承）动手动脑
- windows磁盘分区
- [原创]Android自定义View之IndicatorView，显示当前tab页所处位置的View
- Windows系统安装Oracle 11g数据库
- BZOJ 3295 动态逆序对
- IE6-IE11兼容性问题列表及解决办法
- Java第四周学习日记（绪）
- 关于删除数组中重复元素的lintcode代码
- C#使用Xamarin开发可移植移动应用进阶篇(6.使用渲染器针对单个平台自定义控件..很很很很重要..),附源码
- 实现 node_modules 共享
- openstack的最简单安装
- apache+php+mysql安装与使用
- 【转】判断处理器是Big_endian的还是Little_endian的
- Linux服务器上搭建web项目环境
- java 常用第3方工具
- ASP.NET MVC Areas View 引用 外部母版视图
- 固态盘经常性蓝屏处理方法（WIN7/8）
- 动态SQL中变量赋值
- VBS 处理断开excel数据链接格式,只保留值
- phonegap 的指南针 api Compass