让C#开发更简单,抽象增删改

相信经常做一些MS，CRM 项目的童鞋非常有体会，大部分时间都是在复制和粘贴，大部分项目框架都是建一个三层，首先是DAL建一些增删改查，然后呢是BLL业务层再建一些增删改 查，然后UI层再调用增删改查，整个过程非常的繁琐，开发效率并不是很高，这种项目做久了之后，就非常的痛苦，非常的无聊。今天我给大家带来一个抽象出增 删改查的框架，相信有些大牛早就总结出来了，不喜勿喷哈，本人旨在分享。

你再也不用写增删改查了，我给你抽象出来了！！

现在业界火了一种ORM 框架，那就是Dapper，我也是Dapper的粉丝之一，而我总结出来的框架也是基于Daaper。下面是我的代码，首先是Dapper Helper类，数据库通用访问类（用Nuget工具先把Dapper类引用到NetUtility.Dapper.Core项目中去）：

NetUtility.Dapper.Core.DataBaseAccess.cs

1. using System; 
2. using System.Collections.Generic; 
3. using System.Configuration; 
4. using System.Data.SqlClient; 
5. using System.Linq; 
6. using System.Text; 
7. using System.Threading.Tasks; 
8. using Dapper; 
9. using System.Data; 
10. using NetUtility.Entity; 
11. using System.Reflection; 
12.  
13. namespace NetUtility.Dapper.Core 
14. { 
15.     /// <summary> 
16.     /// 数据库访问类 
17.     /// </summary> 
18.     public class DataBaseAccess 
19.     { 
20.         public static SqlConnection CreateConnection() 
21.         { 
22.             string connStr = ConfigurationManager.ConnectionStrings["connString"].ConnectionString; 
23.             SqlConnection conn = new SqlConnection(connStr); 
24.             conn.Open(); 
25.             return conn; 
26.         } 
27.  
28.         /// <summary> 
29.         /// 执行增、删、改方法 
30.         /// </summary> 
31.         /// <param name="sql"></param> 
32.         /// <param name="parms"></param> 
33.         /// <returns></returns> 
34.         public static int Execute(string sql, object parms = null) 
35.         { 
36.             using (IDbConnection conn = CreateConnection()) 
37.             { 
38.                 return conn.Execute(sql,parms); 
39.             } 
40.         } 
41.  
42.         /// <summary> 
43.         /// 得到单行单列 
44.         /// </summary> 
45.         /// <param name="sql"></param> 
46.         /// <param name="parms"></param> 
47.         /// <returns></returns> 
48.         public static object ExecuteScalar(string sql, object parms = null) 
49.         { 
50.             using (IDbConnection conn = CreateConnection()) 
51.             { 
52.                 return conn.ExecuteScalar(sql, parms); 
53.             } 
54.         } 
55.  
56.         /// <summary> 
57.         /// 单个数据集查询 
58.         /// </summary> 
59.         /// <param name="sql"></param> 
60.         /// <param name="parms"></param> 
61.         /// <returns></returns> 
62.         public static List<TEntity> Query<TEntity>(string sql,Func<TEntity,bool> pre ,object parms = null) 
63.         { 
64.             using (IDbConnection conn = CreateConnection()) 
65.             { 
66.                 return conn.Query<TEntity>(sql, parms).Where(pre).ToList(); 
67.             } 
68.         } 
69.  
70.         /// <summary> 
71.         /// 单个数据集查询 
72.         /// </summary> 
73.         /// <param name="sql"></param> 
74.         /// <param name="parms"></param> 
75.         /// <returns></returns> 
76.         public static List<TEntity> Query<TEntity>(string sql, object parms = null) 
77.         { 
78.             using (IDbConnection conn = CreateConnection()) 
79.             { 
80.                 return conn.Query<TEntity>(sql, parms).ToList(); 
81.             } 
82.         }    
83.  
84.         /// <summary> 
85.         /// 多个数据集查询 
86.         /// </summary> 
87.         /// <param name="sql"></param> 
88.         /// <param name="parms"></param> 
89.         /// <returns></returns> 
90.         public static SqlMapper.GridReader MultyQuery(string sql, object parms = null) 
91.         { 
92.             using (IDbConnection conn = CreateConnection()) 
93.             { 
94.                 return  conn.QueryMultiple(sql, parms); 
95.             } 
96.         } 
97.  
98.         /// <summary> 
99.         /// 单个数据集查询 
100.         /// </summary> 
101.         /// <param name="sql"></param> 
102.         /// <param name="parms"></param> 
103.         /// <returns></returns> 
104.         public static TEntity FirstOrDefault<TEntity>(string sql,Func<TEntity,bool> selector, object parms = null) 
105.         { 
106.             using (IDbConnection conn = CreateConnection()) 
107.             { 
108.                 return conn.Query<TEntity>(sql, parms).Where(selector).FirstOrDefault(); 
109.             } 
110.         } 
111.     } 
112. }
     

