VB.net 2010 视频教程 VB.net 2010 视频教程 python基础视频教程
SQL Server 2008 视频教程 c#入门经典教程 Visual Basic从门到精通视频教程
当前位置:
首页 > temp > C#教程 >

  • 自己写ORM框架 SqlHelper_DG C#（java的写在链接里）

 

ORM框架想必大家都比较熟知了，即对象关系映射（英语：Object Relation Mapping，简称ORM，或O/RM，或O/R mapping），是一种程序技术，用于实现面向对象编程语言里不同类型系统的数据之间的转换。从效果上说，它其实是创建了一个可在编程语言里使用的“虚拟对象数据库”。 当你开发一个应用程序的时候(不使用O/R MAPPING),你可能会写不少数据访问层的代码，用来从数据库保存，删除，读取对象信息，等等。

现在流行的ORM框架有：
JAVA系列：APACHE OJB，CAYENNE，JAXOR，JPA，HIBERNATE，IBATIS/MYBATIS，JRELATIONALFRAMEWORK，SMYLE，TOPLINK等
其中 TOPLINK 是 ORACLE 的商业产品，其他均为开源项目。其中 HIBERNATE的轻量级 ORM 模型逐步确立了在 JAVA ORM 架构中领导地位，甚至取代复杂而又繁琐的 EJB 模型而成为事实上的 JAVA ORM 工业标准。
.NET系列：EF（ENTITY FRAMWORK），NHIBERNATE，Ibits，ENTITYSCODEGENERATE，LINQ TOSQL，GROVE，RUNGOO.ENTERPRISEORM，FIRECODE CREATOR，MYGENERATION，CODESMITH PRO，CODEAUTO等
微软VS中自带的有EF（ENTITY FRAMWORK）框架。

你在DAL中写了很多的方法来读取对象数据，改变状态对象等等任务。而这些代码写起来总是重复的。我们可不可以写一个类来封装这些重复的劳动呢？

想必大家都有曾经想过写SqlHelper吧，实际上，从SqlHelper一步步写下来，封装到足够好之后，就会成为一个自己专属的ORM框架了。

在这里，小编写了一个很基础的类ORM的SqlHelper里面仅仅对Select查询语句进行了封装，由于考虑到了反射机制的诟病（这里不再讨论，关于反射效率问题有大多数的讨论，利与弊总是同时存在的，我们不纠结于这点）。对于常见的CRUD来说，CUD通常一个方法可以实现，并且Sql语句可以得到更大的封装结合配置文件和反射机制进行操作。小编这里采用的模式是SqlServer+SqlHelper+代码生成器（需要代码生成器的可以联系本人,不定期更新）来完成的代码编写工作，因此没有对CUD进行大量的封装，同时也提高了执行效率（你懂的）。

接下来我贴上我的代码（里面注释采用中文注释，比较完善有不懂的可以咨询本人）:

1 public static readonly string ConnString = ConfigurationManager.ConnectionStrings["ConStr"].ConnectionString;

这里的读取数据库连接字符串采用在配置文件中读取的方式，需要在配置文件中进行配置一个连接名称为"ConStr"的连接字符串。如下Appconfig.XML：（这里配置为本机）

1 <connectionStrings>
2     <add name="ConStr" connectionString="Data Source=.;Initial Catalog=db_Test;Integrated Security=True"/>
3 </connectionStrings>

内部的一些主要方法介绍：

ExecuteNonQuery 执行sql命令，返回受影响的行数。 一般用作CUD操作

ExecuteScalar 执行sql语句或存储过程 返回ExecuteScalar （返回自增的ID）不带参数

ExecuteReader 执行sql语句或存储过程 返回DataReader

ExecuteDataSet 执行sql语句或存储过程，返回DataSet

public static List<T> ReturnListByModels<T>(DataSet ds) 反射返回一个List T 类型的结果集 如List<User> 用于Reader操作

public static T ReturnModelByModels<T>(SqlDataReader reader) 反射返回一个T类型的结果 如User 用于Reader操作

SqlHelper_DG代码如下：

