本文章为原创内容,如需转发,请申明我及出处,多谢!

本身在二零零五年2月6日写的壹篇作品“数据库小工具(C#)”中提到:

 

      其实,微软的集团库中有1个相当不利的数码操作类了.然则,不少公司(起码小编赶上的多少个…),对部分”封装”了些什么的事物不太敢用,即便自个儿引入过微软的公司库框架了…然而还是要”评估”…一评正是多少个月…而且,1些铺面部分根本便是裸ado.net开发,可能本人包裹的数据库操作类分外别扭,很不好用.
      那里本身给我们共享四个自身参考公司库中的数据操作组件编码风格写的数据库操作类,对使用它的程序员来说,编码是很舒服滴(起码笔者以为很好撒).以下是代码,很简短的,未有做其它多余的卷入,只是改变了ADO.NET的编码步骤,方便了切实可行支出数据库操作代码的程序员.


在编写有关数据库方面包车型地铁C#先后时,平日要求通晓数据库的表中各字段的以下新闻:
壹.
用于OracleParameter(或SqlParameter,…)中的字段和属性的数据库特定的数据类型。

实际,微软的集团库中有二个可怜不易的数目操作类了.不过,不少协作社(起码小编境遇的多少个…),对有个别”封装”了些什么的东西不太敢用,固然自个儿推荐过微软的集团库框架了…不过依旧要”评估”…一评正是多少个月…而且,一些商行部分根本就是裸ado.net开发,可能本身包装的数据库操作类极度别扭,很不好用.
     
那里小编给大家共享一个本太子参考集团库中的数据操作组件编码风格写的数据库操作类,对应用它的程序员来说,编码是很舒服滴(起码笔者觉着很好撒).以下是代码,很简短的,未有做其它多余的包装,只是改变了ADO.NET的编码步骤,方便了现实支出数据库操作代码的程序员.

金沙注册送58 1    using System;
金沙注册送58 2    using System.Data;
金沙注册送58 3    using System.Data.Common;
金沙注册送58 4    using System.Configuration;
金沙注册送58 5
金沙注册送58 6    public class DbHelper
金沙注册送58 7金沙注册送58 8    金沙注册送58 9{
金沙注册送58 10        private static string dbProviderName = ConfigurationManager.AppSettings[“DbHelperProvider”];
金沙注册送58 11        private static string dbConnectionString = ConfigurationManager.AppSettings[“DbHelperConnectionString”];
金沙注册送58 12
金沙注册送58 13        private DbConnection connection;
金沙注册送58 14        public DbHelper()
金沙注册送58 15金沙注册送58 16        金沙注册送58 17{
金沙注册送58 18            this.connection = CreateConnection(DbHelper.dbConnectionString);
金沙注册送58 19        }
金沙注册送58 20        public DbHelper(string connectionString)
金沙注册送58 21金沙注册送58 22        金沙注册送58 23{
金沙注册送58 24            this.connection = CreateConnection(connectionString);
金沙注册送58 25        }
金沙注册送58 26        public static DbConnection CreateConnection()
金沙注册送58 27金沙注册送58 28        金沙注册送58 29{
金沙注册送58 30            DbProviderFactory dbfactory = DbProviderFactories.GetFactory(DbHelper.dbProviderName);
金沙注册送58 31            DbConnection dbconn = dbfactory.CreateConnection();
金沙注册送58 32            dbconn.ConnectionString = DbHelper.dbConnectionString;
金沙注册送58 33            return dbconn;
金沙注册送58 34        }
金沙注册送58 35        public static DbConnection CreateConnection(string connectionString)
金沙注册送58 36金沙注册送58 37        金沙注册送58 38{
金沙注册送58 39            DbProviderFactory dbfactory = DbProviderFactories.GetFactory(DbHelper.dbProviderName);
金沙注册送58 40            DbConnection dbconn = dbfactory.CreateConnection();
金沙注册送58 41            dbconn.ConnectionString = connectionString;
金沙注册送58 42            return dbconn;
金沙注册送58 43        }
金沙注册送58 44
金沙注册送58 45        public DbCommand GetStoredProcCommond(string storedProcedure)
金沙注册送58 46金沙注册送58 47        金沙注册送58 48{
金沙注册送58 49            DbCommand dbCommand = connection.CreateCommand();
金沙注册送58 50            dbCommand.CommandText = storedProcedure;
金沙注册送58 51            dbCommand.CommandType = CommandType.StoredProcedure;
金沙注册送58 52            return dbCommand;
金沙注册送58 53        }
金沙注册送58 54        public DbCommand GetSqlStringCommond(string sqlQuery)
金沙注册送58 55金沙注册送58 56        金沙注册送58 57{
金沙注册送58 58            DbCommand dbCommand = connection.CreateCommand();
金沙注册送58 59            dbCommand.CommandText = sqlQuery;
金沙注册送58 60            dbCommand.CommandType = CommandType.Text;
金沙注册送58 61            return dbCommand;
金沙注册送58 62        }
金沙注册送58 63
金沙注册送58 64金沙注册送58 65        扩大参数#region 扩大参数
金沙注册送58 66        public void AddParameterCollection(DbCommand cmd, DbParameterCollection dbParameterCollection)
金沙注册送58 67金沙注册送58 68        金沙注册送58 69{
金沙注册送58 70            foreach (DbParameter dbParameter in dbParameterCollection)
金沙注册送58 71金沙注册送58 72            金沙注册送58 73{
金沙注册送58 74金沙注册送58,                cmd.Parameters.Add(dbParameter);
金沙注册送58 75            }
金沙注册送58 76        }
金沙注册送58 77        public void AddOutParameter(DbCommand cmd, string parameterName, DbType dbType, int size)
金沙注册送58 78金沙注册送58 79        金沙注册送58 80{
金沙注册送58 81            DbParameter dbParameter = cmd.CreateParameter();
金沙注册送58 82            dbParameter.DbType = dbType;
金沙注册送58 83            dbParameter.ParameterName = parameterName;
金沙注册送58 84            dbParameter.Size = size;
金沙注册送58 85            dbParameter.Direction = ParameterDirection.Output;
金沙注册送58 86            cmd.Parameters.Add(dbParameter);
金沙注册送58 87        }
金沙注册送58 88        public void AddInParameter(DbCommand cmd, string parameterName, DbType dbType, object value)
金沙注册送58 89金沙注册送58 90        金沙注册送58 91{
金沙注册送58 92            DbParameter dbParameter = cmd.CreateParameter();
金沙注册送58 93            dbParameter.DbType = dbType;
金沙注册送58 94            dbParameter.ParameterName = parameterName;
金沙注册送58 95            dbParameter.Value = value;
金沙注册送58 96            dbParameter.Direction = ParameterDirection.Input;
金沙注册送58 97            cmd.Parameters.Add(dbParameter);
金沙注册送58 98        }
金沙注册送58 99        public void AddReturnParameter(DbCommand cmd, string parameterName, DbType dbType)
金沙注册送58 100金沙注册送58 101        金沙注册送58 102{
金沙注册送58 103            DbParameter dbParameter = cmd.CreateParameter();
金沙注册送58 104            dbParameter.DbType = dbType;
金沙注册送58 105            dbParameter.ParameterName = parameterName;
金沙注册送58 106            dbParameter.Direction = ParameterDirection.ReturnValue;
金沙注册送58 107            cmd.Parameters.Add(dbParameter);
金沙注册送58 108        }
金沙注册送58 109        public DbParameter GetParameter(DbCommand cmd, string parameterName)
金沙注册送58 110金沙注册送58 111        金沙注册送58 112{
金沙注册送58 113            return cmd.Parameters[parameterName];
金沙注册送58 114        }
金沙注册送58 115
金沙注册送58 116        #endregion
金沙注册送58 117
金沙注册送58 118金沙注册送58 119        执行#region 执行
金沙注册送58 120        public DataSet ExecuteDataSet(DbCommand cmd)
金沙注册送58 121金沙注册送58 122        金沙注册送58 123{
金沙注册送58 124            DbProviderFactory dbfactory = DbProviderFactories.GetFactory(DbHelper.dbProviderName);
金沙注册送58 125            DbDataAdapter dbDataAdapter = dbfactory.CreateDataAdapter();
金沙注册送58 126            dbDataAdapter.SelectCommand = cmd;
金沙注册送58 127            DataSet ds = new DataSet();
金沙注册送58 128            dbDataAdapter.Fill(ds);
金沙注册送58 129            return ds;
金沙注册送58 130        }
金沙注册送58 131
金沙注册送58 132        public DataTable ExecuteDataTable(DbCommand cmd)
金沙注册送58 133金沙注册送58 134        金沙注册送58 135{
金沙注册送58 136            DbProviderFactory dbfactory = DbProviderFactories.GetFactory(DbHelper.dbProviderName);
金沙注册送58 137            DbDataAdapter dbDataAdapter = dbfactory.CreateDataAdapter();
金沙注册送58 138            dbDataAdapter.SelectCommand = cmd;
金沙注册送58 139            DataTable dataTable = new DataTable();
金沙注册送58 140            dbDataAdapter.Fill(dataTable);
金沙注册送58 141            return dataTable;
金沙注册送58 142        }
金沙注册送58 143
金沙注册送58 144        public DbDataReader ExecuteReader(DbCommand cmd)
金沙注册送58 145金沙注册送58 146        金沙注册送58 147{
金沙注册送58 148            cmd.Connection.Open();
金沙注册送58 149            DbDataReader reader = cmd.ExecuteReader(CommandBehavior.CloseConnection);            
金沙注册送58 150            return reader;
金沙注册送58 151        }
金沙注册送58 152        public int ExecuteNonQuery(DbCommand cmd)
金沙注册送58 153金沙注册送58 154        金沙注册送58 155{
金沙注册送58 156            cmd.Connection.Open();
金沙注册送58 157            int ret = cmd.ExecuteNonQuery();
金沙注册送58 158            cmd.Connection.Close();
金沙注册送58 159            return ret;
金沙注册送58 160        }
金沙注册送58 161
金沙注册送58 162        public object ExecuteScalar(DbCommand cmd)
金沙注册送58 163金沙注册送58 164        金沙注册送58 165{
金沙注册送58 166            cmd.Connection.Open();
金沙注册送58 167            object ret = cmd.ExecuteScalar();
金沙注册送58 168            cmd.Connection.Close();
金沙注册送58 169            return ret;
金沙注册送58 170        }
金沙注册送58 171        #endregion        
金沙注册送58 172
金沙注册送58 173金沙注册送58 174        执行工作#region 执行工作
金沙注册送58 175        public DataSet ExecuteDataSet(DbCommand cmd,Trans t)
金沙注册送58 176金沙注册送58 177        金沙注册送58 178{
金沙注册送58 179            cmd.Connection = t.DbConnection;
金沙注册送58 180            cmd.Transaction = t.DbTrans;
金沙注册送58 181            DbProviderFactory dbfactory = DbProviderFactories.GetFactory(DbHelper.dbProviderName);
金沙注册送58 182            DbDataAdapter dbDataAdapter = dbfactory.CreateDataAdapter();
金沙注册送58 183            dbDataAdapter.SelectCommand = cmd;
金沙注册送58 184            DataSet ds = new DataSet();
金沙注册送58 185            dbDataAdapter.Fill(ds);
金沙注册送58 186            return ds;
金沙注册送58 187        }
金沙注册送58 188
金沙注册送58 189        public DataTable ExecuteDataTable(DbCommand cmd, Trans t)
金沙注册送58 190金沙注册送58 191        金沙注册送58 192{
金沙注册送58 193            cmd.Connection = t.DbConnection;
金沙注册送58 194            cmd.Transaction = t.DbTrans;
金沙注册送58 195            DbProviderFactory dbfactory = DbProviderFactories.GetFactory(DbHelper.dbProviderName);
金沙注册送58 196            DbDataAdapter dbDataAdapter = dbfactory.CreateDataAdapter();
金沙注册送58 197            dbDataAdapter.SelectCommand = cmd;
金沙注册送58 198            DataTable dataTable = new DataTable();
金沙注册送58 199            dbDataAdapter.Fill(dataTable);
金沙注册送58 200            return dataTable;
金沙注册送58 201        }
金沙注册送58 202
金沙注册送58 203        public DbDataReader ExecuteReader(DbCommand cmd, Trans t)
金沙注册送58 204金沙注册送58 205        金沙注册送58 206{
金沙注册送58 207            cmd.Connection.Close();
金沙注册送58 208            cmd.Connection = t.DbConnection;
金沙注册送58 209            cmd.Transaction = t.DbTrans;            
金沙注册送58 210            DbDataReader reader = cmd.ExecuteReader();
金沙注册送58 211            DataTable dt = new DataTable();            
金沙注册送58 212            return reader;
金沙注册送58 213        }
金沙注册送58 214        public int ExecuteNonQuery(DbCommand cmd, Trans t)
金沙注册送58 215金沙注册送58 216        金沙注册送58 217{
金沙注册送58 218            cmd.Connection.Close();
金沙注册送58 219数据库编程,贰个DbHelper数据操作类。            cmd.Connection = t.DbConnection;
金沙注册送58 220            cmd.Transaction = t.DbTrans;  
金沙注册送58 221            int ret = cmd.ExecuteNonQuery();            
金沙注册送58 222            return ret;
金沙注册送58 223        }
金沙注册送58 224
金沙注册送58 225        public object ExecuteScalar(DbCommand cmd, Trans t)
金沙注册送58 226金沙注册送58 227        金沙注册送58 228{
金沙注册送58 229            cmd.Connection.Close();
金沙注册送58 230            cmd.Connection = t.DbConnection;
金沙注册送58 231            cmd.Transaction = t.DbTrans;  
金沙注册送58 232            object ret = cmd.ExecuteScalar();            
金沙注册送58 233            return ret;
金沙注册送58 234        }
金沙注册送58 235        #endregion
金沙注册送58 236    }
金沙注册送58 237
金沙注册送58 238    public class Trans : IDisposable
金沙注册送58 239金沙注册送58 240    金沙注册送58 241{
金沙注册送58 242        private DbConnection conn;
金沙注册送58 243        private DbTransaction dbTrans;
金沙注册送58 244        public DbConnection DbConnection
金沙注册送58 245金沙注册送58 246        金沙注册送58 247{
金沙注册送58 248金沙注册送58 249            get 金沙注册送58 250{ return this.conn; }
金沙注册送58 251        }
金沙注册送58 252        public DbTransaction DbTrans
金沙注册送58 253金沙注册送58 254        金沙注册送58 255{
金沙注册送58 256金沙注册送58 257            get 金沙注册送58 258{ return this.dbTrans; }
金沙注册送58 259        }
金沙注册送58 260
金沙注册送58 261        public Trans()
金沙注册送58 262金沙注册送58 263        金沙注册送58 264{
金沙注册送58 265            conn = DbHelper.CreateConnection();
金沙注册送58 266            conn.Open();
金沙注册送58 267            dbTrans = conn.BeginTransaction();
金沙注册送58 268        }
金沙注册送58 269        public Trans(string connectionString)
金沙注册送58 270金沙注册送58 271        金沙注册送58 272{
金沙注册送58 273            conn = DbHelper.CreateConnection(connectionString);
金沙注册送58 274            conn.Open();
金沙注册送58 275            dbTrans = conn.BeginTransaction();
金沙注册送58 276        }
金沙注册送58 277        public void Commit()
金沙注册送58 278金沙注册送58 279        金沙注册送58 280{
金沙注册送58 281            dbTrans.Commit();
金沙注册送58 282            this.Colse();
金沙注册送58 283        }
金沙注册送58 284
金沙注册送58 285        public void RollBack()
金沙注册送58 286金沙注册送58 287        金沙注册送58 288{
金沙注册送58 289            dbTrans.Rollback();
金沙注册送58 290            this.Colse();
金沙注册送58 291        }
金沙注册送58 292
金沙注册送58 293        public void Dispose()
金沙注册送58 294金沙注册送58 295        金沙注册送58 296{
金沙注册送58 297            this.Colse();
金沙注册送58 298        }
金沙注册送58 299
金沙注册送58 300        public void Colse()
金沙注册送58 301金沙注册送58 302        金沙注册送58 303{
金沙注册送58 304            if (conn.State == System.Data.ConnectionState.Open)
金沙注册送58 305金沙注册送58 306            金沙注册送58 307{
金沙注册送58 308                conn.Close();
金沙注册送58 309            }
金沙注册送58 310        }
金沙注册送58 311    }

 

  1. 其对应的.NET数据类型。

金沙注册送58 312 using System;
金沙注册送58 313 using System.Data;
金沙注册送58 314 using
System.Data.Common;
金沙注册送58 315 using
System.Configuration;
金沙注册送58 316
金沙注册送58 317 public class DbHelper
金沙注册送58 318金沙注册送58 319
金沙注册送58 320{
金沙注册送58 321 private static string
dbProviderName =
ConfigurationManager.AppSettings[“DbHelperProvider”];
金沙注册送58 322 private static string
dbConnectionString =
ConfigurationManager.AppSettings[“DbHelperConnectionString”];
金沙注册送58 323
金沙注册送58 324 private DbConnection
connection;
金沙注册送58 325 public DbHelper()
金沙注册送58 326金沙注册送58 327
金沙注册送58 328{
金沙注册送58 329 this.connection =
CreateConnection(DbHelper.dbConnectionString);
金沙注册送58 330        }
金沙注册送58 331 public DbHelper(string
connectionString)
金沙注册送58 332金沙注册送58 333
金沙注册送58 334{
金沙注册送58 335 this.connection =
CreateConnection(connectionString);
金沙注册送58 336        }
金沙注册送58 337 public static DbConnection
CreateConnection()
金沙注册送58 338金沙注册送58 339
金沙注册送58 340{
金沙注册送58 341           
DbProviderFactory dbfactory =
DbProviderFactories.GetFactory(DbHelper.dbProviderName);
金沙注册送58 342            DbConnection
dbconn = dbfactory.CreateConnection();
金沙注册送58 343           
dbconn.ConnectionString = DbHelper.dbConnectionString;
金沙注册送58 344 return dbconn;
金沙注册送58 345        }
金沙注册送58 346 public static DbConnection
CreateConnection(string connectionString)
金沙注册送58 347金沙注册送58 348
金沙注册送58 349{
金沙注册送58 350           
DbProviderFactory dbfactory =
DbProviderFactories.GetFactory(DbHelper.dbProviderName);
金沙注册送58 351            DbConnection
dbconn = dbfactory.CreateConnection();
金沙注册送58 352           
dbconn.ConnectionString = connectionString;
金沙注册送58 353 return dbconn;
金沙注册送58 354        }
金沙注册送58 355
金沙注册送58 356 public DbCommand
GetStoredProcCommond(string storedProcedure)
金沙注册送58 357金沙注册送58 358
金沙注册送58 359{
金沙注册送58 360            DbCommand
dbCommand = connection.CreateCommand();
金沙注册送58 361           
dbCommand.CommandText = storedProcedure;
金沙注册送58 362           
dbCommand.CommandType = CommandType.StoredProcedure;
金沙注册送58 363 return dbCommand;
金沙注册送58 364        }
金沙注册送58 365 public DbCommand
GetSqlStringCommond(string sqlQuery)
金沙注册送58 366金沙注册送58 367
金沙注册送58 368{
金沙注册送58 369            DbCommand
dbCommand = connection.CreateCommand();
金沙注册送58 370           
dbCommand.CommandText = sqlQuery;
金沙注册送58 371           
dbCommand.CommandType = CommandType.Text;
金沙注册送58 372 return dbCommand;
金沙注册送58 373        }
金沙注册送58 374
金沙注册送58 375金沙注册送58 376
扩大参数#region 扩充参数
金沙注册送58 377 public void
AddParameterCollection(DbCommand cmd, DbParameterCollection
dbParameterCollection)
金沙注册送58 378金沙注册送58 379
金沙注册送58 380{
金沙注册送58 381 foreach (DbParameter
dbParameter in dbParameterCollection)
金沙注册送58 382金沙注册送58 383
金沙注册送58 384{
金沙注册送58 385               
cmd.Parameters.Add(dbParameter);
金沙注册送58 386            }
金沙注册送58 387        }
金沙注册送58 388 public void
AddOutParameter(DbCommand cmd, string parameterName, DbType dbType, int
size)
金沙注册送58 389金沙注册送58 390
金沙注册送58 391{
金沙注册送58 392            DbParameter
dbParameter = cmd.CreateParameter();
金沙注册送58 393           
dbParameter.DbType = dbType;
金沙注册送58 394           
dbParameter.ParameterName = parameterName;
金沙注册送58 395           
dbParameter.Size = size;
金沙注册送58 396           
dbParameter.Direction = ParameterDirection.Output;
金沙注册送58 397           
cmd.Parameters.Add(dbParameter);
金沙注册送58 398        }
金沙注册送58 399 public void
AddInParameter(DbCommand cmd, string parameterName, DbType dbType,
object value)
金沙注册送58 400金沙注册送58 401
金沙注册送58 402{
金沙注册送58 403            DbParameter
dbParameter = cmd.CreateParameter();
金沙注册送58 404           
dbParameter.DbType = dbType;
金沙注册送58 405           
dbParameter.ParameterName = parameterName;
金沙注册送58 406           
dbParameter.Value = value;
金沙注册送58 407           
dbParameter.Direction = ParameterDirection.Input;
金沙注册送58 408           
cmd.Parameters.Add(dbParameter);
金沙注册送58 409        }
金沙注册送58 410 public void
AddReturnParameter(DbCommand cmd, string parameterName, DbType dbType)
金沙注册送58 411金沙注册送58 412
金沙注册送58 413{
金沙注册送58 414            DbParameter
dbParameter = cmd.CreateParameter();
金沙注册送58 415           
dbParameter.DbType = dbType;
金沙注册送58 416           
dbParameter.ParameterName = parameterName;
金沙注册送58 417           
dbParameter.Direction = ParameterDirection.ReturnValue;
金沙注册送58 418           
cmd.Parameters.Add(dbParameter);
金沙注册送58 419        }
金沙注册送58 420 public DbParameter
GetParameter(DbCommand cmd, string parameterName)
金沙注册送58 421金沙注册送58 422
金沙注册送58 423{
金沙注册送58 424 return
cmd.Parameters[parameterName];
金沙注册送58 425        }
金沙注册送58 426
金沙注册送58 427 #endregion
金沙注册送58 428
金沙注册送58 429金沙注册送58 430
执行#region 执行
金沙注册送58 431 public DataSet
ExecuteDataSet(DbCommand cmd)
金沙注册送58 432金沙注册送58 433
金沙注册送58 434{
金沙注册送58 435           
DbProviderFactory dbfactory =
DbProviderFactories.GetFactory(DbHelper.dbProviderName);
金沙注册送58 436            DbDataAdapter
dbDataAdapter = dbfactory.CreateDataAdapter();
金沙注册送58 437           
dbDataAdapter.SelectCommand = cmd;
金沙注册送58 438            DataSet ds =
new DataSet();
金沙注册送58 439           
dbDataAdapter.Fill(ds);
金沙注册送58 440 return ds;
金沙注册送58 441        }
金沙注册送58 442
金沙注册送58 443 public DataTable
ExecuteDataTable(DbCommand cmd)
金沙注册送58 444金沙注册送58 445
金沙注册送58 446{
金沙注册送58 447           
DbProviderFactory dbfactory =
DbProviderFactories.GetFactory(DbHelper.dbProviderName);
金沙注册送58 448            DbDataAdapter
dbDataAdapter = dbfactory.CreateDataAdapter();
金沙注册送58 449           
dbDataAdapter.SelectCommand = cmd;
金沙注册送58 450            DataTable
dataTable = new DataTable();
金沙注册送58 451           
dbDataAdapter.Fill(dataTable);
金沙注册送58 452 return dataTable;
金沙注册送58 453        }
金沙注册送58 454
金沙注册送58 455 public DbDataReader
ExecuteReader(DbCommand cmd)
金沙注册送58 456金沙注册送58 457
金沙注册送58 458{
金沙注册送58 459           
cmd.Connection.Open();
金沙注册送58 460            DbDataReader
reader =
cmd.ExecuteReader(CommandBehavior.CloseConnection);           
金沙注册送58 461 return reader;
金沙注册送58 462        }
金沙注册送58 463 public int
ExecuteNonQuery(DbCommand cmd)
金沙注册送58 464金沙注册送58 465
金沙注册送58 466{
金沙注册送58 467           
cmd.Connection.Open();
金沙注册送58 468 int ret =
cmd.ExecuteNonQuery();
金沙注册送58 469           
cmd.Connection.Close();
金沙注册送58 470 return ret;
金沙注册送58 471        }
金沙注册送58 472
金沙注册送58 473 public object
ExecuteScalar(DbCommand cmd)
金沙注册送58 474金沙注册送58 475
金沙注册送58 476{
金沙注册送58 477           
cmd.Connection.Open();
金沙注册送58 478 object ret =
cmd.ExecuteScalar();
金沙注册送58 479           
cmd.Connection.Close();
金沙注册送58 480 return ret;
金沙注册送58 481        }
金沙注册送58 482 #endregion
金沙注册送58 483
金沙注册送58 484金沙注册送58 485
执行工作#region 执行工作
金沙注册送58 486 public DataSet
ExecuteDataSet(DbCommand cmd,Trans t)
金沙注册送58 487金沙注册送58 488
金沙注册送58 489{
金沙注册送58 490            cmd.Connection
= t.DbConnection;
金沙注册送58 491            cmd.Transaction
= t.DbTrans;
金沙注册送58 492           
DbProviderFactory dbfactory =
DbProviderFactories.GetFactory(DbHelper.dbProviderName);
金沙注册送58 493            DbDataAdapter
dbDataAdapter = dbfactory.CreateDataAdapter();
金沙注册送58 494           
dbDataAdapter.SelectCommand = cmd;
金沙注册送58 495            DataSet ds =
new DataSet();
金沙注册送58 496           
dbDataAdapter.Fill(ds);
金沙注册送58 497 return ds;
金沙注册送58 498        }
金沙注册送58 499
金沙注册送58 500 public DataTable
ExecuteDataTable(DbCommand cmd, Trans t)
金沙注册送58 501金沙注册送58 502
金沙注册送58 503{
金沙注册送58 504            cmd.Connection
= t.DbConnection;
金沙注册送58 505            cmd.Transaction
= t.DbTrans;
金沙注册送58 506           
DbProviderFactory dbfactory =
DbProviderFactories.GetFactory(DbHelper.dbProviderName);
金沙注册送58 507            DbDataAdapter
dbDataAdapter = dbfactory.CreateDataAdapter();
金沙注册送58 508           
dbDataAdapter.SelectCommand = cmd;
金沙注册送58 509            DataTable
dataTable = new DataTable();
金沙注册送58 510           
dbDataAdapter.Fill(dataTable);
金沙注册送58 511 return dataTable;
金沙注册送58 512        }
金沙注册送58 513
金沙注册送58 514 public DbDataReader
ExecuteReader(DbCommand cmd, Trans t)
金沙注册送58 515金沙注册送58 516
金沙注册送58 517{
金沙注册送58 518           
cmd.Connection.Close();
金沙注册送58 519            cmd.Connection
= t.DbConnection;
金沙注册送58 520            cmd.Transaction
= t.DbTrans;           
金沙注册送58 521            DbDataReader
reader = cmd.ExecuteReader();
金沙注册送58 522            DataTable dt =
new DataTable();           
金沙注册送58 523 return reader;
金沙注册送58 524        }
金沙注册送58 525 public int
ExecuteNonQuery(DbCommand cmd, Trans t)
金沙注册送58 526金沙注册送58 527
金沙注册送58 528{
金沙注册送58 529           
cmd.Connection.Close();
金沙注册送58 530            cmd.Connection
= t.DbConnection;
金沙注册送58 531            cmd.Transaction
= t.DbTrans; 
金沙注册送58 532 int ret =
cmd.ExecuteNonQuery();           
金沙注册送58 533 return ret;
金沙注册送58 534        }
金沙注册送58 535
金沙注册送58 536 public object
ExecuteScalar(DbCommand cmd, Trans t)
金沙注册送58 537金沙注册送58 538
金沙注册送58 539{
金沙注册送58 540           
cmd.Connection.Close();
金沙注册送58 541            cmd.Connection
= t.DbConnection;
金沙注册送58 542            cmd.Transaction
= t.DbTrans; 
金沙注册送58 543 object ret =
cmd.ExecuteScalar();           
金沙注册送58 544 return ret;
金沙注册送58 545        }
金沙注册送58 546 #endregion
金沙注册送58 547    }
金沙注册送58 548
金沙注册送58 549 public class Trans :
IDisposable
金沙注册送58 550金沙注册送58 551
金沙注册送58 552{
金沙注册送58 553 private DbConnection
conn;
金沙注册送58 554 private DbTransaction
dbTrans;
金沙注册送58 555 public DbConnection
DbConnection
金沙注册送58 556金沙注册送58 557
金沙注册送58 558{
金沙注册送58 559金沙注册送58 560
get 金沙注册送58 561{ return this.conn; }
金沙注册送58 562        }
金沙注册送58 563 public DbTransaction
DbTrans
金沙注册送58 564金沙注册送58 565
金沙注册送58 566{
金沙注册送58 567金沙注册送58 568
get 金沙注册送58 569{ return this.dbTrans;
}
金沙注册送58 570        }
金沙注册送58 571
金沙注册送58 572 public Trans()
金沙注册送58 573金沙注册送58 574
金沙注册送58 575{
金沙注册送58 576            conn =
DbHelper.CreateConnection();
金沙注册送58 577            conn.Open();
金沙注册送58 578            dbTrans =
conn.BeginTransaction();
金沙注册送58 579        }
金沙注册送58 580 public Trans(string
connectionString)
金沙注册送58 581金沙注册送58 582
金沙注册送58 583{
金沙注册送58 584            conn =
DbHelper.CreateConnection(connectionString);
金沙注册送58 585            conn.Open();
金沙注册送58 586            dbTrans =
conn.BeginTransaction();
金沙注册送58 587        }
金沙注册送58 588 public void Commit()
金沙注册送58 589金沙注册送58 590
金沙注册送58 591{
金沙注册送58 592           
dbTrans.Commit();
金沙注册送58 593 this.Colse();
金沙注册送58 594        }
金沙注册送58 595
金沙注册送58 596 public void RollBack()
金沙注册送58 597金沙注册送58 598
金沙注册送58 599{
金沙注册送58 600           
dbTrans.Rollback();
金沙注册送58 601 this.Colse();
金沙注册送58 602        }
金沙注册送58 603
金沙注册送58 604 public void Dispose()
金沙注册送58 605金沙注册送58 606
金沙注册送58 607{
金沙注册送58 608 this.Colse();
金沙注册送58 609        }
金沙注册送58 610
金沙注册送58 611 public void Colse()
金沙注册送58 612金沙注册送58 613
金沙注册送58 614{
金沙注册送58 615 if (conn.State ==
System.Data.ConnectionState.Open)
金沙注册送58 616金沙注册送58 617
金沙注册送58 618{
金沙注册送58 619               
conn.Close();
金沙注册送58 620            }
金沙注册送58 621        }
金沙注册送58 622    }

那么什么样运用它吗?上边作者付诸一些着力的使用示例,基本能满意你超过二分之一的数据库操作要求了.
一)直接执行sql语句