我把增删改查抽象出来了，少不了的就是SQL语句的生成，生成SQL语句，要么是映射，要么是反射，而我用的是反射，给一个Entity类，我读取他所有属性和字段，然后生成对应的SQL语句。 NetUtility.Dapper.Core.DataMapping.cs

1. using System; 
2. using System.Collections.Generic; 
3. using System.Configuration; 
4. using System.Linq; 
5. using System.Reflection; 
6. using System.Text; 
7. using System.Threading.Tasks; 
8.  
9. namespace NetUtility.Dapper.Core 
10. { 
11.     internal class DataMapping<TModel> where TModel : class 
12.     { 
13.         #region 数据库类型+DataBaseType 
14.         /// <summary> 
15.         /// 数据库类型 
16.         /// </summary> 
17.         public static string DataBaseType 
18.         { 
19.             get 
20.             { 
21.                 string strType = ConfigurationManager.AppSettings["DataBaseType"]; 
22.                 if (!string.IsNullOrEmpty(strType)) 
23.                 { 
24.                     return strType; 
25.                 } 
26.                 else 
27.                 { 
28.                     return string.Empty; 
29.                 } 
30.             } 
31.         }  
32.         #endregion 
33.  
34.         #region 主键属性字段+PrimaryKey 
35.         /// <summary> 
36.         /// 主键字段名称 
37.         /// </summary> 
38.         public static string PrimaryKey 
39.         { 
40.             get 
41.             { 
42.                 Type t = typeof(TModel); 
43.                 TableInfoAttribute tableInfo = t.GetCustomAttribute(typeof(TableInfoAttribute), true) as TableInfoAttribute;    
44.                 if (tableInfo!=null)//如果没有标识表信息特性，则通过表名向数据库中得到主键信息 
45.                 { 
46.                     return tableInfo.PrimaryKey;               
47.                 } 
48.                 else 
49.                 { 
50.                     string tableName = TableName(); 
51.                     return DataBaseAccess.ExecuteScalar("SELECT name FROM SysColumns WHERE id=Object_Id('" + tableName + "') and colid=(select top 1 colid from sysindexkeys where id=Object_Id('" + tableName + "'))").ToString(); 
52.                 } 
53.             } 
54.         }  
55.         #endregion 
56.  
57.         #region 获取表名+TableName 
58.         /// <summary> 
59.         /// 获取表名 
60.         /// </summary> 
61.         /// <param name="prev">数据库表名前缀</param> 
62.         /// <returns></returns> 
63.         public static string TableName(string prev = "") 
64.         { 
65.             Type t = typeof(TModel); 
66.             TableInfoAttribute tableInfo = t.GetCustomAttribute(typeof(TableInfoAttribute), true) as TableInfoAttribute; 
67.             return tableInfo != null ? tableInfo.TableName : string.Concat(prev, t.Name); 
68.         }  
69.         #endregion 
70.  
71.         #region Select 查询语句+GetQuerySql 
72.         /// <summary> 
73.         /// Select 查询语句 
74.         /// </summary> 
75.         /// <returns></returns> 
76.         public static string GetQuerySql() 
77.         { 
78.             StringBuilder sql = new StringBuilder("select * from "); 
79.             sql.Append(TableName()); 
80.  
81.             return sql.ToString(); 
82.         }  
83.         #endregion 
84.  
85.         #region Insert非Null属性的对象实例 Sql 语句+GetInsertSql 
86.         /// <summary> 
87.         /// Insert 非Null属性的对象实例 Sql 语句 
88.         /// </summary> 
89.         /// <param name="model"></param> 
90.         /// <returns></returns> 
91.         public static string GetInsertSql(TModel model) 
92.         { 
93.             StringBuilder sql = new StringBuilder("insert into "); 
94.  
95.             string[] props = Propertys(model); 
96.             sql.Append(TableName()); 
97.             sql.Append("("); 
98.             sql.Append(string.Join(",", props)); 
99.             sql.Append(") values(@"); 
100.             sql.Append(string.Join(",@", props)); 
101.             sql.Append(");select @@IDENTITY"); 
102.  
103.             return sql.ToString(); 
104.         }  
105.         #endregion 
106.  
107.         #region Delete Sql 语句+GetDeleteSql 
108.         /// <summary> 
109.         /// Delete Sql 语句 
110.         /// </summary> 
111.         /// <returns></returns> 
112.         public static string GetDeleteSql() 
113.         { 
114.             return string.Format(@"delete from {0} where {1} in @IdList", TableName(), PrimaryKey); 
115.         }  
116.         #endregion 
117.  
118.         #region Update 非Null属性的对象实例 Sql语句+GetUpdateSql 
119.         /// <summary> 
120.         /// Update 非Null属性的对象实例 Sql语句 
121.         /// </summary> 
122.         /// <param name="model"></param> 
123.         /// <returns></returns> 
124.         public static string GetUpdateSql(TModel model) 
125.         { 
126.             StringBuilder sql = new StringBuilder("update "); 
127.             string[] props = Propertys(model); 
128.             sql.Append(TableName()); 
129.             sql.Append(" set "); 
130.             foreach (string propName in props) 
131.             { 
132.                 sql.Append(propName + "=@" + propName + ","); 
133.             } 
134.             sql.Remove(sql.Length - 1, 1); 
135.             sql.Append(" where " + PrimaryKey + "=@Id"); 
136.             return sql.ToString(); 
137.         }  
138.         #endregion 
139.  
140.         #region 非主键且非Null属性集合+Propertys 
141.         /// <summary> 
142.         /// 非主键且非Null属性 
143.         /// </summary> 
144.         /// <param name="model"></param> 
145.         /// <returns></returns> 
146.         public static string[] Propertys(TModel model) 
147.         { 
148.             PropertyInfo[] props = typeof(TModel).GetProperties(); 
149.             List<string> list = new List<string>(); 
150.             string key = PrimaryKey; 
151.             if (props != null && props.Length > 0) 
152.             { 
153.                 foreach (PropertyInfo prop in props) 
154.                 { 
155.                     if (prop.GetValue(model, null) != null && !prop.Name.Equals(key, StringComparison.OrdinalIgnoreCase)) 
156.                     { 
157.                         list.Add(prop.Name); 
158.                     } 
159.                 } 
160.             } 
161.  
162.             return list.ToArray(); 
163.         }  
164.         #endregion 
165.     } 
166. } 

