落成其余数据库类型的DbHelper支持类,数据库小工具整合版

本作品为原创内容,如需转发,请注解小编及出处,多谢!

自家在200伍年四月二日写的1篇小说“数据库小工具(C#)”中提到:

 

      其实,微软的公司库中有八个要命科学的数额操作类了.可是,不少商家(起码笔者遇上的多少个…),对一些”封装”了些什么的事物不太敢用,即便本身推荐过微软的公司库框架了…不过照旧要”评估”…一评就是多少个月…而且,一些商行部分根本便是裸ado.net开发,恐怕本身包装的数据库操作类万分别扭,很不好用.
      那里本身给大家共享二个自个儿参考集团库中的数据操作组件编码风格写的数据库操作类,对利用它的程序员来说,编码是很舒服滴(起码小编以为很好撒).以下是代码,非常粗略的,没有做任何多余的卷入,只是改变了ADO.NET的编码步骤,方便了实际开发数据库操作代码的程序员.


在编排有关数据库方面包车型地铁C#程序时,平常须求明白数据库的表中各字段的以下消息:
一.
用以OracleParameter(或SqlParameter,…)中的字段和属性的数据库特定的数据类型。

实则,微软的集团库中有3个相当不易的多寡操作类了.不过,不少专营商(起码我遭受的几个…),对部分”封装”了些什么的事物不太敢用,纵然自个儿引入过微软的集团库框架了…不过照旧要”评估”…一评正是多少个月…而且,壹些卖家部分根本便是裸ado.net开发,可能自个儿包装的数据库操作类分外别扭,很不佳用.
     
这里自身给大家共享二个自作者参考公司库中的数据操作组件编码风格写的数据库操作类,对接纳它的程序员来说,编码是很舒服滴(起码笔者以为很好撒).以下是代码,相当粗略的,未有做其他多余的包裹,只是改变了ADO.NET的编码步骤,方便了切实开发数据库操作代码的程序员.

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

 

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

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

那么如何运用它吗?下边笔者付出一些着力的应用示例,基本能满意你超越50%的数据库操作需求了.
1)直接实施sql语句

1、在System.Data.Common命名空间下,存在那样的贰个类:

当即,对种种不相同的数据库是独家达成这一个“数据库小工具”的。

那正是说什么样运用它吗?上面小编付诸1些中坚的使用示例,基本能满足你大多数的数据库操作要求了.
1)直接执行sql语句

美高梅开户网址 623        DbHelper db = new DbHelper();
美高梅开户网址 624        DbCommand cmd = db.GetSqlStringCommond(“insert t1 (id)values(‘haha’)”);
美高梅开户网址 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);
    }

近期,让大家将这一个独立的“小工具”整合在一块儿啊。

美高梅开户网址 626        DbHelper db = new
DbHelper();
美高梅开户网址 627        DbCommand cmd =
db.GetSqlStringCommond(“insert t1 (id)values(‘haha’)”);
美高梅开户网址 628       
db.ExecuteNonQuery(cmd);

2)执行存储进度

大家能够见到,在此类中,有成都百货上千用以创建数据库相关对象的档次,如DbConnection,DbCommand,DbDataAdapter等。

美高梅开户网址 629

2)执行存款和储蓄进程

美高梅开户网址 630        DbHelper db = new DbHelper();
美高梅开户网址 631        DbCommand cmd = db.GetStoredProcCommond(“t1_insert”);
美高梅开户网址 632        db.AddInParameter(cmd, “@id”, DbType.String, “heihei”);
美高梅开户网址 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
等数据库都早已结合在同一个先后中了。

美高梅开户网址 634        DbHelper db = new
DbHelper();
美高梅开户网址 635        DbCommand cmd =
db.GetStoredProcCommond(“t1_insert”);
美高梅开户网址 636       
db.AddInParameter(cmd, “@id”, DbType.String, “heihei”);
美高梅开户网址 637       
db.ExecuteNonQuery(cmd);

3)返回DataSet

之所以,大家能够动用DbProviderFactory来创立我们想要的、可完毕任何数据库的DbHelper。

美高梅开户网址 638

3)返回DataSet

美高梅开户网址 639        DbHelper db = new DbHelper();
美高梅开户网址 640        DbCommand cmd = db.GetSqlStringCommond(“select * from t1”);
美高梅开户网址 641        DataSet ds = db.ExecuteDataSet(cmd);

贰、达成核心的DbHelper支持类

上海体育场所体现执行一条 SQL 语句后的结果。

美高梅开户网址 642        DbHelper db = new
DbHelper();
美高梅开户网址 643        DbCommand cmd =
db.GetSqlStringCommond(“select * from t1”);
美高梅开户网址 644美高梅开户网址 ,        DataSet ds =
db.ExecuteDataSet(cmd);

4)返回DataTable