1、在System.Data.Common命名空间下,存在这么的三个类:

霎时,对各样不一致的数据库是分别达成这几个“数据库小工具”的。

那么怎样采纳它吗?上边小编付出1些着力的利用示例,基本能满意你大多数的数据库操作须求了.
壹)直接执行sql语句

金沙注册送58 623        DbHelper db = new DbHelper();
金沙注册送58 624        DbCommand cmd = db.GetSqlStringCommond(“insert t1 (id)values(‘haha’)”);
金沙注册送58 625        db.ExecuteNonQuery(cmd);

    //
    // 摘要:
    //     表示一组方法,这些方法用于创建提供程序对数据源类的实现的实例。
    public abstract class DbProviderFactory
    {
        //
        // 摘要:
        //     初始化 System.Data.Common.DbProviderFactory 类的新实例。
        protected DbProviderFactory();

        //
        // 摘要:
        //     指定特定的 System.Data.Common.DbProviderFactory 是否支持 System.Data.Common.DbDataSourceEnumerator
        //     类。
        //
        // 返回结果:
        //     如果 System.Data.Common.DbProviderFactory 的实例支持 System.Data.Common.DbDataSourceEnumerator
        //     类,则为 true;否则为 false。
        public virtual bool CanCreateDataSourceEnumerator { get; }

        //
        // 摘要:
        //     返回实现 System.Data.Common.DbCommand 类的提供程序的类的一个新实例。
        //
        // 返回结果:
        //     System.Data.Common.DbCommand 的新实例。
        public virtual DbCommand CreateCommand();
        //
        // 摘要:
        //     返回实现 System.Data.Common.DbCommandBuilder 类的提供程序的类的一个新实例。
        //
        // 返回结果:
        //     System.Data.Common.DbCommandBuilder 的新实例。
        public virtual DbCommandBuilder CreateCommandBuilder();
        //
        // 摘要:
        //     返回实现 System.Data.Common.DbConnection 类的提供程序的类的一个新实例。
        //
        // 返回结果:
        //     System.Data.Common.DbConnection 的新实例。
        public virtual DbConnection CreateConnection();
        //
        // 摘要:
        //     返回实现 System.Data.Common.DbConnectionStringBuilder 类的提供程序的类的一个新实例。
        //
        // 返回结果:
        //     System.Data.Common.DbConnectionStringBuilder 的新实例。
        public virtual DbConnectionStringBuilder CreateConnectionStringBuilder();
        //
        // 摘要:
        //     返回实现 System.Data.Common.DbDataAdapter 类的提供程序的类的一个新实例。
        //
        // 返回结果:
        //     System.Data.Common.DbDataAdapter 的新实例。
        public virtual DbDataAdapter CreateDataAdapter();
        //
        // 摘要:
        //     返回实现 System.Data.Common.DbDataSourceEnumerator 类的提供程序的类的一个新实例。
        //
        // 返回结果:
        //     System.Data.Common.DbDataSourceEnumerator 的新实例。
        public virtual DbDataSourceEnumerator CreateDataSourceEnumerator();
        //
        // 摘要:
        //     返回实现 System.Data.Common.DbParameter 类的提供程序的类的一个新实例。
        //
        // 返回结果:
        //     System.Data.Common.DbParameter 的新实例。
        public virtual DbParameter CreateParameter();
        //
        // 摘要:
        //     返回提供程序的类的新实例,该实例可实现提供程序的 System.Security.CodeAccessPermission 类的版本。
        //
        // 参数:
        //   state:
        //     System.Security.Permissions.PermissionState 值之一。
        //
        // 返回结果:
        //     指定 System.Security.Permissions.PermissionState 的 System.Security.CodeAccessPermission
        //     对象。
        public virtual CodeAccessPermission CreatePermission(PermissionState state);
    }

