下面写一下相对来说不变的地方

SQL语句部分，改成了静态函数的形式。

  1using System;
  2using System.Collections.Generic;
  3using System.Text;
  4using System.Data;
  5using System.Data.Common;
  6using System.Data.SqlClient;
  7using JYK;
  8
  9namespace JYK.DataAccessLibrary
 10{
 11    //DataAccessLibrary 数据访问库
 12   
 13    public class DAL
 14    {
 15       
 16        //查询语句部分
 17        运行查询语句返回记录（DataSet、DataTable、DataRow、String[]、String）#region 运行查询语句返回记录（DataSet、DataTable、DataRow、String[]、String）
 18
 19        public static DataSet RunSqlDataSet(string sql)
 20        {
 21            string msg = "";
 22            return RunSqlDataSet(sql, out msg);
 23        }
 24
 25        /**//// 
 26        /// 运行SQL查询语句 返回DataSet。可以传入多条查询语句，返回的DataSet里会有多个DataTable
 27        /// 
 28        /// 查询语句。比如select * from tableName
 29        /// 返回DataSet
 30        函数实现 — — RunSqlDataSet#region 函数实现 — — RunSqlDataSet
 31        public static DataSet RunSqlDataSet(string sql,out string ErrorMsg)
 32        {
 33            ErrorMsg = "";
 34            //设置DataAdapter 
 35            DbDataAdapter da = Factory.CreateDataAdapter(sql);
 36            try
 37            {
 38                DataSet DS = new DataSet();
 39                da.Fill(DS);
 40                return DS;
 41            }
 42            catch (Exception ex)
 43            {
 44                WriteLog.SetErrorMsg("RunSqlDataSet", sql, ex.Message);    //处理错误
 45                ErrorMsg = ex.Message + "
RunSqlDataSet_SQL:" + sql;
 46                return null;
 47            }
 48            finally
 49            {
 50                //关闭数据库，销毁实例
 51                Factory.DbDataAdapterDispose(da);
 52                
 53            }
 54        }
 55        #endregion
 56
 57
 58        public static DataTable RunSqlDataTable(string sql)
 59        {
 60            string msg = "";
 61            return RunSqlDataTable(sql, out msg);
 62       
 63        }
 64
 65        /**//// 
 66        /// 运行SQL查询语句 返回DataTable。
 67        /// 
 68        /// 查询语句。比如select * from tableName
 69        /// 返回DataTable
 70        函数实现 — — RunSqlDataTable#region 函数实现 — — RunSqlDataTable
 71        public static DataTable RunSqlDataTable(string sql, out string ErrorMsg)
 72        {
 73            ErrorMsg = "";
 74            //设置DataAdapter 
 75            DbDataAdapter da = Factory.CreateDataAdapter(sql);
 76            try
 77            {
 78                DataTable DT = new DataTable();
 79                da.Fill(DT);
 80                return DT;
 81            }
 82            catch (Exception ex)
 83            {
 84                WriteLog.SetErrorMsg("RunSqlDataTable", sql, ex.Message);    //处理错误
 85                ErrorMsg = ex.Message + "
RunSqlDataSet_SQL:" + sql;
 86                return null;
 87            }
 88            finally
 89            {
 90                //关闭数据库，销毁实例
 91                Factory.DbDataAdapterDispose(da);
 92            }
 93        }
 94        #endregion
 95
 96
 97        /**//// 
 98        /// 运行SQl语句返回第一条记录。返回DataRow
 99        /// 
100        /// 查询语句。比如select * from tableName
101        /// 
102        函数实现 — — RunSqlDataRow#region 函数实现 — — RunSqlDataRow
103        public static DataRow RunSqlDataRow(string sql)
104        {
105            //设置DataAdapter 
106            DbDataAdapter da = Factory.CreateDataAdapter(sql);
107            try
108            {
109                DataTable DT = new DataTable();
110                da.Fill(DT);
111                if (DT.Rows.Count > 0)
112                    return DT.Rows[0];
113                else
114                    return null;
115            }
116            catch (Exception ex)
117            {
118                WriteLog.SetErrorMsg("RunSqlDataRow", sql, ex.Message);    //处理错误
119                return null;
120            }
121            finally
122            {
123                //关闭数据库，销毁实例
124                Factory.DbDataAdapterDispose(da);
125            }
126
127        }
128        #endregion
129
130
131        /**//// 
132        /// 运行SQl语句返回第一条记录的数组。返回字符串数组
133        /// 
134        /// 查询语句。比如select top 1 * from tableName
135        /// 
136        函数实现 — — RunSqlStrings#region 函数实现 — — RunSqlStrings
137        public static string[] RunSqlStrings(string sql)
138        {
139            //传入查询语句，返回第一条记录的字符串数组
140            //设置command
141            DbCommand cm = Factory.CreateCommand(sql);
142            
143            try
144            {
145                cm.Connection.Open();
146
147                DbDataReader r = cm.ExecuteReader(CommandBehavior.SingleRow);
148                if (r.Read())
149                {
150                    int ArrLength = r.FieldCount;
151
152                    string[] strValue = new string[ArrLength];
153                    for (int i = 0; i < ArrLength; i++)
154                        strValue[i] = r.GetValue(i).ToString();
155                    return strValue;
156                }
157                else
158                {
159                    r.Close();
160                    return null;
161                }
162            }
163            catch (Exception ex)
164            {
165                WriteLog.SetErrorMsg("RunSqlStrings", sql, ex.Message);    //处理错误
166                return null;
167            }
168            finally
169            {
170                cm.Connection.Close();
171                cm.Connection.Dispose();
172                cm.Dispose();
173
174            }
175        }
176        #endregion
177
178        /**//// 
179        /// 运行SQl语句返回每一条记录的第一个字段的数组。返回字符串数组
180        /// 
181        /// 查询语句。比如select myName from tableName
182        /// 
183        函数实现 — — RunSqlStringsByRow#region 函数实现 — — RunSqlStringsByRow
184        public static string[] RunSqlStringsByRow(string sql)
185        {
186
187            //传入查询语句，每一条记录的第一个字段的数组。返回字符串数组
188            //设置command
189            DbCommand cm = Factory.CreateCommand(sql);
190            
191            try
192            {
193                cm.Connection.Open();
194
195                DbDataReader r = cm.ExecuteReader();
196                
197                System.Collections.Generic.List<string> list = new List<string>();
198                while (r.Read())
199                    list.Add(r[0].ToString());
200
201                return list.ToArray();
202
203            }
204            catch (Exception ex)
205            {
206                WriteLog.SetErrorMsg("RunSqlStringsByRow", sql, ex.Message);    //处理错误
207                return null;
208            }
209            finally
210            {
211                cm.Connection.Close();
212                cm.Connection.Dispose();
213                cm.Dispose();
214                
215            }
216        }
217        #endregion
218
219        /**//// 
220        /// 运行SQl语句返回第一条记录的第一列的值。
221        /// 
222        /// 查询语句。比如select top 1 ID from tableName where userName='aa'。会返回ID的内容
223        /// 
224        函数实现 — — RunSqlGetID#region 函数实现 — — RunSqlGetID
225        public static string RunSqlGetID(string sql)
226        {
227            //设置command
228            DbCommand cm = Factory.CreateCommand(sql);
229           
230            try
231            {
232                cm.Connection.Open();
233
234                DbDataReader r = cm.ExecuteReader(CommandBehavior.SingleRow);
235                if (r.Read())
236                    return r.GetValue(0).ToString();
237                else
238                    return null;
239            }
240            catch (Exception ex)
241            {
242                WriteLog.SetErrorMsg("RunSqlGetID", sql, ex.Message);    //处理错误
243                return null;
244            }
245            finally
246            {
247                cm.Connection.Close();
248                cm.Connection.Dispose();
249                cm.Dispose();
250            }
251        }
252        #endregion
253
254        #endregion
255
256        运行查询语句不返回记录集（无返回记录、检查持否存在指定的记录）#region 运行查询语句不返回记录集（无返回记录、检查持否存在指定的记录）
257        /**//// 
258        /// 运行SQL查询语句，不返回记录集。用于添加、修改、删除等操作
259        /// 
260        /// 查询语句。比如insert into tableName 、update tableName
261        /// 
262        函数实现 — — RunSql#region 函数实现 — — RunSql
263        public static void RunSql(string sql)
264        {
265            //设置command
266            DbCommand cm = Factory.CreateCommand(sql);
267           
268            try
269            {
270                cm.Connection.Open();
271                cm.ExecuteNonQuery();
272            }
273            catch (Exception ex)
274            {
275                WriteLog.SetErrorMsg("RunSql", sql, ex.Message);    //处理错误
276            }
277            finally
278            {
279                cm.Connection.Close();
280                cm.Connection.Dispose();
281                cm.Dispose();
282            }
283        }
284        #endregion
285
286
287        /**//// 
288        /// 执行一条SQL语句，看是否能查到记录 有：返回true；没有返回false，用于判断是否重名
289        /// 
290        /// 查询语句。比如select ID from tableName where userName='aa'
291        /// 
292        函数实现 — — RunSqlExists#region 函数实现 — — RunSqlExists
293        public static bool RunSqlExists(string sql)
294        {
295            //设置command
296            DbCommand cm = Factory.CreateCommand(sql);
297           
298            try
299            {
300                if (cm.Connection.State == ConnectionState.Broken || cm.Connection.State == ConnectionState.Closed)
301                    cm.Connection.Open();
302
303                DbDataReader r = cm.ExecuteReader(CommandBehavior.CloseConnection);
304                if (r.HasRows)
305                    return true;
306                else
307                    return false;
308            }
309            catch (Exception ex)
310            {
311                WriteLog.SetErrorMsg("RunSqlDataSet", sql, ex.Message);    //处理错误
312                return true;
313            }
314            finally
315            {
316                cm.Connection.Close();
317                cm.Connection.Dispose();
318                cm.Dispose();
319            }
320        }
321        #endregion
322
323        #endregion
324
325        查询语句的方式添加、修改数据#region 查询语句的方式添加、修改数据
326
327        /**//// 
328        /// 添加记录。传入表名，字段数组，值数组，返回新生成记录的ID
329        /// 
330        /// 要添加记录的表的名称
331        /// 字段名数组
332        /// 字段对应的值的数组
333        /// 
334        public static string InsertDataStr(string TableName, string[] columns, string[] msg)
335        {
336            //添加数据    返回新添加的ID
337            System.Text.StringBuilder SQL = new System.Text.StringBuilder(300);
338            SQL.Append("insert into ");                    //insert into 
339            SQL.Append(TableName);
340            SQL.Append(" (");
341            int i;
342            for (i = 0; i < columns.Length - 1; i++)        //字段
343            {
344                SQL.Append(columns[i]);
345                SQL.Append(",");
346            }
347            SQL.Append(columns[i]);
348            SQL.Append(")  values ('");
349
350            for (i = 0; i < columns.Length - 1; i++)
351            {
352                SQL.Append(msg[i]);
353                SQL.Append("','");
354            }
355            SQL.Append(msg[i]);
356            if (WebConfig.DataBaseType() == 1)
357                SQL.Append("')  select scope_identity() as a1");
358            else
359                SQL.Append("')");
360
361            string re = RunSqlGetID(SQL.ToString());
362            SQL.Length = 1;
363            if (re == null)
364                return "-1";
365            else
366                return re;
367        }
368
369        /**//// 
370        /// 修改记录。传入表名，字段数组，值数组 
371        /// 
372        /// 要修改记录的表的名称
373        /// 字段名数组
374        /// 字段对应的值的数组
375        /// 条件 ，加在where 后面的语句
376        /// 
377        public static bool UpdateData(string TableName, string[] cloumns, string[] msg, string myWhere)
378        {
379            System.Text.StringBuilder SQL = new System.Text.StringBuilder(300);
380            SQL.Append("update ");                    //update
381            SQL.Append(TableName);
382            SQL.Append(" set ");
383            int i;
384            for (i = 0; i < cloumns.Length - 1; i++)
385            {
386                SQL.Append(cloumns[i]);                    //update
387                SQL.Append("='");
388                SQL.Append(msg[i]);
389                SQL.Append("',");
390            }
391            SQL.Append(cloumns[i]);                    //update
392            SQL.Append("='");
393            SQL.Append(msg[i]);
394            SQL.Append("' where ");
395            SQL.Append(myWhere);
396
397            RunSql(SQL.ToString());
398            return true;
399
400        }
401        #endregion
402
403    }
404}
405