1、大家将DbHelper定义为抽象类,并在类中提供三个虚无可读属性,名为DbProviderFactory,重返类型为DbProviderFactory(注:名称与再次来到类型能够为同样,也得以不1致),

美高梅开户网址 645

4)返回DataTable

美高梅开户网址 646        DbHelper db = new DbHelper();
美高梅开户网址 647        DbCommand cmd = db.GetSqlStringCommond(“t1_findall”);
美高梅开户网址 648        DataTable dt = db.ExecuteDataTable(cmd);

二、我们采用在该抽象类达成的子类中重写DbProviderFactory方法,并在子类的构造函数中为该属性赋值,该值正是一度落到实处了切实数据库类型的DbProviderFactory。

上航海用体育场合显示出数据库中的表的结构。

美高梅开户网址 649        DbHelper db = new
DbHelper();
美高梅开户网址 650        DbCommand cmd =
db.GetSqlStringCommond(“t1_findall”);
美高梅开户网址 651        DataTable dt =
db.ExecuteDataTable(cmd);

5)输入参数/输出参数/再次回到值的选拔(相比较关键哦)

概念的代码参考如下:

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

伍)输入参数/输出参数/重回值的采用(相比主要哦)

美高梅开户网址 652        DbHelper db = new DbHelper();
美高梅开户网址 653        DbCommand cmd = db.GetStoredProcCommond(“t2_insert”);
美高梅开户网址 654        db.AddInParameter(cmd, “@timeticks”, DbType.Int64, DateTime.Now.Ticks);
美高梅开户网址 655        db.AddOutParameter(cmd, “@outString”, DbType.String, 20);
美高梅开户网址 656        db.AddReturnParameter(cmd, “@returnValue”, DbType.Int32);
美高梅开户网址 657
美高梅开户网址 658        db.ExecuteNonQuery(cmd);
美高梅开户网址 659
美高梅开户网址 660        string s = db.GetParameter(cmd, “@outString”).Value as string;//out parameter
美高梅开户网址 661        int r = Convert.ToInt32(db.GetParameter(cmd, “@returnValue”).Value);//return value
美高梅开户网址 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");
    }
  }
}

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

6)DataReader使用

三、我们为该抽象类编写2个构造函数,传进去的参数为连日来字符串,并将其储存在可读的ConnectionString字段里,代码如下:

本条顺序首要运用 System.Data.Common 命名空间中的类来举办工作 。

6)DataReader使用

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

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

在 MainForm_Load 方法(第3陆到3二行)中央银行使 DbProviderFactories 的静态方法
GetFactoryClasses 获得在本机中贯彻 DbProviderFactories
的装有已安装提供程序的消息(第2二行),然后再将其绑定到程序主界面包车型客车 ListBox(第一4行) 和 DataGridView (第1五行) 控件上。那样,那八个控件就会联动了。

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

7)事务的使用.(项目中需求将主旨的数据库操作组合成一个完好无损的政工流时,代码级的工作是少不了的啊)

四、在DbHelper编写1些用于落到实处数据库相关操作的章程,这里就用到了DbProviderFactory类中的方法,以下办法仅供参考,具体请参见其余完整的DbHelp帮忙类,

点击“执行”按钮,就会调用 btnSubmit_Click 方法(第二四到6捌行)。在该方法中:

7)事务的使用.(项目中要求将核心的数据库操作组合成2个完好的事务流时,代码级的事务是必需的哦)

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

DbHelper完整代码如下:

  • 应用 DbProviderFactories 类的静态方法 GetFactory 获得二个DbProviderFactory (第四0行)。
  • 运用 DbProviderFactory 类的 CreateConnection 方法创立三个DbConnection (第五一行)。
  • 选用 DbConnection 类的 Open 方法打开数据库连接(第六4行)。
  • 利用 DbConnection 类的 CreateCommand 方法创制1个 DbCommand
    (第四0行)。
  • 壹经要实施的 SQL 语句不是 SELECT 语句,则调用 DbCommand 类的
    ExecuteNonQuery 方法执行该 SQL 语句(第四4行)。
  • 要不然,假如程序主界面中的“结构”复选框被入选,就调用
    RunQueryTableStruct 方法取得数据库中的表的结构(第肆伍行)。
  • 要不,就调用 RunQueryTableData 方法取得数据库中的表的数据(第四陆行)。