前天,让我们将那一个独立的“小工具”整合在1齐吧。

金沙注册送58 626        DbHelper db = new
DbHelper();
金沙注册送58 627        DbCommand cmd =
db.GetSqlStringCommond(“insert t1 (id)values(‘haha’)”);
金沙注册送58 628       
db.ExecuteNonQuery(cmd);

二)执行存款和储蓄进程

大家能够观看,在此类中,有无数用来创建数据库相关对象的项目,如DbConnection,DbCommand,DbDataAdapter等。

金沙注册送58 629

2)执行存款和储蓄进程

金沙注册送58 630        DbHelper db = new DbHelper();
金沙注册送58 631        DbCommand cmd = db.GetStoredProcCommond(“t1_insert”);
金沙注册送58 632        db.AddInParameter(cmd, “@id”, DbType.String, “heihei”);
金沙注册送58 633        db.ExecuteNonQuery(cmd);

而且,完成诸如SqlConnection、SqlCommand、SqlData艾达pter(这里用的是SQL
Server)的门类,都分别继承自DbConnection,DbCommand,DbDataAdapter,

从上海体育场所中得以见到 Odbc、奥莱Db、Oracle、SQL Server、SQL Server Mobile
艾德ition、SQL Server Compact 艾德ition、SQLite、MySql
等数据库都已经组成在同四个顺序中了。