代码中的TableInfoAttribute 类是我建一个属性特性类，用于标识表名和主键名称的特性类，假如Entity实体类上面没有标识主键名称，框架默认会用Entity类名作为表名，建议最好标识一下表名和主键名称。

NetUtility.Dapper.Core.TableInfoAttribute.cs

1. using System; 
2. using System.Collections.Generic; 
3. using System.Linq; 
4. using System.Text; 
5. using System.Threading.Tasks; 
6.  
7. namespace NetUtility.Dapper.Core 
8. { 
9.     [AttributeUsage(AttributeTargets.Class | AttributeTargets.Property, AllowMultiple = true, Inherited = true)] 
10.     /// <summary> 
11.     /// 标识表名、主键等信息特性类 
12.     /// </summary> 
13.     public class TableInfoAttribute : Attribute 
14.     { 
15.         /// <summary> 
16.         /// 数据库表名 
17.         /// </summary> 
18.         public string TableName { get; set; } 
19.  
20.         /// <summary> 
21.         /// 主键名称 
22.         /// </summary> 
23.         public string PrimaryKey { get; set; } 
24.  
25.         public TableInfoAttribute() 
26.         { } 
27.         public TableInfoAttribute(string tableName, string key) 
28.         { 
29.             this.TableName = tableName; 
30.             this.PrimaryKey = key; 
31.         } 
32.     } 
33. }using System; 
34. using System.Collections.Generic; 
35. using System.Linq; 
36. using System.Text; 
37. using System.Threading.Tasks; 
38.  
39. namespace NetUtility.Dapper.Core 
40. { 
41.     [AttributeUsage(AttributeTargets.Class | AttributeTargets.Property, AllowMultiple = true, Inherited = true)] 
42.     /// <summary> 
43.     /// 标识表名、主键等信息特性类 
44.     /// </summary> 
45.     public class TableInfoAttribute : Attribute 
46.     { 
47.         /// <summary> 
48.         /// 数据库表名 
49.         /// </summary> 
50.         public string TableName { get; set; } 
51.  
52.         /// <summary> 
53.         /// 主键名称 
54.         /// </summary> 
55.         public string PrimaryKey { get; set; } 
56.  
57.         public TableInfoAttribute() 
58.         { } 
59.         public TableInfoAttribute(string tableName, string key) 
60.         { 
61.             this.TableName = tableName; 
62.             this.PrimaryKey = key; 
63.         } 
64.     } 
65. } 