复制代码
  1 using System;
  2 using System.Collections.Generic;
  3 using System.ComponentModel;
  4 using System.Configuration;
  5 using System.Data;
  6 using System.Data.SqlClient;
  7 using System.Reflection;
  8 
  9 
 10 namespace SqlHelper_Framework4_5_DG
 11 {
 12     /// <summary>
 13     /// SqlHelper
 14     /// 此类为抽象类，不允许实例化，在应用时直接调用即可;
 15     /// author qixiao（DG）;
 16     /// release Time :20160506;
 17     /// </summary>
 18     public abstract class SqlHelper_DG
 19     {
 20         #region ConStr链接字符串---ConStr链接字符串声明
 21         /// <summary>
 22         /// 连接字符串 ConnString 公共静态只读 不允许进行修改 在后续调用中目前不支持代码修改链接字符串--DG
 23         /// </summary>
 24         public static readonly string ConnString = ConfigurationManager.ConnectionStrings["ConStr"].ConnectionString;
 25         #endregion
 26 
 27         #region ExcuteNonQuery 执行sql语句或者存储过程,返回影响的行数---ExcuteNonQuery
 28         /// <summary>
 29         /// 执行sql语句或存储过程，返回受影响的行数,不带参数。--DG
 30         /// </summary>
 31         /// <param name="ConnString">连接字符串，可以自定义，可以使用SqlHelper_DG.ConnString</param>
 32         /// <param name="commandTextOrSpName">sql语句或存储过程名称</param>
 33         /// <param name="commandType">命令类型 有默认值CommandType.Text</param>
 34         /// <returns>返回受影响的行数</returns>
 35         public static int ExecuteNonQuery(string ConnString, string commandTextOrSpName, CommandType commandType = CommandType.Text)
 36         {
 37             try
 38             {
 39                 using (SqlConnection conn = new SqlConnection(ConnString))
 40                 {
 41                     using (SqlCommand cmd = new SqlCommand())
 42                     {
 43                         PreparCommand(conn, cmd, commandTextOrSpName, commandType);//参数增加了commandType 可以自己编辑执行方式
 44                         return cmd.ExecuteNonQuery();
 45                     }
 46                 }
 47             }
 48             catch (Exception)
 49             {
 50                 return default(int);
 51             }
 52         }
 53         /// <summary>
 54         /// 执行sql语句或存储过程，返回受影响的行数。--DG
 55         /// </summary>
 56         /// <param name="ConnString">连接字符串，可以自定义，可以使用SqlHelper_DG.ConnString</param>
 57         /// <param name="commandTextOrSpName">sql语句或存储过程名称</param>
 58         /// <param name="commandType">命令类型 t</param>
 59         /// <param name="parms">SqlParameter[]参数数组，允许空</param>
 60         /// <returns>返回受影响的行数</returns>
 61         public static int ExecuteNonQuery(string ConnString, string commandTextOrSpName, CommandType commandType, params SqlParameter[] parms)
 62         {
 63             try
 64             {
 65                 using (SqlConnection conn = new SqlConnection(ConnString))
 66                 {
 67                     using (SqlCommand cmd = new SqlCommand())
 68                     {
 69                         PreparCommand(conn, cmd, commandTextOrSpName, commandType, parms);//参数增加了commandType 可以自己编辑执行方式
 70                         return cmd.ExecuteNonQuery();
 71                     }
 72                 }
 73             }
 74             catch (Exception)
 75             {
 76                 return default(int);
 77             }
 78 
 79 
 80         }
 81         /// <summary>
 82         /// 执行sql命令，返回受影响的行数。--DG
 83         /// </summary>
 84         /// <param name="ConnString">连接字符串，可以自定义，可以以使用SqlHelper_DG.ConnString</param>
 85         /// <param name="commandTextOrSpName">sql语句或存储过程名称</param>
 86         /// <param name="commandType">命令类型</param>
 87         /// <param name="obj">object[]参数数组，允许空</param>
 88         /// <returns>返回受影响的行数</returns>
 89         public static int ExecuteNonQuery(string ConnString, string commandTextOrSpName, CommandType commandType, params object[] obj)
 90         {
 91             try
 92             {
 93                 using (SqlConnection conn = new SqlConnection(ConnString))
 94                 {
 95                     using (SqlCommand cmd = new SqlCommand())
 96                     {
 97                         PreparCommand(conn, cmd, commandTextOrSpName, commandType, obj);//参数增加了commandType 可以自己编辑执行方式
 98                         return cmd.ExecuteNonQuery();
 99                     }
100                 }
101             }
102             catch (Exception)
103             {
104                 return default(int);
105             }
106 
107 
108         }
109         #endregion
110 
111         #region ExecuteScalar 执行sql语句或者存储过程,执行单条语句，返回自增的id---ScalarExecuteScalar
112         /// <summary>
113         /// 执行sql语句或存储过程 返回ExecuteScalar （返回自增的ID）不带参数--DG
114         /// </summary>
115         /// <param name="ConnString">连接字符串，可以自定义，可以使用SqlHelper_DG.ConnString</param>
116         /// <param name="commandTextOrSpName">sql语句或存储过程名称</param>
117         /// <param name="commandType">命令类型 有默认值CommandType.Text</param>
118         /// <returns></returns>
119         public static object ExecuteScalar(string ConnString, string commandTextOrSpName, CommandType commandType = CommandType.Text)
120         {
121             try
122             {
123                 using (SqlConnection conn = new SqlConnection(ConnString))
124                 {
125                     using (SqlCommand cmd = new SqlCommand())
126                     {
127                         PreparCommand(conn, cmd, commandTextOrSpName, commandType);
128                         return cmd.ExecuteScalar();
129                     }
130 
131                 }
132             }
133             catch (Exception)
134             {
135                 return default(int);
136             }
137         }
138         /// <summary>
139         /// 执行sql语句或存储过程 返回ExecuteScalar （返回自增的ID）--DG
140         /// </summary>
141         /// <param name="ConnString">连接字符串，可以自定义，可以使用SqlHelper_DG.ConnString</param>
142         /// <param name="commandTextOrSpName">sql语句或存储过程名称</param>
143         /// <param name="commandType">命令类型</param>
144         /// <param name="parms">SqlParameter[]参数数组，允许空</param>
145         /// <returns></returns>
146         public static object ExecuteScalar(string ConnString, string commandTextOrSpName, CommandType commandType, params SqlParameter[] parms)
147         {
148             try
149             {
150                 using (SqlConnection conn = new SqlConnection(ConnString))
151                 {
152                     using (SqlCommand cmd = new SqlCommand())
153                     {
154                         PreparCommand(conn, cmd, commandTextOrSpName, commandType, parms);
155                         return cmd.ExecuteScalar();
156                     }
157 
158                 }
159             }
160             catch (Exception)
161             {
162                 return default(int);
163             }
164         }
165         /// <summary>
166         /// 执行sql语句或存储过程 返回ExecuteScalar （返回自增的ID）--DG
167         /// </summary>
168         /// <param name="ConnString">连接字符串，可以自定义，可以使用SqlHelper_DG.ConnString</param>
169         /// <param name="commandTextOrSpName">sql语句或存储过程名称</param>
170         /// <param name="commandType">命令类型</param>
171         /// <param name="obj">object[]参数数组，允许空</param>
172         /// <returns></returns>
173         public static object ExecuteScalar(string ConnString, string commandTextOrSpName, CommandType commandType, params object[] obj)
174         {
175             try
176             {
177                 using (SqlConnection conn = new SqlConnection(ConnString))
178                 {
179                     using (SqlCommand cmd = new SqlCommand())
180                     {
181                         PreparCommand(conn, cmd, commandTextOrSpName, commandType, obj);
182                         return cmd.ExecuteScalar();
183                     }
184                 }
185             }
186             catch (Exception)
187             {
188 
189                 return default(int);
190             }
191         }
192         #endregion
193 
194         #region ExecuteReader 执行sql语句或者存储过程,返回DataReader---DaataReader
195         /// <summary>
196         /// 执行sql语句或存储过程 返回DataReader 不带参数--DG
197         /// </summary>
198         /// <param name="ConnString">连接字符串，可以自定义，可以使用SqlHelper_DG.ConnString</param>
199         /// <param name="commandTextOrSpName">sql语句或存储过程名称</param>
200         /// <param name="commandType">命令类型 有默认值CommandType.Text</param>
201         /// <returns></returns>
202         public static SqlDataReader ExecuteReader(string ConnString, string commandTextOrSpName, CommandType commandType = CommandType.Text)
203         {
204             //sqlDataReader不能用using 会关闭conn 导致不能获取到返回值。注意：DataReader获取值时必须保持连接状态
205             try
206             {
207                 SqlConnection conn = new SqlConnection(ConnString);
208                 SqlCommand cmd = new SqlCommand();
209                 PreparCommand(conn, cmd, commandTextOrSpName, commandType);
210                 return cmd.ExecuteReader(CommandBehavior.CloseConnection);
211             }
212             catch (Exception)
213             {
214                 return null;
215             }
216         }
217         /// <summary>
218         /// 执行sql语句或存储过程 返回DataReader--DG
219         /// </summary>
220         /// <param name="ConnString">连接字符串，可以自定义，可以使用SqlHelper_DG.ConnString</param>
221         /// <param name="commandTextOrSpName">sql语句或存储过程名称</param>
222         /// <param name="commandType">命令类型</param>
223         /// <param name="parms">SqlParameter[]参数数组，允许空</param>
224         /// <returns></returns>
225         public static SqlDataReader ExecuteReader(string ConnString, string commandTextOrSpName, CommandType commandType, params SqlParameter[] parms)
226         {
227             //sqlDataReader不能用using 会关闭conn 导致不能获取到返回值。注意：DataReader获取值时必须保持连接状态
228             try
229             {
230                 SqlConnection conn = new SqlConnection(ConnString);
231                 SqlCommand cmd = new SqlCommand();
232                 PreparCommand(conn, cmd, commandTextOrSpName, commandType, parms);
233                 return cmd.ExecuteReader(CommandBehavior.CloseConnection);
234             }
235             catch (Exception)
236             {
237                 return null;
238             }
239         }
240         /// <summary>
241         /// 执行sql语句或存储过程 返回DataReader--DG
242         /// </summary>
243         /// <param name="ConnString">连接字符串，可以自定义，可以使用SqlHelper_DG.ConnString</param>
244         /// <param name="commandTextOrSpName">sql语句或存储过程名称</param>
245         /// <param name="commandType">命令类型</param>
246         /// <param name="obj">object[]参数数组，允许空</param>
247         /// <returns></returns>
248         public static SqlDataReader ExecuteReader(string ConnString, string commandTextOrSpName, CommandType commandType, params object[] obj)
249         {
250             //sqlDataReader不能用using 会关闭conn 导致不能获取到返回值。注意：DataReader获取值时必须保持连接状态
251             try
252             {
253                 SqlConnection conn = new SqlConnection(ConnString);
254                 SqlCommand cmd = new SqlCommand();
255                 PreparCommand(conn, cmd, commandTextOrSpName, commandType, obj);
256                 return cmd.ExecuteReader(CommandBehavior.CloseConnection);
257             }
258             catch (Exception)
259             {
260                 return null;
261             }
262         }
263         #endregion
264 
265         #region ExecuteDataset 执行sql语句或者存储过程,返回一个DataSet---DataSet
266         /// <summary>
267         /// 执行sql语句或存储过程，返回DataSet 不带参数--DG
268         /// </summary>
269         /// <param name="ConnString">连接字符串，可以自定义，可以使用SqlHelper_DG.ConnString</param>
270         /// <param name="commandTextOrSpName">sql语句或存储过程名称</param>
271         /// <param name="commandType">命令类型 有默认值CommandType.Text</param>
272         /// <returns></returns>
273         public static DataSet ExecuteDataSet(string ConnString, string commandTextOrSpName, CommandType commandType = CommandType.Text)
274         {
275             try
276             {
277                 using (SqlConnection conn = new SqlConnection(ConnString))
278                 {
279                     using (SqlCommand cmd = new SqlCommand())
280                     {
281                         PreparCommand(conn, cmd, commandTextOrSpName, commandType);
282                         using (SqlDataAdapter da = new SqlDataAdapter(cmd))
283                         {
284                             DataSet ds = new DataSet();
285                             da.Fill(ds);
286                             return ds;
287                         }
288                     }
289                 }
290             }
291             catch (Exception)
292             {
293                 return null;
294             }
295         }
296         /// <summary>
297         /// 执行sql语句或存储过程，返回DataSet--DG
298         /// </summary>
299         /// <param name="ConnString">连接字符串，可以自定义，可以使用SqlHelper_DG.ConnString</param>
300         /// <param name="commandTextOrSpName">sql语句或存储过程名称</param>
301         /// <param name="commandType">命令类型</param>
302         /// <param name="parms">SqlParameter[]参数数组，允许空</param>
303         /// <returns></returns>
304         public static DataSet ExecuteDataSet(string ConnString, string commandTextOrSpName, CommandType commandType, params SqlParameter[] parms)
305         {
306             try
307             {
308                 using (SqlConnection conn = new SqlConnection(ConnString))
309                 {
310                     using (SqlCommand cmd = new SqlCommand())
311                     {
312                         PreparCommand(conn, cmd, commandTextOrSpName, commandType, parms);
313                         using (SqlDataAdapter da = new SqlDataAdapter(cmd))
314                         {
315                             DataSet ds = new DataSet();
316                             da.Fill(ds);
317                             return ds;
318                         }
319                     }
320                 }
321             }
322             catch (Exception)
323             {
324                 return null;
325             }
326         }
327         /// <summary>
328         /// 执行sql语句或存储过程，返回DataSet--DG
329         /// </summary>
330         /// <param name="ConnString">连接字符串，可以自定义，可以使用SqlHelper_DG.ConnString</param>
331         /// <param name="commandTextOrSpName">sql语句或存储过程名称</param>
332         /// <param name="commandType">命令类型 </param>
333         /// <param name="obj">object[]参数数组，允许空</param>
334         /// <returns></returns>
335         public static DataSet ExecuteDataSet(string ConnString, string commandTextOrSpName, CommandType commandType, params object[] obj)
336         {
337             try
338             {
339                 using (SqlConnection conn = new SqlConnection(ConnString))
340                 {
341                     using (SqlCommand cmd = new SqlCommand())
342                     {
343                         PreparCommand(conn, cmd, commandTextOrSpName, commandType, obj);
344                         using (SqlDataAdapter da = new SqlDataAdapter(cmd))
345                         {
346                             DataSet ds = new DataSet();
347                             da.Fill(ds);
348                             return ds;
349                         }
350                     }
351                 }
352             }
353             catch (Exception)
354             {
355                 return null;
356             }
357         }
358         #endregion
359 
360         #region ---PreparCommand 构建一个通用的command对象供内部方法进行调用---
361         /// <summary>
362         /// 不带参数的设置sqlcommand对象--DG
363         /// </summary>
364         /// <param name="conn">sqlconnection对象</param>
365         /// <param name="cmd">sqlcommmand对象</param>
366         /// <param name="commandTextOrSpName">sql语句或存储过程名称</param>
367         /// <param name="commandType">语句的类型</param>
368         private static void PreparCommand(SqlConnection conn, SqlCommand cmd, string commandTextOrSpName, CommandType commandType)
369         {
370             //打开连接
371             if (conn.State != ConnectionState.Open)
372             {
373                 conn.Open();
374             }
375 
376             //设置SqlCommand对象的属性值
377             cmd.Connection = conn;
378             cmd.CommandType = commandType;
379             cmd.CommandText = commandTextOrSpName;
380             cmd.CommandTimeout = 20;
381         }
382         /// <summary>
383         /// 设置一个等待执行的SqlCommand对象--DG
384         /// </summary>
385         /// <param name="conn">sqlconnection对象</param>
386         /// <param name="cmd">sqlcommmand对象</param>
387         /// <param name="commandTextOrSpName">sql语句或存储过程名称</param>
388         /// <param name="commandType">语句的类型</param>
389         /// <param name="parms">参数，sqlparameter类型，需要指出所有的参数名称</param>
390         private static void PreparCommand(SqlConnection conn, SqlCommand cmd, string commandTextOrSpName, CommandType commandType, params SqlParameter[] parms)
391         {
392             //打开连接
393             if (conn.State != ConnectionState.Open)
394             {
395                 conn.Open();
396             }
397 
398             //设置SqlCommand对象的属性值
399             cmd.Connection = conn;
400             cmd.CommandType = commandType;
401             cmd.CommandText = commandTextOrSpName;
402             cmd.CommandTimeout = 20;
403 
404             cmd.Parameters.Clear();
405             if (parms != null)
406             {
407                 cmd.Parameters.AddRange(parms);
408             }
409         }
410         /// <summary>
411         /// PreparCommand方法，可变参数为object需要严格按照参数顺序传参--DG
412         /// </summary>
413         /// <param name="conn">sqlconnection对象</param>
414         /// <param name="cmd">sqlcommmand对象</param>
415         /// <param name="commandTextOrSpName">sql语句或存储过程名称</param>
416         /// <param name="commandType">语句的类型</param>
417         /// <param name="parms">参数，object类型，需要按顺序赋值</param>
418         private static void PreparCommand(SqlConnection conn, SqlCommand cmd, string commandTextOrSpName, CommandType commandType, params object[] parms)
419         {
420 
421             //打开连接
422             if (conn.State != ConnectionState.Open)
423             {
424                 conn.Open();
425             }
426 
427             //设置SqlCommand对象的属性值
428             cmd.Connection = conn;
429             cmd.CommandType = commandType;
430             cmd.CommandText = commandTextOrSpName;
431             cmd.CommandTimeout = 20;
432 
433             cmd.Parameters.Clear();
434             if (parms != null)
435             {
436                 cmd.Parameters.AddRange(parms);
437             }
438         }
439         //之所以会用object参数方法是为了我们能更方便的调用存储过程，不必去关系存储过程参数名是什么，知道它的参数顺序就可以了 sqlparameter必须指定每一个参数名称
440         #endregion
441 
442         #region 通过Model反射返回结果集 Model为 T 泛型变量的真实类型---反射返回结果集Private
443         /// <summary>
444         /// 反射返回一个List T 类型的结果集--DG
445         /// </summary>
446         /// <typeparam name="T">Model中对象类型</typeparam>
447         /// <param name="ds">DataSet结果集</param>
448         /// <returns></returns>
449         public static List<T> ReturnListByModels<T>(DataSet ds)
450         {
451             try
452             {
453                 List<T> list = new List<T>();//实例化一个list对象
454                 T model = System.Activator.CreateInstance<T>();                     //实例化一个T类型对象
455                 PropertyInfo[] propertyInfos = model.GetType().GetProperties();     //获取T对象的所有公共属性
456 
457                 DataTable dt = ds.Tables[0];    // 获取到ds的dt
458                 if (dt.Rows.Count > 0)
459                 {
460                     //判断读取的行是否>0 即数据库数据已被读取
461                     foreach (DataRow row in dt.Rows)
462                     {
463                         T model1 = System.Activator.CreateInstance<T>();//实例化一个对象，便于往list里填充数据
464                         foreach (PropertyInfo propertyInfo in propertyInfos)
465                         {
466                             //遍历模型里所有的字段
467                             if (row[propertyInfo.Name] != System.DBNull.Value)
468                             {
469                                 //判断值是否为空，如果空赋值为null见else
470                                 if (propertyInfo.PropertyType.IsGenericType && propertyInfo.PropertyType.GetGenericTypeDefinition().Equals(typeof(Nullable<>)))
471                                 {
472                                     //如果convertsionType为nullable类，声明一个NullableConverter类，该类提供从Nullable类到基础基元类型的转换
473                                     NullableConverter nullableConverter = new NullableConverter(propertyInfo.PropertyType);
474                                     //将convertsionType转换为nullable对的基础基元类型
475                                     propertyInfo.SetValue(model1, Convert.ChangeType(row[propertyInfo.Name], nullableConverter.UnderlyingType), null);
476                                 }
477                                 else
478                                 {
479                                     propertyInfo.SetValue(model1, Convert.ChangeType(row[propertyInfo.Name], propertyInfo.PropertyType), null);
480                                 }
481                             }
482                             else
483                             {
484                                 propertyInfo.SetValue(model1, null, null);//如果数据库的值为空，则赋值为null
485                             }
486                         }
487                         list.Add(model1);//将对象填充到list中
488                     }
489                 }
490                 return list;
491             }
492             catch (Exception)
493             {
494                 return null;
495             }
496         }
497         /// <summary>
498         /// 反射返回一个T类型的结果--DG
499         /// </summary>
500         /// <typeparam name="T">Model中对象类型</typeparam>
501         /// <param name="reader">SqlDataReader结果集</param>
502         /// <returns></returns>
503         public static T ReturnModelByModels<T>(SqlDataReader reader)
504         {
505             try
506             {
507                 T model = System.Activator.CreateInstance<T>();                     //实例化一个T类型对象
508                 PropertyInfo[] propertyInfos = model.GetType().GetProperties();     //获取T对象的所有公共属性
509                 using (reader)
510                 {
511                     if (reader.Read())
512                     {
513                         foreach (PropertyInfo propertyInfo in propertyInfos)
514                         {
515                             //遍历模型里所有的字段
516                             if (reader[propertyInfo.Name] != System.DBNull.Value)
517                             {
518                                 //判断值是否为空，如果空赋值为null见else
519                                 if (propertyInfo.PropertyType.IsGenericType && propertyInfo.PropertyType.GetGenericTypeDefinition().Equals(typeof(Nullable<>)))
520                                 {
521                                     //如果convertsionType为nullable类，声明一个NullableConverter类，该类提供从Nullable类到基础基元类型的转换
522                                     NullableConverter nullableConverter = new NullableConverter(propertyInfo.PropertyType);
523                                     //将convertsionType转换为nullable对的基础基元类型
524                                     propertyInfo.SetValue(model, Convert.ChangeType(reader[propertyInfo.Name], nullableConverter.UnderlyingType), null);
525                                 }
526                                 else
527                                 {
528                                     propertyInfo.SetValue(model, Convert.ChangeType(reader[propertyInfo.Name], propertyInfo.PropertyType), null);
529                                 }
530                             }
531                             else
532                             {
533                                 propertyInfo.SetValue(model, null, null);//如果数据库的值为空，则赋值为null
534                             }
535                         }
536                         return model;//返回T类型的赋值后的对象 model
537                     }
538                 }
539                 return default(T);//返回引用类型和值类型的默认值0或null
540             }
541             catch (Exception)
542             {
543                 return default(T);//返回引用类型和值类型的默认值0或null
544             }
545         }
546         #endregion
547     }
548 }
复制代码

 

 