金沙注册送58 634        DbHelper db = new
DbHelper();
金沙注册送58 635        DbCommand cmd =
db.GetStoredProcCommond(“t1_insert”);
金沙注册送58 636       
db.AddInParameter(cmd, “@id”, DbType.String, “heihei”);
金沙注册送58 637       
db.ExecuteNonQuery(cmd);

3)返回DataSet

从而,大家得以行使DbProviderFactory来创建我们想要的、可完结其余数据库的DbHelper。

金沙注册送58 638

3)返回DataSet

金沙注册送58 639        DbHelper db = new DbHelper();
金沙注册送58 640        DbCommand cmd = db.GetSqlStringCommond(“select * from t1”);
金沙注册送58 641        DataSet ds = db.ExecuteDataSet(cmd);

2、完结宗旨的DbHelper匡助类

上海教室展示执行一条 SQL 语句后的结果。

金沙注册送58 642        DbHelper db = new
DbHelper();
金沙注册送58 643        DbCommand cmd =
db.GetSqlStringCommond(“select * from t1”);
金沙注册送58 644        DataSet ds =
db.ExecuteDataSet(cmd);

4)返回DataTable

1、大家将DbHelper定义为抽象类,并在类中提供三个抽象可读属性,名字为DbProviderFactory,再次回到类型为DbProviderFactory(注:名称与再次来到类型能够为同一,也足以不等同),