好，下面就是新建一个抽象类，用于抽象出增删改查的 ExecuteSql<TModel> 泛型抽象类

NetUtility.Dapper.Core.ExecuteSql.cs

1. using Dapper; 
2. using System; 
3. using System.Collections.Generic; 
4. using System.Linq; 
5. using System.Text; 
6. using System.Threading.Tasks; 
7.  
8. namespace NetUtility.Dapper.Core 
9. { 
10.     public abstract class ExecuteSql<TModel> where TModel : class 
11.     { 
12.         #region Insert非Null属性的对象实例+Insert(TModel model) 
13.         /// <summary> 
14.         /// Insert非Null属性的对象实例 
15.         /// </summary> 
16.         /// <param name="model"></param> 
17.         /// <returns></returns> 
18.         public virtual int Insert(TModel model) 
19.         { 
20.             string sql = DataMapping<TModel>.GetInsertSql(model); 
21.             object res = DataBaseAccess.ExecuteScalar(sql, model); 
22.             if (res != null) 
23.             { 
24.                 return Convert.ToInt32(res); 
25.             } 
26.             return 0; 
27.         }  
28.         #endregion 
29.  
30.         #region Select * 查询+Query() 
31.         /// <summary> 
32.         /// Select * 查询 
33.         /// </summary>     
34.         /// <returns></returns> 
35.         public virtual List<TModel> Query() 
36.         { 
37.             string sql = DataMapping<TModel>.GetQuerySql(); 
38.             return DataBaseAccess.Query<TModel>(sql); 
39.         }  
40.         #endregion 
41.  
42.         #region 带查询条件的Select查询+Query(Func<TModel, bool> selector) 
43.         /// <summary> 
44.         /// 带查询条件的Select查询 
45.         /// </summary> 
46.         /// <param name="selector"></param> 
47.         /// <returns></returns> 
48.         public virtual List<TModel> Query(Func<TModel, bool> selector) 
49.         { 
50.             string sql = DataMapping<TModel>.GetQuerySql(); 
51.             return DataBaseAccess.Query<TModel>(sql, selector); 
52.         }  
53.         #endregion 
54.  
55.         #region  得到一个对象的实例+FirstOrDefault(Func<TModel, bool> selector = null) 
56.         /// <summary> 
57.         /// 得到一个对象的实例 
58.         /// </summary> 
59.         /// <param name="selector"></param> 
60.         /// <returns></returns> 
61.         public virtual TModel FirstOrDefault(Func<TModel, bool> selector = null) 
62.         { 
63.             string sql = DataMapping<TModel>.GetQuerySql(); 
64.             return DataBaseAccess.FirstOrDefault<TModel>(sql, selector); 
65.         }  
66.         #endregion 
67.  
68.         #region 批量删除+Delete(string[] IdList) 
69.         /// <summary> 
70.         /// 批量删除 
71.         /// </summary> 
72.         /// <param name="IdList"></param> 
73.         /// <returns></returns> 
74.         public virtual int Delete(string[] IdList) 
75.         { 
76.             return DataBaseAccess.Execute(DataMapping<TModel>.GetDeleteSql(), new { IdList = IdList }); 
77.         }  
78.         #endregion 
79.  
80.         #region Update 一个非Null属性的对象+Update(TModel model) 
81.         /// <summary> 
82.         /// Update 一个非Null属性的对象 
83.         /// </summary> 
84.         /// <param name="model"></param> 
85.         /// <returns></returns> 
86.         public virtual int Update(TModel model) 
87.         { 
88.             return DataBaseAccess.Execute(DataMapping<TModel>.GetUpdateSql(model), model); 
89.         }  
90.         #endregion 
91.  
92.         #region 获取多个数据集+MultyQuery(string sql, object param = null) 
93.         /// <summary> 
94.         /// 获取多个数据集 
95.         /// </summary> 
96.         /// <param name="sql"></param> 
97.         /// <param name="param"></param> 
98.         /// <returns></returns> 
99.         public virtual SqlMapper.GridReader MultyQuery(string sql, object param = null) 
100.         { 
101.             return DataBaseAccess.MultyQuery(sql, param); 
102.         }  
103.         #endregion 
104.  
105.         
106.     } 
107. } 