接下来我们介绍一下使用方法 ：

这里写的一个tb_TestService数据访问层（用本人的代码生成器自动生成的）,实现的是一个简单的增删改查CRUD操作，里面包含了大部分的SqlHelper_DG的使用方法，大家自己在里面找吧！本人就不在具体说明了。

复制代码
  1 using Model;
  2 using SqlHelper_Framework4_5_DG;
  3 using System;
  4 using System.Collections.Generic;
  5 using System.Data;
  6 using System.Data.SqlClient;
  7 using System.Text;
  8 
  9 namespace DAL
 10 {
 11     /// <summary>
 12     ///七小代码生成器
 13     ///版本号：2.0.0
 14     ///Author:EnglishName：Qixiao，中文名：七小(東哥) 
 15     ///生成器编写时间：20160507，地点：亚洲中国天津
 16     ///代码标准：東哥的SqlHelper_DG
 17     /// </summary>
 18 
 19     /// <summary>
 20     /// 实体类tb_TestService（可添加属性说明）
 21     /// </summary>
 22     public class tb_TestService
 23     {
 24         /// <summary>
 25         /// 计算当前表内的符合条件的所有数据的数量
 26         /// </summary>
 27         /// <param name="safeSqlConditionInBLL">安全的sql条件语句,从BLL层获取</param>
 28         /// <returns></returns>
 29         public int DataCount(string safeSqlConditionInBLL = "")
 30         {
 31             try
 32             {
 33                 string commandText = "select count(0) from tb_Test WHERE " + safeSqlConditionInBLL;
 34                 return Convert.ToInt32(SqlHelper_DG.ExecuteScalar(SqlHelper_DG.ConnString, commandText));
 35             }
 36             catch (Exception)
 37             {
 38                 return default(int);
 39             }
 40         }
 41         /// <summary>
 42         /// 检测是否存在条件所指示的数据------------这个方法需要按需求来修改条件，不能盲目使用！！！
 43         /// </summary>
 44         /// <param name="tb_TestObject">从对象中提取中要查找的字段是否存在(对象方式是防止数据注入！)</param>
 45         /// <returns></returns>
 46         public Boolean IsExistWhereFeild(tb_Test tb_TestObject)
 47         {
 48             try
 49             {
 50                 string commandText = "select count(0) from tb_Test WHERE Str1=@Str1";
 51                 SqlParameter[] parms = new SqlParameter[]{
 52                 new SqlParameter("@Str1",tb_TestObject.Str1),
 53                 };
 54                 return Convert.ToInt32(SqlHelper_DG.ExecuteScalar(SqlHelper_DG.ConnString, commandText,CommandType.Text,parms)) > 0 ? true : false;
 55             }
 56             catch (Exception)
 57             {
 58                 return false;
 59             }
 60         }
 61         /// <summary>
 62         /// Insert插入语句，返回插入的结果：成功true，失败false
 63         /// </summary>
 64         /// <param name="tb_TestObject">要插入的对象，屏蔽掉自增的字段</param>
 65         /// <returns></returns>
 66         public Boolean IsInsert(tb_Test tb_TestObject)
 67         {
 68             try
 69             {
 70                 string commandText = "INSERT INTO tb_Test ( Str1,Id2,Str2) VALUES (@Str1,@Id2,@Str2)";
 71                 SqlParameter[] parms = new SqlParameter[]{
 72                 new SqlParameter("@Str1",tb_TestObject.Str1),
 73                 new SqlParameter("@Id2",tb_TestObject.Id2),
 74                 new SqlParameter("@Str2",tb_TestObject.Str2),
 75                 };
 76                 return SqlHelper_DG.ExecuteNonQuery(SqlHelper_DG.ConnString, commandText, CommandType.Text, parms) > 0 ? true : false;
 77             }
 78             catch (Exception)
 79             {
 80                 return false;
 81             }
 82         }
 83         /// <summary>
 84         /// Update修改语句，返回修改的结果：成功true，失败false
 85         /// </summary>
 86         /// <param name="tb_TestObject">要修改的结果对象，屏蔽掉自增的列，条件可修改</param>
 87         /// <returns></returns>
 88         public Boolean IsUpdate(tb_Test tb_TestObject)
 89         {
 90             try
 91             {
 92                 string commandText = "UPDATE tb_Test SET Str1=@Str1,Id2=@Id2,Str2=@Str2 WHERE Id=@Id";
 93                 SqlParameter[] parms = new SqlParameter[]{
 94                     new SqlParameter("@Id",tb_TestObject.Id),
 95                     new SqlParameter("@Str1",tb_TestObject.Str1),
 96                     new SqlParameter("@Id2",tb_TestObject.Id2),
 97                     new SqlParameter("@Str2",tb_TestObject.Str2),
 98                 };
 99                 return SqlHelper_DG.ExecuteNonQuery(SqlHelper_DG.ConnString, commandText, CommandType.Text, parms) > 0 ? true : false;
100             }
101             catch (Exception)
102             {
103                 return false;
104             }
105         }
106         /// <summary>
107         /// Delete删除语句，返回删除的结果：成功true，失败false
108         /// </summary>
109         /// <param name="tb_TestObject">条件对象，唯一字段或者自定义删除条件</param>
110         /// <returns></returns>
111         public Boolean IsDelete(tb_Test tb_TestObject)
112         {
113             try
114             {
115                 string commandText = "DELETE FROM tb_Test WHERE Id=@Id";
116                 SqlParameter[] parms = new SqlParameter[]{
117                 new SqlParameter("@Id",tb_TestObject.Id),
118                 };
119                 return SqlHelper_DG.ExecuteNonQuery(SqlHelper_DG.ConnString, commandText, CommandType.Text, parms) > 0 ? true : false;
120             }
121             catch (Exception)
122             {
123                 return false;
124             }
125         }
126         /// <summary>
127         /// Select Model语句，返回查询的Model结果
128         /// </summary>
129         /// <param name="tb_TestObject">条件对象，按需求来确定查找的条件</param>
130         /// <returns></returns>
131         public T SelectSingleLine_RTModel<T>(tb_Test tb_TestObject)
132         {
133             try
134             {
135                 string commandText = "SELECT TOP (1) * FROM tb_Test WHERE Id=@Id";//这里需要按需求来确定需要查找的是哪个参数 因为要返回一行数据，所以搜索的条件值必须是唯一的，主键是最佳选择！
136                 SqlParameter[] parms = new SqlParameter[]{
137                 new SqlParameter("@Id",tb_TestObject.Id),
138                 };
139                 return SqlHelper_DG.ReturnModelByModels<T>(SqlHelper_DG.ExecuteReader(SqlHelper_DG.ConnString, commandText, CommandType.Text, parms));
140             }
141             catch (Exception)
142             {
143                 return default(T);
144             }
145         }
146         /// <summary>
147         /// Select List语句，返回查询的List结果集
148         /// </summary>
149         /// <param name="safeSqlCondition">查询的条件,从BLL层传来的安全的sql语句</param>
150         /// <returns></returns>
151         public List<T> SelectALL<T>(string safeSqlCondition = " 1=1 ")
152         {
153             try
154             {
155                 string commandText = "SELECT * FROM tb_Test WHERE " + safeSqlCondition;//这里修改条件语句 默认全部
156                 return SqlHelper_DG.ReturnListByModels<T>(SqlHelper_DG.ExecuteDataSet(SqlHelper_DG.ConnString, commandText));
157             }
158             catch (Exception)
159             {
160                 return null;
161             }
162         }
163         /// <summary>
164         /// 用RowNumber方法进行分页处理返回List结果集，效率最佳但不支持低版本SqlServer
165         /// </summary>
166         /// <param name="PageSize">int页大小，每页容纳的行数</param>
167         /// <param name="PageNumber">int页码，第几页</param>
168         /// <param name="DataOrderBy">object表中按这个字段顺序排序,可以是任意字段,可以加修饰符如DESC</param>
169         /// <param name="safeSqlCondition">所有集合中先找出符合这个条件的结果再进行分页处理 查询的条件,从BLL层传来的安全的sql语句</param>
170         /// <returns></returns>
171         public List<T> SelectALLPaginByRowNumber<T>(int PageSize, int PageNumber, string DataOrderBy,string safeSqlCondition="1=1")
172         {
173             try
174             {
175                 StringBuilder commandText=new StringBuilder ();
176                 commandText.Append("SELECT TOP " + PageSize + " * FROM (SELECT ROW_NUMBER() OVER (ORDER BY " + DataOrderBy + ") AS RowNumber,* FROM tb_Test ");
177                 commandText.Append(" WHERE " + safeSqlCondition + " ");//这里修改条件语句
178                 commandText.Append(" ) AS T  WHERE RowNumber > (" + PageSize + "*(" + PageNumber + "-1))");
179                 return SqlHelper_DG.ReturnListByModels<T>(SqlHelper_DG.ExecuteDataSet(SqlHelper_DG.ConnString, commandText.ToString()));
180             }
181             catch (Exception)
182             {
183                 return null;
184             }
185         }
186     }
187 }
复制代码

 

 

写到这里，相信大家都已经对ORM框架的实现机制有一定的了解，并且能完美的实现一个SqlHelper来进行对自己数据访问代码的封装！如果喜欢，大家可以进一步对Service层的代码进行封装放到一个类里面，更加方便自己对数据库的访问，可以更加简便地访问数据库，有朝一日写出一个属于自己的ORM框架！

 

 

有关于 Java 的 DBUtils 介绍详情请参考：http://www.cnblogs.com/qixiaoyizhan/p/5818599.html

2016-08-29 16:44:12

本文为七小站主原创作品，转载请注明出处：http://www.cnblogs.com/qixiaoyizhan/



相关教程