金沙注册送58 645

4)返回DataTable

金沙注册送58 646        DbHelper db = new DbHelper();
金沙注册送58 647        DbCommand cmd = db.GetSqlStringCommond(“t1_findall”);
金沙注册送58 648        DataTable dt = db.ExecuteDataTable(cmd);

贰、大家选取在该抽象类完成的子类中重写DbProviderFactory方法,并在子类的构造函数中为该属性赋值,该值正是曾经落到实处了具体数据库类型的DbProviderFactory。

上海教室显示出数据库中的表的布局。

金沙注册送58 649        DbHelper db = new
DbHelper();
金沙注册送58 650        DbCommand cmd =
db.GetSqlStringCommond(“t1_findall”);
金沙注册送58 651        DataTable dt =
db.ExecuteDataTable(cmd);

5)输入参数/输出参数/重返值的利用(相比较首要哦)

概念的代码参考如下:

好了,大家来看源程序吗:

五)输入参数/输出参数/重返值的行使(比较重大哦)

金沙注册送58 652        DbHelper db = new DbHelper();
金沙注册送58 653        DbCommand cmd = db.GetStoredProcCommond(“t2_insert”);
金沙注册送58 654        db.AddInParameter(cmd, “@timeticks”, DbType.Int64, DateTime.Now.Ticks);
金沙注册送58 655        db.AddOutParameter(cmd, “@outString”, DbType.String, 20);
金沙注册送58 656        db.AddReturnParameter(cmd, “@returnValue”, DbType.Int32);
金沙注册送58 657
金沙注册送58 658        db.ExecuteNonQuery(cmd);
金沙注册送58 659
金沙注册送58 660        string s = db.GetParameter(cmd, “@outString”).Value as string;//out parameter
金沙注册送58 661        int r = Convert.ToInt32(db.GetParameter(cmd, “@returnValue”).Value);//return value
金沙注册送58 662

    public abstract class DbHelper
    {
        public abstract DbProviderFactory DbProviderFactory { get; }
    }
using System;
using System.IO;
using System.Data;
using System.Data.Common;
using System.Windows.Forms;

namespace Skyiv.Ben.DbTools
{
  public partial class MainForm : Form
  {
    public MainForm()
    {
      InitializeComponent();
    }

    private void MainForm_Load(object sender, EventArgs e)
    {
      try
      {
        tbxDsn.Text = "Data Source=:memory:";
        tbxSql.Text = "select sqlite_version()";
        var table = DbProviderFactories.GetFactoryClasses();
        lbxDbProvider.ValueMember = "InvariantName";
        lbxDbProvider.DataSource = table;
        dgvMain.DataSource = table;
        lbxDbProvider.SelectedValue = "System.Data.SQLite";
      }
      catch (Exception ex)
      {
        tbxMessage.AppendText(Pub.GetMessage(ex));
      }
    }

    private void btnSubmit_Click(object sender, EventArgs e)
    {
      btnSubmit.Enabled = false;
      try
      {
        tbxMessage.Clear();
        var factory = DbProviderFactories.GetFactory(lbxDbProvider.SelectedValue.ToString());
        using (var conn = factory.CreateConnection())
        {
          conn.ConnectionString = tbxDsn.Text;
          conn.Open();
          tbxMessage.AppendLine("Client Version: [{0}]", Pub.GetClientVersion(Path.GetFileNameWithoutExtension(factory.ToString())));
          tbxMessage.AppendLine("Server Version: [{0}]", conn.ServerVersion);
          var sql = tbxSql.Text.Trim();
          if (sql.Length != 0)
          {
            var comm = conn.CreateCommand();
            comm.CommandText = sql;
            var isQuery = IsQuery(sql);
            var rows = int.MinValue;
            if (!isQuery) rows = comm.ExecuteNonQuery();
            else if (chkStruct.Checked) dgvMain.DataSource = RunQueryTableStruct(comm);
            else dgvMain.DataSource = RunQueryTableData(factory, comm);
            tbxMessage.AppendText("运行 SQL 语句完毕(" + (!isQuery ? "非查询" : (chkStruct.Checked ? "表结构" : "查询")) + ")");
            if (rows >= 0) tbxMessage.AppendText(",受影响的行数: " + rows.ToString("N0"));
          }
          else tbxMessage.AppendText("完成");
        }
      }
      catch (Exception ex)
      {
        tbxMessage.AppendText(Pub.GetMessage(ex));
      }
      btnSubmit.Enabled = true;
    }

    DataView RunQueryTableStruct(DbCommand comm)
    {
      using (var r = comm.ExecuteReader(CommandBehavior.KeyInfo))
      {
        return r.GetSchemaTable().DefaultView;
      }
    }

    DataView RunQueryTableData(DbProviderFactory factory, DbCommand comm)
    {
      var da = factory.CreateDataAdapter();
      da.SelectCommand = comm;
      var ds = new DataSet();
      da.Fill(ds);
      return ds.Tables[0].DefaultView;
    }

    bool IsQuery(string sql)
    {
      return sql.ToUpper().StartsWith("SELECT");
    }
  }
}

金沙注册送58 663        DbHelper db = new
DbHelper();
金沙注册送58 664        DbCommand cmd =
db.GetStoredProcCommond(“t2_insert”);
金沙注册送58 665       
db.AddInParameter(cmd, “@timeticks”, DbType.Int64,
DateTime.Now.Ticks);
金沙注册送58 666       
db.AddOutParameter(cmd, “@outString”, DbType.String, 20);
金沙注册送58 667       
db.AddReturnParameter(cmd, “@returnValue”, DbType.Int32);
金沙注册送58 668
金沙注册送58 669       
db.ExecuteNonQuery(cmd);
金沙注册送58 670
金沙注册送58 671 string s =
db.GetParameter(cmd, “@outString”).Value as string;//out parameter
金沙注册送58 672 int r =
Convert.ToInt32(db.GetParameter(cmd, “@returnValue”).Value);//return
value
金沙注册送58 673

6)DataReader使用

三、大家为该抽象类编写1个构造函数,传进去的参数为总是字符串,并将其储存在可读的ConnectionString字段里,代码如下:

那个程序首要使用 System.Data.Common 命名空间中的类来展开工作 。

6)DataReader使用

金沙注册送58 674      DbHelper db = new DbHelper();
金沙注册送58 675        DbCommand cmd = db.GetStoredProcCommond(“t2_insert”);
金沙注册送58 676        db.AddInParameter(cmd, “@timeticks”, DbType.Int64, DateTime.Now.Ticks);
金沙注册送58 677        db.AddOutParameter(cmd, “@outString”, DbType.String, 20);
金沙注册送58 678        db.AddReturnParameter(cmd, “@returnValue”, DbType.Int32);
金沙注册送58 679
金沙注册送58 680        using (DbDataReader reader = db.ExecuteReader(cmd))
金沙注册送58 681金沙注册送58 682        金沙注册送58 683{
金沙注册送58 684            dt.Load(reader);
金沙注册送58 685        }        
金沙注册送58 686        string s = db.GetParameter(cmd, “@outString”).Value as string;//out parameter
金沙注册送58 687        int r = Convert.ToInt32(db.GetParameter(cmd, “@returnValue”).Value);//return value
金沙注册送58 688

    public abstract class DbHelper
    {
        public DbHelper(string connectionString)
        {
            ConnectionString = connectionString;
        }
        public string ConnectionString { get; }
        public abstract DbProviderFactory DbProviderFactory { get; }
    }

在 MainForm_Load 方法(第三6到3二行)中采用 DbProviderFactories 的静态方法
GetFactoryClasses 得到在本机中落到实处 DbProviderFactories
的有着已设置提供程序的音信(第3贰行),然后再将其绑定到程序主界面的 ListBox(第二四行) 和 DataGridView (第叁五行) 控件上。那样,那多个控件就会联合浮动了。