存储过程的代码

  1using System;
  2using System.Collections.Generic;
  3using System.Text;
  4using System.Data;
  5using System.Data.Common;
  6using JYK;
  7
  8
  9namespace JYK.DataAccessLibrary
 10{
 11    public class DataAccessLayerSP
 12    {
 13        属性#region 属性
 14        private static string errorMsg;            //出错信息
 15        private static bool  isShowErrorSQL;    //是否显示出错的查询语句（包括存储过程名程）
 16        private DbCommand cm ;            //建立Command对象
 17        
 18        /**//// 
 19        /// 读取出错信息
 20        /// 
 21        public string ErrorMsg            
 22        {
 23            get{return errorMsg;}
 24        }
 25
 26        /**//// 
 27        /// 修改连接字符串，在同时访问两个或两个以上的数据库的时候使用
 28        /// 
 29        public string cnString            
 30        {
 31            set{cm.Connection.ConnectionString = value;}
 32            get{return cm.Connection.ConnectionString;}
 33        }
 34
 35        /**//// 
 36        /// 释放资源~
 37        /// 
 38        public void Dispose()
 39        {
 40            errorMsg = null;
 41            cm.Parameters.Clear();
 42            cm.Connection.Close();
 43            cm.Connection.Dispose();
 44            cm.Dispose();
 45        }
 46        #endregion
 47
 48        public DataAccessLayerSP()    //构造函数
 49        {
 50            //获取连接字符串
 51            cm = Factory.CreateCommand();
 52            cm.CommandType = CommandType.StoredProcedure;
 53            //初始化错误信息
 54            errorMsg = "";
 55
 56            //本地运行，显示出错的查询语句（包括存储过程名程）
 57            isShowErrorSQL = WebConfig.isShowErrorSQL(); 
 58            
 59        }
 60    
 61        //存储过程的参数部分
 62        存储过程的参数部分——清除和添加参数#region 存储过程的参数部分——清除和添加参数
 63
 64        清除参数#region 清除参数
 65        /**//// 
 66        /// 清除Command的存储过程的参数。
 67        /// 
 68        public void ClearParameter()
 69        {cm.Parameters.Clear();}
 70        #endregion
 71    
 72        //int：        tinyint、smallint
 73        //bigint：
 74        //bool：    bit
 75        //double：    float、real
 76        //string：    char、nchar、varchar、nvarchar、uniqueidentifier、smalldatetime、datetime
 77        //string：    ntext、text
 78
 79        //decimal：从 -10^38 +1 到 10^38 –1 的固定精度和小数位的数字数据。
 80        //numeric：功能上等同于 decimal。
 81        //decimal：    smallmoney、money
 82
 83        //二进制
 84        //            binary、varbinary、image
 85
 86        输入型的参数 int 、double、decimal、nvarChar、、、#region 输入型的参数 int 、double、decimal、nvarChar、、、
 87        int#region int
 88        /**//// 
 89        /// 添加int型的参数。
 90        /// 
 91        /// 参数名称。比如 @UserName
 92        /// 参数值
 93        public void addNewParameter(string ParameterName,int ParameterValue)
 94        {
 95            ((System.Data.SqlClient.SqlCommand)cm).Parameters.Add(ParameterName,SqlDbType.Int,4);            //添加存储过程的参数
 96            cm.Parameters[ParameterName].Value=ParameterValue;            //负值
 97            //设置方向取默认值——输入
 98        }
 99        #endregion 
100    
101        double#region double
102        /**//// 
103        /// 添加小数参数，double
104        /// 
105        /// 参数名称。比如 @UserName
106        /// 参数值
107        public void addNewParameter(string ParameterName,double ParameterValue )
108        {
109            ((System.Data.SqlClient.SqlCommand)cm).Parameters.Add(ParameterName, SqlDbType.Float);            //添加存储过程的参数
110            cm.Parameters[ParameterName].Value=ParameterValue;            //负值
111        }
112        #endregion 
113    
114        decimal#region decimal
115        /**//// 
116        /// 添加金额参数，方向是输入（input）。decimal
117        /// 
118        /// 参数名称。比如 @UserName
119        /// 参数值
120        public void addNewParameter(string ParameterName,decimal ParameterValue )
121        {
122            ((System.Data.SqlClient.SqlCommand)cm).Parameters.Add(ParameterName, SqlDbType.Decimal);            //添加存储过程的参数
123            cm.Parameters[ParameterName].Value=ParameterValue;            //负值
124        }
125        #endregion 
126    
127        nvarChar#region nvarChar
128        /**//// 
129        /// 添加nvarChar型的参数。方向是输入（input）
130        /// 
131        /// 参数名称。比如 @UserName
132        /// 参数值
133        /// 参数大小
134        public void addNewParameter(string ParameterName,string ParameterValue,int size)
135        {
136            ((System.Data.SqlClient.SqlCommand)cm).Parameters.Add(ParameterName, SqlDbType.NVarChar, size);            //添加存储过程的参数
137            cm.Parameters[ParameterName].Value=ParameterValue;            //负值
138        }
139        #endregion 
140    
141        nText#region nText
142        /**//// 
143        /// 添加nText型的参数。方向是输入（input）
144        /// 
145        /// 参数名称。比如 @UserName
146        /// 参数值
147        public   void addNewParameter(string ParameterName,string ParameterValue)
148        {
149            ((System.Data.SqlClient.SqlCommand)cm).Parameters.Add(ParameterName, SqlDbType.NText);            //添加存储过程的参数
150            cm.Parameters[ParameterName].Value=ParameterValue;            //负值
151        }
152
153        #endregion 
154    
155        bit#region bit
156        /**//// 
157        /// 添加bit型的参数。方向是输入（input）
158        /// 
159        /// 参数名称。比如 @UserName
160        /// 参数值
161        public   void addNewParameter(string ParameterName,bool ParameterValue)
162        {
163            ((System.Data.SqlClient.SqlCommand)cm).Parameters.Add(ParameterName, SqlDbType.Bit);            //添加存储过程的参数
164            cm.Parameters[ParameterName].Value=ParameterValue;            //负值
165        }
166        #endregion 
167    
168        #endregion
169
170        输出型的参数#region 输出型的参数 
171        
172        /**//// 
173        /// 添加输出型的参数。只支持常用的几个参数类型，如果需要可以扩充。
174        /// 
175        /// 参数名称。比如 @UserName
176        /// 参数的类型
177        public void addNewParameter(string ParameterName,JYK.ParameterKind kind)
178        {
179            switch(kind)
180            {
181                case ParameterKind.Int :
182                    ((System.Data.SqlClient.SqlCommand)cm).Parameters.Add(ParameterName, SqlDbType.Int);            //添加存储过程的参数
183                    break;
184                case ParameterKind.Double:
185                    ((System.Data.SqlClient.SqlCommand)cm).Parameters.Add(ParameterName, SqlDbType.Float);            //添加存储过程的参数
186                    break;
187                case ParameterKind.Decimal :
188                    ((System.Data.SqlClient.SqlCommand)cm).Parameters.Add(ParameterName, SqlDbType.Decimal);            //添加存储过程的参数
189                    break;
190                case ParameterKind.NVarChar :
191                    ((System.Data.SqlClient.SqlCommand)cm).Parameters.Add(ParameterName, SqlDbType.NVarChar, 4000);            //添加存储过程的参数
192                    break;
193                case ParameterKind.Bit :
194                    ((System.Data.SqlClient.SqlCommand)cm).Parameters.Add(ParameterName, SqlDbType.Bit);            //添加存储过程的参数
195                    break;
196            }
197            cm.Parameters[ParameterName].Direction=    ParameterDirection.Output;        //设置方向
198        }
199        
200        #endregion
201
202        #endregion
203
204        存储过程的参数部分——取参数的返回值#region 存储过程的参数部分——取参数的返回值
205
206        /**//// 
207        /// 按序号返回参数值，一般在执行完存储过程后使用
208        /// 
209        /// 序号
210        /// 返回参数的内容
211        public string this[int ParameterIndex]
212        {
213            get {return cm.Parameters[ParameterIndex].Value.ToString(); }
214        }
215
216        /**//// 
217        /// 按名称返回参数值，一般在执行完存储过程后使用
218        /// 
219        /// 参数名称。比如 @UserName
220        /// 返回参数的内容
221        public string this[string ParameterName]
222        {
223            get {return cm.Parameters[ParameterName].Value.ToString(); }
224        }
225        #endregion
226
227        存储过程的参数部分——修改参数值#region 存储过程的参数部分——修改参数值
228        /**//// 
229        /// 按序号修改参数值，一般在一次添加多条记录时用。
230        /// 
231        /// 序号
232        public void setParameter(int ParameterIndex,string parameterValue)
233        {    cm.Parameters[ParameterIndex].Value = parameterValue;}
234
235        /**//// 
236        /// 按名称修改参数值，一般在一次添加多条记录时用
237        /// 
238        /// 参数名称。比如 @UserName
239        public void setParameter(string ParameterName,string parameterValue)
240        {    cm.Parameters[ParameterName].Value = parameterValue;}
241        #endregion
242
243        //存储过程部分
244        运行存储过程返回记录（DataSet、DataTable、不返回记录集）#region 运行存储过程返回记录（DataSet、DataTable、不返回记录集）
245
246        /**//// 
247        /// 运行存储过程返回DataSet。DataSet里面可以是多个表(DateTable)
248        /// 
249        /// 存储过程名称
250        /// 返回DataSet
251        函数实现 — — RunStoreDataSet#region 函数实现 — — RunStoreDataSet
252        public DataSet RunStoreDataSet(string StoredProcedureName)
253        {
254            DbDataAdapter da = Factory.CreateDataAdapter(StoredProcedureName);
255            da.SelectCommand.CommandType = CommandType.StoredProcedure;
256            try
257            {
258                DataSet DS = new DataSet();
259                da.Fill(DS);
260                return DS;
261            }
262            catch(Exception ex)
263            {
264                WriteLog.SetErrorMsg("RunStoreDataSet", StoredProcedureName, ex.Message);    //处理错误
265                return null;
266            }
267            finally
268            {
269                da.Dispose();
270            }
271        }
272        #endregion
273
274        /**//// 
275        /// 运行存储过程返回DataTable。
276        /// 
277        /// 存储过程名称
278        /// 返回DataTable
279        函数实现 — — RunStoreDataTable#region 函数实现 — — RunStoreDataTable
280        public DataTable RunStoreDataTable(string StoredProcedureName)
281        {
282            DbDataAdapter da = Factory.CreateDataAdapter(StoredProcedureName);
283            da.SelectCommand.CommandType = CommandType.StoredProcedure;
284            try
285            {
286                DataTable dt = new DataTable();
287                da.Fill(dt);
288                return dt;
289            }
290            catch(Exception ex)
291            {
292                WriteLog.SetErrorMsg("RunStoreDataTable", StoredProcedureName, ex.Message);    //处理错误
293                return null;
294            }
295            finally
296            {
297                da.Dispose();
298            }
299        }
300        #endregion
301        
302        /**//// 
303        /// 运行存储过程 不返回记录集，用于添加、修改、删除等操作
304        /// 
305        /// 存储过程名称
306        /// 
307        public void RunStore(string StoredProcedureName)
308        {
309            DbCommand cm = Factory.CreateCommand(StoredProcedureName);
310            cm.CommandText = StoredProcedureName;//设置command
311            try
312            {
313                if (cm.Connection.State == ConnectionState.Broken || cm.Connection.State == ConnectionState.Closed )
314                    cm.Connection.Open();
315                cm.ExecuteNonQuery();
316            }
317            catch(Exception ex)
318            {
319                WriteLog.SetErrorMsg("RunStore", StoredProcedureName, ex.Message);    //处理错误
320            }
321            finally
322            {
323                cm.Connection.Close();
324            }
325        }
326        #endregion
327    }
328}

这里没有使用静态函数的方式，目的是为了方便添加存储过程的参数。