ExecuteSql.cs 类中的方法全是 virsual方法，使用者可以重写他，特别是查询方法，一定会被重写掉。现在NetUtility.Dapper.Core项目中的类全部写完了，现在 是我业务类的引用了，我现在只需要建一个业务类继承这个抽象类，这些增删改查方法全都有了，已经不需要写了！

下面是我的两个实体类，实体类用TableInfoAttribute特性类标识出了主键名称和表名称：

1. using System; 
2. using System.Collections.Generic; 
3. using System.Linq; 
4. using System.Text; 
5. using System.Threading.Tasks; 
6. using NetUtility.Dapper.Core; 
7.  
8. namespace NetUtility.Entity 
9. { 
10.     [TableInfo(PrimaryKey ="Id",TableName ="Classes")] 
11.     public class Classes 
12.     {   public int Id { get; set; } 
13.         public string Name { get; set; } 
14.         public string Code { get; set; } 
15.     } 
16. } 
17.  
18. using System; 
19. using System.Collections.Generic; 
20. using System.Linq; 
21. using System.Text; 
22. using System.Threading.Tasks; 
23. using NetUtility.Dapper.Core; 
24.  
25. namespace NetUtility.Entity 
26. { 
27.     [TableInfo(PrimaryKey = "Id", TableName = "Student")] 
28.     public class Student 
29.     {        
30.         public int Id { get; set; } 
31.         public string Name { get; set; } 
32.         public string Code { get; set; } 
33.         public int? Age { get; set; } 
34.         public DateTime? JoinDate { get; set; } 
35.         public int? ClassesId { get; set; } 
36.     } 
37. } 

我再新建一个StudentRepertories业务类，继承ExecuteSql抽象类。

NetUtility.Repertories.StudentRepertories.cs

1. using System; 
2. using System.Collections.Generic; 
3. using System.Linq; 
4. using System.Text; 
5. using System.Threading.Tasks; 
6. using NetUtility.Dapper.Core; 
7. using NetUtility.Entity; 
8. using NetUtility.Entity.ExstendEntity;//这个是实体类的扩展类，项目中如不需要可移除 
9. using System.Data; 
10. using Dapper; 
11.  
12. namespace NetUtility.Repertories 
13. { 
14.     public class StudentRepertories : ExecuteSql<Student> 
15.     { 
16.  
17.         public override List<Student> Query() 
18.         { 
19.             return base.Query(); 
20.         } 
21.  
22.         public  List<StudentInfo> QueryInfo() 
23.         { 
24.             string sql = "select * from Student a left join Classes b on a.ClassesId=b.Id"; 
25.  
26.             using (IDbConnection conn = DataBaseAccess.CreateConnection()) 
27.             { 
28.                 return conn.Query<StudentInfo, Classes, StudentInfo>(sql, (stu, classes) => { stu.ClassesModel = classes; return stu; }).ToList();    
29.             } 
30.         } 
31.     } 
32. } 

好了，现在我们只需要建一个控制台测试一下有没有问题就是了，亲测，木有问题。

NetUtility.ConsoleItem

1. using System; 
2. using System.Collections.Generic; 
3. using System.Linq; 
4. using System.Text; 
5. using System.Threading.Tasks; 
6. using NetUtility.Repertories; 
7. using NetUtility.Entity; 
8.  
9. namespace NetUtility.ConsoleItem 
10. { 
11.     class Program 
12.     { 
13.         static void Main(string[] args) 
14.         { 
15.             //业务对象 
16.              StudentRepertories stu = new StudentRepertories(); 
17.             //实体对象 
18.             var model = new Student(){Age = 100,ClassesId = 1,Code = "3200020021",JoinDate = DateTime.Now,Name = "老徐"};        
19.             //新增一个对象 
20.             int StudentId = stu.Insert(model); 
21.             var newModel = stu.FirstOrDefault(a => a.Id == StudentId);  
22.             //Lambda表达式查询 
23.             var list = stu.Query(a => a.Age == 100); 
24.             //不带参数查询 
25.             var studentInfoList = stu.QueryInfo();  
26.             #region 更新 
27.             newModel.Code = "1111111111"; 
28.             newModel.Id = StudentId; 
29.             stu.Update(newModel); 
30.             #endregion 
31.           // 删除 
32.             stu.Delete(new string[] { newModel.Id.ToString() });          
33.             Console.ReadKey(); 
34.         } 
35.     } 
36. } 

各位可以指出我上面的程序一些毛病，相互交流一下，或者有什么更新的做法也可以说说

来源：51CTO