金沙注册送58 689      DbHelper db = new
DbHelper();
金沙注册送58 690        DbCommand cmd =
db.GetStoredProcCommond(“t2_insert”);
金沙注册送58 691       
db.AddInParameter(cmd, “@timeticks”, DbType.Int64,
DateTime.Now.Ticks);
金沙注册送58 692       
db.AddOutParameter(cmd, “@outString”, DbType.String, 20);
金沙注册送58 693       
db.AddReturnParameter(cmd, “@returnValue”, DbType.Int32);
金沙注册送58 694
金沙注册送58 695 using (DbDataReader reader
= db.ExecuteReader(cmd))
金沙注册送58 696金沙注册送58 697
金沙注册送58 698{
金沙注册送58 699           
dt.Load(reader);
金沙注册送58 700        }
金沙注册送58 701 string s =
db.GetParameter(cmd, “@outString”).Value as string;//out parameter
金沙注册送58 702 int r =
Convert.ToInt32(db.GetParameter(cmd, “@returnValue”).Value);//return
value
金沙注册送58 703

7)事务的使用.(项目中必要将大旨的数据库操作组合成五个完全的工作流时,代码级的作业是少不了的啊)

肆、在DbHelper编写壹些用于落到实处数据库相关操作的主意,那里就用到了DbProviderFactory类中的方法,以下措施仅供参考,具体请参考其余完整的DbHelp扶助类,

点击“执行”按钮,就会调用 btnSubmit_Click 方法(第3四到68行)。在该措施中:

7)事务的使用.(项目中须要将宗旨的数据库操作组合成一个完全的思想政治工作流时,代码级的政工是不可缺少的啊)

金沙注册送58 704    pubic void DoBusiness()
金沙注册送58 705金沙注册送58 706    金沙注册送58 707{
金沙注册送58 708        using (Trans t = new Trans())
金沙注册送58 709金沙注册送58 710        金沙注册送58 711{
金沙注册送58 712            try
金沙注册送58 713金沙注册送58 714            金沙注册送58 715{
金沙注册送58 716                D1(t);
金沙注册送58 717                throw new Exception();//如若有十分,会回滚滴
金沙注册送58 718                D2(t);
金沙注册送58 719                t.Commit();
金沙注册送58 720            }
金沙注册送58 721            catch
金沙注册送58 722金沙注册送58 723            金沙注册送58 724{
金沙注册送58 725                t.RollBack();
金沙注册送58 726            }
金沙注册送58 727        }
金沙注册送58 728    }
金沙注册送58 729    public void D1(Trans t)
金沙注册送58 730金沙注册送58 731    金沙注册送58 732{
金沙注册送58 733        DbHelper db = new DbHelper();
金沙注册送58 734        DbCommand cmd = db.GetStoredProcCommond(“t2_insert”);
金沙注册送58 735        db.AddInParameter(cmd, “@timeticks”, DbType.Int64, DateTime.Now.Ticks);
金沙注册送58 736        db.AddOutParameter(cmd, “@outString”, DbType.String, 20);
金沙注册送58 737        db.AddReturnParameter(cmd, “@returnValue”, DbType.Int32);
金沙注册送58 738
金沙注册送58 739        if (t == null) db.ExecuteNonQuery(cmd);
金沙注册送58 740        else db.ExecuteNonQuery(cmd,t);
金沙注册送58 741
金沙注册送58 742        string s = db.GetParameter(cmd, “@outString”).Value as string;//out parameter
金沙注册送58 743        int r = Convert.ToInt32(db.GetParameter(cmd, “@returnValue”).Value);//return value
金沙注册送58 744    }
金沙注册送58 745    public void D2(Trans t)
金沙注册送58 746金沙注册送58 747    金沙注册送58 748{
金沙注册送58 749        DbHelper db = new DbHelper();
金沙注册送58 750        DbCommand cmd = db.GetSqlStringCommond(“insert t1 (id)values(‘金沙注册送58 751..’)”);        
金沙注册送58 752        if (t == null) db.ExecuteNonQuery(cmd);
金沙注册送58 753        else db.ExecuteNonQuery(cmd, t);
金沙注册送58 754    }

DbHelper完整代码如下:

  • 使用 DbProviderFactories 类的静态方法 GetFactory 获得一个DbProviderFactory (第50行)。
  • 选拔 DbProviderFactory 类的 CreateConnection 方法创造三个DbConnection (第4一行)。
  • 选拔 DbConnection 类的 Open 方法打开数据库连接(第5四行)。
  • 利用 DbConnection 类的 CreateCommand 方法创设二个 DbCommand
    (第60行)。
  • 只要要履行的 SQL 语句不是 SELECT 语句,则调用 DbCommand 类的
    ExecuteNonQuery 方法执行该 SQL 语句(第陆四行)。
  • 要不,假设程序主界面中的“结构”复选框被入选,就调用
    RunQueryTableStruct 方法获得数据库中的表的构造(第四五行)。
  • 要不,就调用 RunQueryTableData 方法得到数据库中的表的数据(第伍陆行)。

金沙注册送58 755    pubic void
DoBusiness()
金沙注册送58 756金沙注册送58 757
金沙注册送58 758{
金沙注册送58 759 using (Trans t = new
Trans())
金沙注册送58 760金沙注册送58 761
金沙注册送58 762{
金沙注册送58 763 try
金沙注册送58 764金沙注册送58 765
金沙注册送58 766{
金沙注册送58 767                D1(t);
金沙注册送58 768 throw new
Exception();//假若有那多少个,会回滚滴
金沙注册送58 769                D2(t);
金沙注册送58 770               
t.Commit();
金沙注册送58 771            }
金沙注册送58 772 catch
金沙注册送58 773金沙注册送58 774
金沙注册送58 775{
金沙注册送58 776               
t.RollBack();
金沙注册送58 777            }
金沙注册送58 778        }
金沙注册送58 779    }
金沙注册送58 780 public void D1(Trans t)
金沙注册送58 781金沙注册送58 782
金沙注册送58 783{
金沙注册送58 784        DbHelper db = new
DbHelper();
金沙注册送58 785        DbCommand cmd =
db.GetStoredProcCommond(“t2_insert”);
金沙注册送58 786       
db.AddInParameter(cmd, “@timeticks”, DbType.Int64,
DateTime.Now.Ticks);
金沙注册送58 787       
db.AddOutParameter(cmd, “@outString”, DbType.String, 20);
金沙注册送58 788       
db.AddReturnParameter(cmd, “@returnValue”, DbType.Int32);
金沙注册送58 789
金沙注册送58 790 if (t == null)
db.ExecuteNonQuery(cmd);
金沙注册送58 791 else
db.ExecuteNonQuery(cmd,t);
金沙注册送58 792
金沙注册送58 793 string s =
db.GetParameter(cmd, “@outString”).Value as string;//out parameter
金沙注册送58 794 int r =
Convert.ToInt32(db.GetParameter(cmd, “@returnValue”).Value);//return
value
金沙注册送58 795    }
金沙注册送58 796 public void D2(Trans t)
金沙注册送58 797金沙注册送58 798
金沙注册送58 799{
金沙注册送58 800        DbHelper db = new
DbHelper();
金沙注册送58 801        DbCommand cmd =
db.GetSqlStringCommond(“insert t1
(id)values(‘金沙注册送58 802..’)”);       
金沙注册送58 803 if (t == null)
db.ExecuteNonQuery(cmd);
金沙注册送58 804 else
db.ExecuteNonQuery(cmd, t);
金沙注册送58 805    }

以上大家好像未有点名数据库连接字符串,大家若是看下DbHelper的代码,就知道要选用它必须在config中安插五个参数,如下:

