本身寫ORM框架 SqlHelper_DG C#（java的寫在連接裏）

時間 2019-11-30

標籤本身 orm 框架 sqlhelper c# java 寫在連接欄目 Java 简体版

原文原文鏈接

ORM框架想必你們都比較熟知了，即對象關係映射（英語：Object Relation Mapping，簡稱ORM，或O/RM，或O/R mapping），是一種程序技術，用於實現面向對象編程語言裏不一樣類型系統的數據之間的轉換。從效果上說，它實際上是建立了一個可在編程語言裏使用的「虛擬對象數據庫」。當你開發一個應用程序的時候(不使用O/R MAPPING),你可能會寫很多數據訪問層的代碼，用來從數據庫保存，刪除，讀取對象信息，等等。html

如今流行的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中寫了不少的方法來讀取對象數據，改變狀態對象等等任務。而這些代碼寫起來老是重複的。咱們可不能夠寫一個類來封裝這些重複的勞動呢？sql

想必你們都有曾經想過寫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操做
app

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 }

SqlHelper_DG

接下來咱們介紹一下使用方法：

這裏寫的一個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 }