美高梅开户网址 755    pubic void
DoBusiness()
美高梅开户网址 756美高梅开户网址 757
美高梅开户网址 758{
美高梅开户网址 759 using (Trans t = new
Trans())
美高梅开户网址 760美高梅开户网址 761
美高梅开户网址 762{
美高梅开户网址 763 try
美高梅开户网址 764美高梅开户网址 765
美高梅开户网址 766{
美高梅开户网址 767                D1(t);
美高梅开户网址 768 throw new
Exception();//要是有格外,会回滚滴
美高梅开户网址 769                D2(t);
美高梅开户网址 770               
t.Commit();
美高梅开户网址 771            }
美高梅开户网址 772 catch
美高梅开户网址 773美高梅开户网址 774
美高梅开户网址 775{
美高梅开户网址 776               
t.RollBack();
美高梅开户网址 777            }
美高梅开户网址 778        }
美高梅开户网址 779    }
美高梅开户网址 780 public void D1(Trans t)
美高梅开户网址 781美高梅开户网址 782
美高梅开户网址 783{
美高梅开户网址 784        DbHelper db = new
DbHelper();
美高梅开户网址 785        DbCommand cmd =
db.GetStoredProcCommond(“t2_insert”);
美高梅开户网址 786       
db.AddInParameter(cmd, “@timeticks”, DbType.Int64,
DateTime.Now.Ticks);
美高梅开户网址 787       
db.AddOutParameter(cmd, “@outString”, DbType.String, 20);
美高梅开户网址 788       
db.AddReturnParameter(cmd, “@returnValue”, DbType.Int32);
美高梅开户网址 789
美高梅开户网址 790 if (t == null)
db.ExecuteNonQuery(cmd);
美高梅开户网址 791 else
db.ExecuteNonQuery(cmd,t);
美高梅开户网址 792
美高梅开户网址 793 string s =
db.GetParameter(cmd, “@outString”).Value as string;//out parameter
美高梅开户网址 794 int r =
Convert.ToInt32(db.GetParameter(cmd, “@returnValue”).Value);//return
value
美高梅开户网址 795    }
美高梅开户网址 796 public void D2(Trans t)
美高梅开户网址 797美高梅开户网址 798
美高梅开户网址 799{
美高梅开户网址 800        DbHelper db = new
DbHelper();
美高梅开户网址 801        DbCommand cmd =
db.GetSqlStringCommond(“insert t1
(id)values(‘美高梅开户网址 802..’)”);       
美高梅开户网址 803 if (t == null)
db.ExecuteNonQuery(cmd);
美高梅开户网址 804 else
db.ExecuteNonQuery(cmd, t);
美高梅开户网址 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);
    }

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

如上大家好像从没点名数据库连接字符串,大家假使看下DbHelper的代码,就通晓要利用它必须在config中配置五个参数,如下:

美高梅开户网址 806    <appSettings>
美高梅开户网址 807        <add key=”DbHelperProvider” value=”System.Data.SqlClient”/>
美高梅开户网址 808        <add key=”DbHelperConnectionString” value=”Data Source=(local);Initial Catalog=DbHelperTest;Persist Security Info=True;User ID=sa;Password=sa”/>
美高梅开户网址 809    </appSettings>

叁、完结具体的数据库匡助类

第九8到捌五行的 RunQueryTableData 方法运用 DbProviderFactory 类的
CreateDataAdapter 方法成立一个 DbData艾达pter (第十0行),然后利用
DbData艾达pter 类的 Fill 方法来填充 DataSet (第九三行),最终回到该 DataSet
的 Tables 属性中的第多少个 DataTabe 的 DefaultView (第九4行)。

美高梅开户网址 810 <appSettings>
美高梅开户网址 811 <add
key=”DbHelperProvider” value=”System.Data.SqlClient”/>
美高梅开户网址 812 <add
key=”DbHelperConnectionString” value=”Data Source=(local);Initial
Catalog=DbHelperTest;Persist Security Info=True;User
ID=sa;Password=sa”/>
美高梅开户网址 813 </appSettings>

实质上,DbHelper必要的单独是多个字符串,你能够本人修改,作成加密什么的…

一、实现Sql
Server的帮忙类,具体方法:只要重写DbHelper类的DbProviderFactory属性并在构造函数为其赋值即可,别的的数据库补助类亦是这么,

该程序中的静态类 Pub 类提供1些援助的静态方法:

实在,DbHelper须要的唯有是四个字符串,你能够本身修改,作成加密什么的…
好了,就像是此,DbHelper的代码是卓殊不难和透明的,只是在ado.net上做了一点小包装,改变了一下应用它的程序员的编码形式,去除掉一些比较”
物理级”的编制程序概念,如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;
    }
  }
}

另:以上代码大家能够Infiniti制动用,
不需求给自个儿版权费的呀,嘿嘿.假如大家发现有何样BUG,只怕有更加好的多少操作类的完成格局,请联系本人哦.

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

末尾,完整的源程序能够到
页面下载。

二、参照以上,达成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属性并在构造函数为其赋值即可。

4、示例演示

选择前,必须引用了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();
        }
    }

输出的结果如下:

美高梅开户网址 814

伍、完整代码如下:

美高梅开户网址 815美高梅开户网址 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地图