//帮助类的基类(抽象类)
    public abstract class DbHelper
    {
        public DbHelper(string connectionString)
        {
            ConnectionString = connectionString;
        }

        public abstract DbProviderFactory DbProviderFactory {  get; } 

        public string ConnectionString { get; }

        //以下实现的帮助类方法,仅供该例子使用,具体请参照其他完整的DbHelp帮助类
        private void ThrowExceptionIfLengthNotEqual(string[] sqls, params DbParameter[][] parameters)
        {
            if (parameters.GetLength(0) != 0 && sqls.Length != parameters.GetLength(0)) throw new ArgumentException($"一维数组{nameof(sqls)}的长度与二维数组{nameof(parameters)}长度的第一维长度不一致");
        }

        private T[] Execute<T>(string[] sqls, CommandType commandType = CommandType.Text, ExecuteMode executeMode = ExecuteMode.NonQuery, params DbParameter[][] parameters)
        {
            ThrowExceptionIfLengthNotEqual(sqls, parameters);
            if(executeMode == ExecuteMode.NonQuery && typeof(T) != typeof(int)) throw new InvalidCastException("使用NonQuery模式时,必须将类型T指定为int");
            using (DbConnection connection = DbProviderFactory.CreateConnection())
            using (DbCommand command = DbProviderFactory.CreateCommand())
            {
                connection.ConnectionString = ConnectionString;
                connection.Open();
                command.Connection = connection;
                command.CommandType = commandType;
                DbTransaction transaction = connection.BeginTransaction();
                command.Transaction = transaction;
                try
                {
                    List<T> resultList = new List<T>();
                    for (int i = 0; i < sqls.Length; i++)
                    {
                        command.CommandText = sqls[i];
                        if (parameters.GetLength(0) != 0)
                        {
                            command.Parameters.Clear();
                            command.Parameters.AddRange(parameters[i]);
                        }
                        object result = null;
                        switch (executeMode)
                        {
                            case ExecuteMode.NonQuery:
                                result = command.ExecuteNonQuery(); break;
                            case ExecuteMode.Scalar:
                                result = command.ExecuteScalar(); break;
                            default: throw new NotImplementedException();
                        }
                        resultList.Add((T)Convert.ChangeType(result, typeof(T)));
                    }
                    transaction.Commit();
                    return resultList.ToArray();
                }
                catch
                {
                    transaction.Rollback();
                    throw;
                }
            }
        }

        public int ExecuteNonQuery(string sql, params DbParameter[] parameter) => ExecuteNonQuery(new string[] { sql }, new DbParameter[][] { parameter })[0];

        public int[] ExecuteNonQuery(string[] sqls, params DbParameter[][] parameters)=> Execute<int>(sqls, CommandType.Text, ExecuteMode.NonQuery,parameters);

        public int ExecuteNonQueryWithProc(string sql, params DbParameter[] parameter) => ExecuteNonQueryWithProc(new string[] { sql },  new DbParameter[][] { parameter })[0];

        public int[] ExecuteNonQueryWithProc(string[] sqls, params DbParameter[][] parameters) => Execute<int>(sqls, CommandType.StoredProcedure, ExecuteMode.NonQuery, parameters);

        public T ExecuteScalar<T>(string sql, params DbParameter[] parameter) => ExecuteNonQuery<T>(new string[] { sql }, new DbParameter[][] { parameter })[0];

        public T[] ExecuteNonQuery<T>(string[] sqls, params DbParameter[][] parameters) => Execute<T>(sqls, CommandType.Text,ExecuteMode.Scalar, parameters);

        public T ExecuteScalarWithProc<T>(string sql, params DbParameter[] parameter) => ExecuteNonQuery<T>(new string[] { sql }, new DbParameter[][] { parameter })[0];

        public T[] ExecuteNonQueryWithProc<T>(string[] sqls, params DbParameter[][] parameters) => Execute<T>(sqls, CommandType.StoredProcedure, ExecuteMode.Scalar, parameters);

        enum ExecuteMode
        {
            NonQuery,Scalar
        }

        private DataTable[] Fill(string[] selectSqls, CommandType commandType = CommandType.Text, params DbParameter[][] parameters)
        {
            ThrowExceptionIfLengthNotEqual(selectSqls, parameters);
            using (DbConnection connection = DbProviderFactory.CreateConnection())
            using (DbDataAdapter adapter = DbProviderFactory.CreateDataAdapter())
            using (DbCommand command = DbProviderFactory.CreateCommand())
            {
                connection.ConnectionString = ConnectionString;
                connection.Open();
                command.Connection = connection;
                command.CommandType = commandType;
                adapter.SelectCommand = command;
                List<DataTable> resultList = new List<DataTable>();
                for (int i = 0; i < selectSqls.Length; i++)
                {
                    command.CommandText = selectSqls[i];
                    if (parameters.GetLength(0) != 0)
                    {
                        command.Parameters.Clear();
                        command.Parameters.AddRange(parameters[i]);
                    }
                    DataTable table = new DataTable();
                    adapter.Fill(table);
                    resultList.Add(table);
                }
                return resultList.ToArray();
            }
        }

        public DataTable Fill(string selectSql, params DbParameter[] parameter) => Fill(new string[] { selectSql }, new DbParameter[][] { parameter })[0];

        public DataTable[] Fill(string[] selectSqls, params DbParameter[][] parameters) => Fill(selectSqls, CommandType.Text, parameters);

        public DataTable FillWithProc(string selectSql, params DbParameter[] parameter) => FillWithProc(new string[] { selectSql }, new DbParameter[][] { parameter })[0];

        public DataTable[] FillWithProc(string[] selectSqls, params DbParameter[][] parameters) => Fill(selectSqls, CommandType.StoredProcedure, parameters);
    }

第90到7陆行的 RunQueryTableStruct 方法应用 DbCommand 类的 ExecuteReader
方法(使用 CommandBehavior.KeyInfo 参数)获得3个 DbDataReader
(第七二行),然后调用 DbDataReader 类的 GetSchemaTable
方法来赢得数据库中的表的各列的元数据(第十四行)。

如上大家好像从没点名数据库连接字符串,大家只要看下DbHelper的代码,就知道要动用它必须在config中配置七个参数,如下:

金沙注册送58 806    <appSettings>
金沙注册送58 807        <add key=”DbHelperProvider” value=”System.Data.SqlClient”/>
金沙注册送58 808        <add key=”DbHelperConnectionString” value=”Data Source=(local);Initial Catalog=DbHelperTest;Persist Security Info=True;User ID=sa;Password=sa”/>
金沙注册送58 809    </appSettings>

三、达成具体的数据库帮忙类

第8八到八五行的 RunQueryTableData 方法运用 DbProviderFactory 类的
CreateDataAdapter 方法创造贰个 DbDataAdapter (第玖0行),然后选用DbDataAdapter 类的 Fill 方法来填充 DataSet (第七3行),最终回来该 DataSet
的 Tables 属性中的第三个 DataTabe 的 DefaultView (第九四行)。

金沙注册送58 810 <appSettings>
金沙注册送58 811 <add
key=”DbHelperProvider” value=”System.Data.SqlClient”/>
金沙注册送58 812 <add
key=”DbHelperConnectionString” value=”Data Source=(local);Initial
Catalog=DbHelperTest;Persist Security Info=True;User
ID=sa;Password=sa”/>
金沙注册送58 813 </appSettings>

实质上,DbHelper须要的仅仅是四个字符串,你能够本身修改,作成加密什么的…

1、达成Sql
Server的协助类,具体方法:只要重写DbHelper类的DbProviderFactory属性并在构造函数为其赋值即可,别的的数据库扶助类亦是这么,

该程序中的静态类 Pub 类提供部分推推搡搡的静态方法:

实际,DbHelper供给的独自是多个字符串,你能够协调修改,作成加密什么的…
好了,就这么,DbHelper的代码是相当简单和晶莹剔透的,只是在ado.net上做了好几小包装,改变了弹指间使用它的程序员的编码格局,去除掉1些相比”
物理级”的编制程序概念,如connection的open和close之类的,使程序员更在意于工作逻辑代码的编纂,少死掉点脑细胞,此外,统一了多少操作层的数目操作代码的品格和格式,维护起来很方便的撒~~~
另:以上代码我们能够自由使用,
不必要给自家版权费的啦,嘿嘿.假如大家发现有何BUG,或然有越来越好的多少操作类的达成情势,请联系自个儿哦.

好了,就像此,DbHelper的代码是极度不难和透明的,只是在ado.net上做了有些小包装,改变了瞬间选择它的程序员的编码格局,去除掉1些比较”物理级”的编制程序概念,如connection的open和close之类的,使程序员更在意于业务逻辑代码的编辑撰写,少死掉点脑细胞,其余,统一了多少操作层的多寡操作代码的风格和格式,维护起来很便宜的撒~~~

代码如下:

using System;
using System.Text;
using System.Windows.Forms;
using System.Reflection;

namespace Skyiv.Ben.DbTools
{
  static class Pub
  {
    public static string GetMessage(Exception ex)
    {
      var sb = new StringBuilder();
      for (sb.Append("错误: "); ex != null; ex = ex.InnerException)
      {
        sb.AppendFormat("[{0}]: ", ex.GetType());
        sb.AppendLine(ex.Message);
      }
      return sb.ToString();
    }

    public static void AppendLine(this TextBoxBase tbx, string fmt, params object[] args)
    {
      tbx.AppendText(string.Format(fmt, args) + Environment.NewLine);
    }

    public static Version GetClientVersion(string name)
    {
      foreach (var a in AppDomain.CurrentDomain.GetAssemblies()) if (name == a.GetName().Name) return a.GetName().Version;
      return null;
    }
  }
}

另:以上代码我们能够随便行使,
不供给给自己版权费的呐,嘿嘿.假设我们发现有如何BUG,或然有更加好的多少操作类的落成格局,请联系作者哦.

    //用于Sql Server的帮助类
    public class SqlClientHelper : DbHelper
    {
        public SqlClientHelper(string connectionString) : base(connectionString)
        {
            this.DbProviderFactory = SqlClientFactory.Instance;
        }
        public override DbProviderFactory DbProviderFactory { get; }
    }

最终,完整的源程序能够到
页面下载。

2、参照以上,落成SQLite帮忙类如下:

也足以选择 hg clone 命令下载。

    //用于SQLite的帮助类
    public class SQLiteHelper : DbHelper
    {
        public SQLiteHelper(string connectionString) : base(connectionString)
        {
            DbProviderFactory = SQLiteFactory.Instance;
        }
        public override DbProviderFactory DbProviderFactory  { get; }
    }

关于 hg ,请参阅 Mercurial
备忘录。

三、其余数据库的辅助类,正如以上所说的,只要重写DbHelper类的DbProviderFactory属性并在构造函数为其赋值即可。

肆、示例演示

使用前,必须引用了System.Data.SQLite,具体请参考一下稿子:

使用C#创办SQLite控制台应用程序

编辑的客户端代码,如下:

    class Program
    {
        //客户端调用
        static void Main(string[] args)
        {
            string fileName = "Test.db";
            if (File.Exists(fileName)) File.Delete(fileName);
            SQLiteConnection.CreateFile(fileName);
            SQLiteHelper helper = new SQLiteHelper($"Data Source = {fileName}");
            helper.ExecuteNonQuery("CREATE TABLE IF NOT EXISTS Info(ID integer PRIMARY KEY AUTOINCREMENT, Guid text)");
            List<string> sqlList = new List<string>();
            for (int i = 0; i < 1000; i++)
            {
                sqlList.Add($"INSERT INTO Info VALUES(null,'{Guid.NewGuid()}')");
            }
            helper.ExecuteNonQuery(sqlList.ToArray());
            DataTable table = helper.Fill("SELECT * FROM Info");
            table.Rows.Cast<DataRow>().ToList().ForEach(x => Console.WriteLine($"{x[0]}\t{x[1]}"));
            Console.ReadKey();
        }
    }

出口的结果如下:

金沙注册送58 814

5、完整代码如下:

金沙注册送58 815金沙注册送58 816

using System;
using System.Linq;
using System.Collections.Generic;
using System.Data;
using System.Data.Common;
using System.Data.SqlClient;
using System.Data.SQLite;
using System.IO;

namespace ConsoleApp
{
    class Program
    {
        //客户端调用
        static void Main(string[] args)
        {
            string fileName = "Test.db";
            if (File.Exists(fileName)) File.Delete(fileName);
            SQLiteConnection.CreateFile(fileName);
            SQLiteHelper helper = new SQLiteHelper($"Data Source = {fileName}");
            helper.ExecuteNonQuery("CREATE TABLE IF NOT EXISTS Info(ID integer PRIMARY KEY AUTOINCREMENT, Guid text)");
            List<string> sqlList = new List<string>();
            for (int i = 0; i < 1000; i++)
            {
                sqlList.Add($"INSERT INTO Info VALUES(null,'{Guid.NewGuid()}')");
            }
            helper.ExecuteNonQuery(sqlList.ToArray());
            DataTable table = helper.Fill("SELECT * FROM Info");
            table.Rows.Cast<DataRow>().ToList().ForEach(x => Console.WriteLine($"{x[0]}\t{x[1]}"));
            Console.ReadKey();
        }
    }

    //用于Sql Server的帮助类
    public class SqlClientHelper : DbHelper
    {
        public SqlClientHelper(string connectionString) : base(connectionString)
        {
            this.DbProviderFactory = SqlClientFactory.Instance;
        }
        public override DbProviderFactory DbProviderFactory { get; }
    }

    //用于SQLite的帮助类
    public class SQLiteHelper : DbHelper
    {
        public SQLiteHelper(string connectionString) : base(connectionString)
        {
            DbProviderFactory = SQLiteFactory.Instance;
        }
        public override DbProviderFactory DbProviderFactory  { get; }
    }

    //--------------------------------------------------------------------------------
    //其他数据库的帮助类,只要重写DbHelper类的DbProviderFactory属性并在构造函数为其赋值即可
    //--------------------------------------------------------------------------------

    //帮助类的基类(抽象类)
    public abstract class DbHelper
    {
        public DbHelper(string connectionString)
        {
            ConnectionString = connectionString;
        }

        public abstract DbProviderFactory DbProviderFactory {  get; } 

        public string ConnectionString { get; }

        //以下实现的帮助类方法,仅供该例子使用,具体请参照其他完整的DbHelp帮助类
        private void ThrowExceptionIfLengthNotEqual(string[] sqls, params DbParameter[][] parameters)
        {
            if (parameters.GetLength(0) != 0 && sqls.Length != parameters.GetLength(0)) throw new ArgumentException($"一维数组{nameof(sqls)}的长度与二维数组{nameof(parameters)}长度的第一维长度不一致");
        }

        private T[] Execute<T>(string[] sqls, CommandType commandType = CommandType.Text, ExecuteMode executeMode = ExecuteMode.NonQuery, params DbParameter[][] parameters)
        {
            ThrowExceptionIfLengthNotEqual(sqls, parameters);
            if(executeMode == ExecuteMode.NonQuery && typeof(T) != typeof(int)) throw new InvalidCastException("使用NonQuery模式时,必须将类型T指定为int");
            using (DbConnection connection = DbProviderFactory.CreateConnection())
            using (DbCommand command = DbProviderFactory.CreateCommand())
            {
                connection.ConnectionString = ConnectionString;
                connection.Open();
                command.Connection = connection;
                command.CommandType = commandType;
                DbTransaction transaction = connection.BeginTransaction();
                command.Transaction = transaction;
                try
                {
                    List<T> resultList = new List<T>();
                    for (int i = 0; i < sqls.Length; i++)
                    {
                        command.CommandText = sqls[i];
                        if (parameters.GetLength(0) != 0)
                        {
                            command.Parameters.Clear();
                            command.Parameters.AddRange(parameters[i]);
                        }
                        object result = null;
                        switch (executeMode)
                        {
                            case ExecuteMode.NonQuery:
                                result = command.ExecuteNonQuery(); break;
                            case ExecuteMode.Scalar:
                                result = command.ExecuteScalar(); break;
                            default: throw new NotImplementedException();
                        }
                        resultList.Add((T)Convert.ChangeType(result, typeof(T)));
                    }
                    transaction.Commit();
                    return resultList.ToArray();
                }
                catch
                {
                    transaction.Rollback();
                    throw;
                }
            }
        }

        public int ExecuteNonQuery(string sql, params DbParameter[] parameter) => ExecuteNonQuery(new string[] { sql }, new DbParameter[][] { parameter })[0];

        public int[] ExecuteNonQuery(string[] sqls, params DbParameter[][] parameters)=> Execute<int>(sqls, CommandType.Text, ExecuteMode.NonQuery,parameters);

        public int ExecuteNonQueryWithProc(string sql, params DbParameter[] parameter) => ExecuteNonQueryWithProc(new string[] { sql },  new DbParameter[][] { parameter })[0];

        public int[] ExecuteNonQueryWithProc(string[] sqls, params DbParameter[][] parameters) => Execute<int>(sqls, CommandType.StoredProcedure, ExecuteMode.NonQuery, parameters);

        public T ExecuteScalar<T>(string sql, params DbParameter[] parameter) => ExecuteNonQuery<T>(new string[] { sql }, new DbParameter[][] { parameter })[0];

        public T[] ExecuteNonQuery<T>(string[] sqls, params DbParameter[][] parameters) => Execute<T>(sqls, CommandType.Text,ExecuteMode.Scalar, parameters);

        public T ExecuteScalarWithProc<T>(string sql, params DbParameter[] parameter) => ExecuteNonQuery<T>(new string[] { sql }, new DbParameter[][] { parameter })[0];

        public T[] ExecuteNonQueryWithProc<T>(string[] sqls, params DbParameter[][] parameters) => Execute<T>(sqls, CommandType.StoredProcedure, ExecuteMode.Scalar, parameters);

        enum ExecuteMode
        {
            NonQuery,Scalar
        }

        private DataTable[] Fill(string[] selectSqls, CommandType commandType = CommandType.Text, params DbParameter[][] parameters)
        {
            ThrowExceptionIfLengthNotEqual(selectSqls, parameters);
            using (DbConnection connection = DbProviderFactory.CreateConnection())
            using (DbDataAdapter adapter = DbProviderFactory.CreateDataAdapter())
            using (DbCommand command = DbProviderFactory.CreateCommand())
            {
                connection.ConnectionString = ConnectionString;
                connection.Open();
                command.Connection = connection;
                command.CommandType = commandType;
                adapter.SelectCommand = command;
                List<DataTable> resultList = new List<DataTable>();
                for (int i = 0; i < selectSqls.Length; i++)
                {
                    command.CommandText = selectSqls[i];
                    if (parameters.GetLength(0) != 0)
                    {
                        command.Parameters.Clear();
                        command.Parameters.AddRange(parameters[i]);
                    }
                    DataTable table = new DataTable();
                    adapter.Fill(table);
                    resultList.Add(table);
                }
                return resultList.ToArray();
            }
        }

        public DataTable Fill(string selectSql, params DbParameter[] parameter) => Fill(new string[] { selectSql }, new DbParameter[][] { parameter })[0];

        public DataTable[] Fill(string[] selectSqls, params DbParameter[][] parameters) => Fill(selectSqls, CommandType.Text, parameters);

        public DataTable FillWithProc(string selectSql, params DbParameter[] parameter) => FillWithProc(new string[] { selectSql }, new DbParameter[][] { parameter })[0];

        public DataTable[] FillWithProc(string[] selectSqls, params DbParameter[][] parameters) => Fill(selectSqls, CommandType.StoredProcedure, parameters);
    }
}

View Code

 

相关文章

网站地图xml地图