├── Database ├── DbUpdate.cs ├── DbInsert.cs ├── Orm.cs ├── DbPager.cs └── DbHelper.cs └── README.md /Database/DbUpdate.cs: -------------------------------------------------------------------------------- 1 | using System; 2 | using System.Collections.Generic; 3 | using System.Text; 4 | using System.Data.Common; 5 | 6 | namespace Cat.Database 7 | { 8 | public class DbUpdate 9 | { 10 | private StringBuilder sb = new StringBuilder(); 11 | private StringBuilder where = new StringBuilder(); 12 | private List pars = new List(); 13 | private DbHelper dataBase; 14 | 15 | public DbUpdate() 16 | { 17 | dataBase = new DbHelper(); 18 | } 19 | 20 | public DbUpdate(DbHelper db) 21 | { 22 | dataBase = db; 23 | } 24 | 25 | public void Set(string name, object value) 26 | { 27 | sb.Append(",[" + name + "]=@" + name); 28 | DbParameter param = dataBase.Factory.CreateParameter(); 29 | param.ParameterName = "@" + name; 30 | param.Value = value; 31 | pars.Add(param); 32 | } 33 | 34 | public int Execute(string tableName) 35 | { 36 | return dataBase.ExecuteNonQuery("UPDATE [" + tableName + "] SET " + sb.ToString().TrimStart(','), pars.ToArray()); 37 | } 38 | 39 | public int Execute(string tableName, string appendSql, params DbParameter[] parameters) 40 | { 41 | pars.AddRange(parameters); 42 | return dataBase.ExecuteNonQuery("UPDATE [" + tableName + "] SET " + sb.ToString().TrimStart(',') + " " + appendSql, pars.ToArray()); 43 | } 44 | } 45 | } 46 | -------------------------------------------------------------------------------- /Database/DbInsert.cs: -------------------------------------------------------------------------------- 1 | using System; 2 | using System.Collections.Generic; 3 | using System.Text; 4 | using System.Data.Common; 5 | 6 | namespace Cat.Database 7 | { 8 | public class DbInsert 9 | { 10 | private StringBuilder field = new StringBuilder(); 11 | private StringBuilder values = new StringBuilder(); 12 | private List pars = new List(); 13 | private DbHelper dataBase; 14 | 15 | public DbInsert() 16 | { 17 | dataBase = new DbHelper(); 18 | } 19 | 20 | public DbInsert(DbHelper db) 21 | { 22 | dataBase = db; 23 | } 24 | 25 | public void Add(string name, object value) 26 | { 27 | field.Append(",[" + name + "]"); 28 | values.Append("," + "@" + name); 29 | DbParameter param = dataBase.Factory.CreateParameter(); 30 | param.ParameterName = "@" + name; 31 | param.Value = value; 32 | pars.Add(param); 33 | } 34 | 35 | public int Execute(string tableName) 36 | { 37 | return dataBase.ExecuteNonQuery("INSERT INTO [" + tableName + "](" + field.ToString().TrimStart(',') + ") VALUES(" + values.ToString().TrimStart(',') + ")", pars.ToArray()); 38 | } 39 | 40 | public object ExecuteIdentity(string tableName) 41 | { 42 | bool ist = dataBase.IsBeginTransaction; 43 | if (!ist) 44 | { 45 | dataBase.BeginTransaction(); 46 | } 47 | try 48 | { 49 | Execute(tableName); 50 | return dataBase.ExecuteScalar("SELECT @@IDENTITY"); 51 | } 52 | catch 53 | { 54 | dataBase.RollbackTransaction(); 55 | throw; 56 | } 57 | finally 58 | { 59 | if (!ist) 60 | { 61 | dataBase.CommitTransaction(); 62 | } 63 | } 64 | } 65 | } 66 | } 67 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # DbHelper 2 | 3 | ```c# 4 | using Cat.Database; 5 | ``` 6 | 7 | ## web.config 8 | 9 | ```xml 10 | 11 | 12 | 13 | 14 | ``` 15 | 16 | ## Usage 17 | 18 | ```c# 19 | DbHelper db = new DbHelper(); 20 | 21 | Repeater1.DataSource = db.GetDataTable("select * from [jobs]"); 22 | Repeater1.DataBind(); 23 | 24 | SqlParameter par = new SqlParameter("@job_id", 1); 25 | msg.Text = db.ExecuteScalar("select job_desc from jobs where job_id=@job_id", par); 26 | ``` 27 | 28 | ### Paging 29 | 30 | ```c# 31 | DbPager pager = new DbPager(); 32 | pager.field = "*"; 33 | pager.tableName = "jobs"; 34 | pager.primaryKey = "job_id"; 35 | pager.orderSql = "job_id desc"; 36 | //pager.appendSql = "left join jobs on jobs.job_id=employee.job_id"; 37 | pager.pagerSize = Pager1.PageSize; 38 | pager.pagerIndex = Pager1.CurPage; 39 | //pager.kind = DbPagerKind.TableVar; 40 | Repeater1.DataSource = pager.GetData(); 41 | Pager1.RecordCount = pager.pagerCount; 42 | Repeater1.DataBind(); 43 | ``` 44 | 45 | ### Insert 46 | 47 | ```c# 48 | DbInsert insert = new DbInsert(); 49 | insert.Add("job_desc", TextBox1.Text); 50 | insert.Add("min_lvl", TextBox2.Text); 51 | insert.Add("max_lvl", TextBox2.Text); 52 | insert.Execute("jobs"); 53 | ``` 54 | 55 | ### Update 56 | 57 | ```c# 58 | DbUpdate update = new DbUpdate(); 59 | update.Add("max_lvl", TextBox2.Text); 60 | SqlParameter par = new SqlParameter("@job_id", 1); 61 | update.Execute("jobs", "where job_id=@job_id", par); 62 | ``` 63 | 64 | ### Transaction 65 | 66 | ```c# 67 | DbHelper db = new DbHelper(); 68 | db.BeginTransaction(); 69 | try 70 | { 71 | db.ExecuteNonQuery('sql...1'); 72 | db.ExecuteNonQuery('sql...2'); 73 | int a = 0; 74 | int b = 1 / a; //exception code 75 | db.ExecuteNonQuery('sql...3'); 76 | db.CommitTransaction(); 77 | } 78 | catch (Exception) 79 | { 80 | db.RollbackTransaction(); 81 | } 82 | 83 | ``` 84 | -------------------------------------------------------------------------------- /Database/Orm.cs: -------------------------------------------------------------------------------- 1 | using System; 2 | using System.Collections.Generic; 3 | using System.Text; 4 | using System.Data; 5 | using System.Data.Common; 6 | using System.Configuration; 7 | using System.Reflection; 8 | 9 | namespace Cat.Database 10 | { 11 | [AttributeUsage(AttributeTargets.Struct | AttributeTargets.Property | AttributeTargets.Field)] 12 | public class DataFieldAttribute : Attribute 13 | { 14 | private string _fieldName; 15 | 16 | public string FieldName 17 | { 18 | get { return _fieldName; } 19 | set { _fieldName = value; } 20 | } 21 | 22 | public DataFieldAttribute(string fieldName) 23 | { 24 | this._fieldName = fieldName; 25 | } 26 | } 27 | 28 | public class Orm 29 | { 30 | public static T GetEntity(DbHelper db, string sql, CommandType CommandType, params DbParameter[] param) where T : new() 31 | { 32 | T entity = new T(); 33 | using (DbDataReader reader = db.ExecuteReader(sql, CommandType, param)) 34 | { 35 | try 36 | { 37 | if (reader.Read()) 38 | { 39 | Type entityType = entity.GetType(); 40 | PropertyInfo[] propertyInfos = entityType.GetProperties(); 41 | foreach (PropertyInfo property in propertyInfos) 42 | { 43 | DataFieldAttribute datafieldAttribute = GetDataFieldAttribute(property); 44 | if (datafieldAttribute != null) 45 | { 46 | if (!(reader[datafieldAttribute.FieldName] is DBNull)) 47 | { 48 | property.SetValue(entity, reader[datafieldAttribute.FieldName], null); 49 | } 50 | } 51 | } 52 | } 53 | } 54 | catch 55 | { 56 | throw; 57 | } 58 | finally 59 | { 60 | reader.Close(); 61 | reader.Dispose(); 62 | } 63 | } 64 | return entity; 65 | } 66 | 67 | public static T GetEntity(DbHelper db, string sql, params DbParameter[] param) where T : new() 68 | { 69 | return GetEntity(db, sql, CommandType.Text, param); 70 | } 71 | 72 | public static T GetEntity(string sql, params DbParameter[] param) where T : new() 73 | { 74 | return GetEntity(DbHelper.Db, sql, CommandType.Text, param); 75 | } 76 | 77 | public static T GetEntity(string sql, CommandType CommandType, params DbParameter[] param) where T : new() 78 | { 79 | return GetEntity(DbHelper.Db, sql, CommandType, param); 80 | } 81 | 82 | public static IList GetEntityList(DbHelper db, string sql, CommandType CommandType, params DbParameter[] param) where T : new() 83 | { 84 | IList entityList = new List(); 85 | using (DbDataReader reader = db.ExecuteReader(sql, CommandType, param)) 86 | { 87 | try 88 | { 89 | while (reader.Read()) 90 | { 91 | T entity = new T(); 92 | Type entityType = entity.GetType(); 93 | PropertyInfo[] propertyInfos = entityType.GetProperties(); 94 | foreach (PropertyInfo property in propertyInfos) 95 | { 96 | DataFieldAttribute datafieldAttribute = GetDataFieldAttribute(property); 97 | if (datafieldAttribute != null) 98 | { 99 | if (!(reader[datafieldAttribute.FieldName] is DBNull)) 100 | { 101 | property.SetValue(entity, reader[datafieldAttribute.FieldName], null); 102 | } 103 | } 104 | } 105 | entityList.Add(entity); 106 | } 107 | } 108 | catch 109 | { 110 | throw; 111 | } 112 | finally 113 | { 114 | reader.Close(); 115 | reader.Dispose(); 116 | } 117 | } 118 | return entityList; 119 | } 120 | 121 | public static IList GetEntityList(DbHelper db, string sql, params DbParameter[] param) where T : new() 122 | { 123 | return GetEntityList(db, sql, CommandType.Text, param); 124 | } 125 | 126 | public static IList GetEntityList(string sql, CommandType CommandType, params DbParameter[] param) where T : new() 127 | { 128 | return GetEntityList(DbHelper.Db, sql, CommandType, param); 129 | } 130 | 131 | public static IList GetEntityList(string sql, params DbParameter[] param) where T : new() 132 | { 133 | return GetEntityList(DbHelper.Db, sql, CommandType.Text, param); 134 | } 135 | 136 | public static int ExecuteEntity(DbHelper db, string sql, CommandType commandType, object entity) 137 | { 138 | return db.ExecuteNonQuery(sql, commandType, GetParameters(db, entity)); 139 | } 140 | 141 | public static int ExecuteEntity(string sql, CommandType commandType, object entity) 142 | { 143 | return ExecuteEntity(DbHelper.Db, sql, commandType, entity); 144 | } 145 | 146 | public static int ExecuteEntity(DbHelper db, string sql, object entity) 147 | { 148 | return ExecuteEntity(db, sql, CommandType.Text, entity); 149 | } 150 | 151 | public static int ExecuteEntity(string sql, object entity) 152 | { 153 | return ExecuteEntity(DbHelper.Db, sql, CommandType.Text, entity); 154 | } 155 | 156 | public static object ExecuteEntityIdentity(DbHelper db, string sql, CommandType commandType, object entity) 157 | { 158 | bool ist = db.IsBeginTransaction; 159 | if (!ist) 160 | { 161 | db.BeginTransaction(); 162 | } 163 | try 164 | { 165 | ExecuteEntity(db, sql, commandType, entity); 166 | return db.ExecuteScalar("SELECT @@IDENTITY"); 167 | } 168 | catch 169 | { 170 | db.RollbackTransaction(); 171 | throw; 172 | } 173 | finally 174 | { 175 | if (!ist) 176 | { 177 | db.CommitTransaction(); 178 | } 179 | } 180 | } 181 | 182 | public static object ExecuteEntityIdentity(DbHelper db, string sql, object entity) 183 | { 184 | return ExecuteEntityIdentity(db, sql, CommandType.Text, entity); 185 | } 186 | 187 | public static object ExecuteEntityIdentity(string sql, CommandType commandType, object entity) 188 | { 189 | return ExecuteEntityIdentity(DbHelper.Db, sql, commandType, entity); 190 | } 191 | 192 | public static object ExecuteEntityIdentity(string sql, object entity) 193 | { 194 | return ExecuteEntityIdentity(DbHelper.Db, sql, CommandType.Text, entity); 195 | } 196 | 197 | private static DbParameter[] GetParameters(DbHelper db, object entity) 198 | { 199 | Type entityType = entity.GetType(); 200 | PropertyInfo[] propertyInfos = entityType.GetProperties(); 201 | List paramerList = new List(); 202 | foreach (PropertyInfo property in propertyInfos) 203 | { 204 | DataFieldAttribute datafieldAttribute = GetDataFieldAttribute(property); 205 | if (datafieldAttribute != null) 206 | { 207 | object oval = property.GetValue(entity, null); 208 | if (oval != null) 209 | { 210 | DbParameter param = db.Factory.CreateParameter(); 211 | param.ParameterName = "@" + datafieldAttribute.FieldName; 212 | param.Value = oval; 213 | paramerList.Add(param); 214 | } 215 | } 216 | } 217 | return paramerList.ToArray(); 218 | } 219 | 220 | private static DataFieldAttribute GetDataFieldAttribute(PropertyInfo property) 221 | { 222 | object[] oArr = property.GetCustomAttributes(true); 223 | for (int i = 0; i < oArr.Length; i++) 224 | { 225 | if (oArr[i] is DataFieldAttribute) 226 | return (DataFieldAttribute)oArr[i]; 227 | } 228 | return null; 229 | } 230 | } 231 | } 232 | -------------------------------------------------------------------------------- /Database/DbPager.cs: -------------------------------------------------------------------------------- 1 | using System; 2 | using System.Data.Common; 3 | using System.Collections.Generic; 4 | using System.Data; 5 | using System.Text; 6 | 7 | namespace Cat.Database 8 | { 9 | public enum DbPagerKind 10 | { 11 | Row_Number = 1, 12 | 13 | TableVar = 2, 14 | 15 | MaxMin = 3, 16 | 17 | TopTop = 4, 18 | 19 | Max_TopTop = 304, 20 | 21 | Max_TableVar = 302 22 | } 23 | 24 | public class DbPagerBase 25 | { 26 | public DbPager dbPager; 27 | 28 | internal virtual void CreateRecordCountSQL() 29 | { 30 | if (dbPager.isDefaultRecordCount) 31 | { 32 | if (dbPager.kind == DbPagerKind.Row_Number) 33 | { 34 | dbPager.pagerCountSql = String.Format("SELECT COUNT(0) FROM {0} {1}", dbPager.tableName, dbPager.appendSql); 35 | } 36 | else 37 | { 38 | dbPager.pagerCountSql = String.Format("SELECT COUNT(0) FROM {0} {1}", dbPager.tableName, string.IsNullOrEmpty(dbPager.whereSql) ? "" : "WHERE " + dbPager.whereSql); 39 | } 40 | } 41 | else 42 | { 43 | if (dbPager.kind == DbPagerKind.Row_Number) 44 | { 45 | dbPager.pagerCountSql = String.Format("SELECT COUNT(0) FROM (SELECT {0} FROM {1} {2}) AS [TABLE]", dbPager.field, dbPager.tableName, dbPager.appendSql); 46 | } 47 | else 48 | { 49 | dbPager.pagerCountSql = String.Format("SELECT COUNT(0) FROM (SELECT {0} FROM {1} {2}) AS [TABLE]", dbPager.field, dbPager.tableName, string.IsNullOrEmpty(dbPager.whereSql) ? "" : "WHERE " + dbPager.whereSql); 50 | } 51 | } 52 | } 53 | 54 | internal virtual void CreateFirstPageSQL() 55 | { 56 | StringBuilder sql = new StringBuilder(); 57 | sql.Append("select top "); 58 | sql.Append(dbPager.pagerSize); 59 | sql.Append(" "); 60 | sql.Append(dbPager.field); 61 | sql.Append(" from "); 62 | sql.Append(dbPager.tableName); 63 | if (dbPager.kind == DbPagerKind.Row_Number || dbPager.kind == DbPagerKind.TableVar) 64 | { 65 | if (!string.IsNullOrEmpty(dbPager.appendSql)) 66 | { 67 | sql.Append(" "); 68 | sql.Append(dbPager.appendSql); 69 | } 70 | } 71 | else 72 | { 73 | if (!string.IsNullOrEmpty(dbPager.whereSql)) 74 | { 75 | sql.Append(" where "); 76 | sql.Append(dbPager.whereSql); 77 | } 78 | } 79 | sql.Append(" order by "); 80 | sql.Append(dbPager.orderSql); 81 | 82 | dbPager.firstPagerSql = sql.ToString(); 83 | } 84 | 85 | internal virtual void CreateNextPageSQL() 86 | { 87 | 88 | } 89 | 90 | internal virtual void CreateLastPageSQL() 91 | { 92 | 93 | } 94 | 95 | internal virtual string GetSQLByPageIndex() 96 | { 97 | 98 | if (dbPager.pagerIndex == 1) 99 | { 100 | return dbPager.firstPagerSql; 101 | } 102 | 103 | if (dbPager.pagerIndex < 1) 104 | dbPager.pagerIndex = 1; 105 | 106 | if (dbPager.pagerIndex > dbPager.pagerCount) 107 | dbPager.pagerIndex = dbPager.pagerCount; 108 | 109 | 110 | Int32 p1 = dbPager.pagerSize * (dbPager.pagerIndex - 1) + 1; 111 | Int32 p2 = p1 + dbPager.pagerSize - 1; 112 | 113 | return string.Format(dbPager.pagerSql, p1, p2); 114 | 115 | } 116 | } 117 | 118 | public class SQL_Max : DbPagerBase 119 | { 120 | internal override void CreateNextPageSQL() 121 | { 122 | 123 | 124 | 125 | /* 126 | 127 | select top 10 * from table 128 | where customerID >= 129 | (SELECT max(customerID) FROM 130 | (select top 21 customerID from table order by customerID ) as t 131 | ) 132 | 133 | --------------------- 134 | 135 | select top 10 * from table where customerID >=( 136 | select top 1 customerID from ( 137 | SELECT top 21 customerID 138 | FROM table order by customerID ) as aa order by customerID desc 139 | ) 140 | 141 | 142 | ------------ 143 | declare @id int 144 | 145 | SELECT top 21 @id = customerID 146 | FROM table 147 | 148 | select top 10 * from table where customerID >=@id 149 | select @id 150 | 151 | */ 152 | 153 | string orderCol; bool isDesc = true; 154 | orderCol = dbPager.orderSql.ToLower(); if (orderCol.Contains("desc")) 155 | { 156 | orderCol = orderCol.Replace("desc", ""); 157 | } 158 | else 159 | { 160 | orderCol = orderCol.Replace("asc", ""); 161 | isDesc = false; 162 | } 163 | 164 | StringBuilder sql = new StringBuilder(); 165 | sql.Append(" select top "); sql.Append(dbPager.pagerSize); sql.Append(" "); 166 | sql.Append(dbPager.field); 167 | sql.Append(" from "); 168 | sql.Append(dbPager.tableName); 169 | 170 | sql.Append(" where "); sql.Append(orderCol); 171 | 172 | sql.Append(isDesc ? "<=" : ">="); 173 | sql.Append(" (SELECT "); sql.Append(isDesc ? "min(" : "max("); 174 | 175 | sql.Append(orderCol); 176 | sql.Append(" ) from (select top {0} "); sql.Append(orderCol); 177 | sql.Append(" from "); 178 | sql.Append(dbPager.tableName); 179 | 180 | if (!string.IsNullOrEmpty(dbPager.whereSql)) { 181 | sql.Append(" where "); 182 | sql.Append(dbPager.whereSql); 183 | } 184 | 185 | sql.Append(" order by "); sql.Append(orderCol); 186 | 187 | if (isDesc) 188 | sql.Append(" desc"); 189 | 190 | 191 | sql.Append(" ) as t ) "); 192 | if (!string.IsNullOrEmpty(dbPager.whereSql)) { 193 | sql.Append(" and ( "); 194 | sql.Append(dbPager.whereSql); 195 | sql.Append(")"); 196 | } 197 | 198 | sql.Append(" order by "); sql.Append(orderCol); 199 | 200 | if (isDesc) 201 | sql.Append(" desc "); 202 | 203 | 204 | dbPager.pagerSql = sql.ToString(); 205 | } 206 | 207 | internal override string GetSQLByPageIndex() 208 | { 209 | if (dbPager.pagerIndex == 1) 210 | { 211 | return dbPager.firstPagerSql; 212 | } 213 | 214 | if (dbPager.pagerIndex < 1) 215 | dbPager.pagerIndex = 1; 216 | 217 | if (dbPager.pagerIndex > dbPager.pagerCount) 218 | dbPager.pagerIndex = dbPager.pagerCount; 219 | 220 | 221 | Int32 p1 = dbPager.pagerSize * (dbPager.pagerIndex - 1) + 1; 222 | 223 | return string.Format(dbPager.pagerSql, p1); 224 | 225 | } 226 | } 227 | 228 | public class SQL_Row_Number : DbPagerBase 229 | { 230 | internal override void CreateNextPageSQL() 231 | { 232 | StringBuilder sql = new StringBuilder(); 233 | sql.Append("with t_pager as (select row_num = ROW_NUMBER() OVER (ORDER BY "); 234 | sql.Append(dbPager.orderSql); 235 | sql.Append(" ),"); 236 | sql.Append(dbPager.field); 237 | sql.Append(" from "); 238 | sql.Append(dbPager.tableName); 239 | 240 | if (!string.IsNullOrEmpty(dbPager.appendSql)) 241 | { 242 | sql.Append(" "); 243 | sql.Append(dbPager.appendSql); 244 | } 245 | 246 | sql.Append(" ) select * from t_pager where row_num between {0} and {1} "); 247 | 248 | 249 | dbPager.pagerSql = sql.ToString(); 250 | } 251 | } 252 | 253 | public class SQL_TableVar : DbPagerBase 254 | { 255 | internal override void CreateNextPageSQL() 256 | { 257 | 258 | 259 | 260 | 261 | 262 | 263 | 264 | 265 | StringBuilder sql = new StringBuilder(); 266 | sql.Append(" declare @tt table(id int identity(1,1),nid int)"); 267 | sql.Append(" insert into @tt(nid) select top {1} "); 268 | sql.Append(dbPager.primaryKey); 269 | sql.Append(" from "); 270 | sql.Append(dbPager.tableName); 271 | 272 | if (!string.IsNullOrEmpty(dbPager.whereSql)) 273 | { 274 | sql.Append(" where "); 275 | sql.Append(dbPager.whereSql); 276 | } 277 | 278 | sql.Append(" order by "); 279 | sql.Append(dbPager.orderSql); 280 | 281 | sql.Append(" select "); 282 | sql.Append(dbPager.field); 283 | sql.Append(" from "); 284 | sql.Append(dbPager.tableName); 285 | sql.Append(" t1, @tt t2 where t1."); 286 | sql.Append(dbPager.primaryKey); 287 | sql.Append(" =t2.nid and t2.id between {0} and {1} order by t2.id"); 288 | 289 | 290 | dbPager.pagerSql = sql.ToString(); 291 | } 292 | } 293 | 294 | public class SQL_TopTop : DbPagerBase 295 | { 296 | string _tableNames = ""; string _query = ""; string _idColumn = ""; 297 | string _orderCol = ""; string _orderColA = ""; string _orderColB = ""; 298 | string[] _arrOrderCol; 299 | 300 | private void TopTopInit(string t1, string t2) 301 | { 302 | if (_tableNames.Length == 0) 303 | { 304 | _tableNames = dbPager.tableName; _query = dbPager.whereSql; 305 | _idColumn = dbPager.primaryKey.ToLower().Trim(); 306 | 307 | _arrOrderCol = dbPager.orderSql.ToLower().Split(','); 308 | } 309 | 310 | string tmpCol; 311 | _orderCol = ""; _orderColA = ""; _orderColB = ""; 312 | foreach (string a in _arrOrderCol) 313 | { 314 | if (a.Contains("desc")) 315 | { 316 | tmpCol = a.Replace("desc", "").Trim(); 317 | _orderColA += t1 + tmpCol + " desc,"; 318 | _orderColB += t2 + tmpCol + ","; 319 | _orderCol += tmpCol + ","; 320 | } 321 | else 322 | { 323 | tmpCol = a.Replace("asc", "").Trim(); 324 | _orderColA += t1 + tmpCol + ","; 325 | _orderColB += t2 + tmpCol + " desc,"; 326 | _orderCol += tmpCol + ","; 327 | } 328 | } 329 | 330 | _orderColA = _orderColA.TrimEnd(','); 331 | _orderColB = _orderColB.TrimEnd(','); 332 | _orderCol = _orderCol.TrimEnd(','); 333 | 334 | if (!_orderCol.Contains(_idColumn)) _orderCol += "," + _idColumn; 335 | 336 | } 337 | 338 | internal override void CreateNextPageSQL() 339 | { 340 | int pageSize = dbPager.pagerSize; 341 | string tableShowColumns = dbPager.field; 342 | 343 | 344 | TopTopInit("", "t."); 345 | 346 | 347 | StringBuilder sql = new StringBuilder(); 348 | sql.Append(" select "); 349 | sql.Append(tableShowColumns); 350 | sql.Append(" from "); sql.Append(_tableNames); sql.Append(" where "); 351 | sql.Append(_idColumn); sql.Append(" in ( "); 352 | 353 | sql.Append(" select top "); 354 | sql.Append(pageSize); sql.Append(" "); sql.Append(_idColumn); sql.Append(" from ("); 355 | 356 | sql.Append(" select top {0} "); 357 | sql.Append(_orderCol); sql.Append(" from "); 358 | sql.Append(_tableNames); 359 | if (!string.IsNullOrEmpty(_query) && _query.Length > 1) 360 | { sql.Append(" where "); 361 | sql.Append(_query); 362 | } 363 | 364 | sql.Append(" order by "); sql.Append(_orderColA); 365 | sql.Append(" ) as t order by "); 366 | sql.Append(_orderColB); 367 | sql.Append(" ) "); 368 | 369 | if (!string.IsNullOrEmpty(_query) && _query.Length > 1) 370 | { sql.Append(" and "); 371 | sql.Append(_query); 372 | } 373 | 374 | sql.Append(" order by "); 375 | sql.Append(_orderColA); 376 | dbPager.pagerSql = sql.ToString(); 377 | } 378 | 379 | internal override void CreateLastPageSQL() 380 | { 381 | string tableShowColumns = dbPager.field; 382 | 383 | 384 | TopTopInit("t.", ""); 385 | 386 | 387 | StringBuilder sql = new StringBuilder(); 388 | sql.Append(" select "); 389 | sql.Append(tableShowColumns); sql.Append(" from ( select top {0} * from "); 390 | sql.Append(_tableNames); 391 | if (!string.IsNullOrEmpty(_query) && _query.Length > 1) 392 | { sql.Append(" where "); 393 | sql.Append(_query); 394 | } 395 | 396 | sql.Append(" order by "); sql.Append(_orderColB); 397 | sql.Append(" ) as t order by "); 398 | sql.Append(_orderColA); 399 | dbPager.lastPagerSql = sql.ToString(); 400 | } 401 | 402 | internal override string GetSQLByPageIndex() 403 | { 404 | if (dbPager.pagerIndex < 1) 405 | dbPager.pagerIndex = 1; 406 | 407 | if (dbPager.pagerIndex > dbPager.pagerCount) 408 | dbPager.pagerIndex = dbPager.pagerCount; 409 | 410 | 411 | if (dbPager.pagerIndex == 1) 412 | { 413 | return dbPager.firstPagerSql; 414 | } 415 | int pagerlastcount = dbPager.pagerCount % dbPager.pagerSize == 0 ? dbPager.pagerCount / dbPager.pagerSize : dbPager.pagerCount / dbPager.pagerSize + 1; 416 | if (dbPager.pagerIndex == pagerlastcount) 417 | { 418 | Int32 p1 = dbPager.pagerCount % dbPager.pagerSize; 419 | if (p1 == 0) 420 | p1 = dbPager.pagerSize; 421 | 422 | return string.Format(dbPager.lastPagerSql, p1); 423 | } 424 | else 425 | { 426 | Int32 p1 = dbPager.pagerSize * dbPager.pagerIndex; 427 | return string.Format(dbPager.pagerSql, p1); 428 | } 429 | } 430 | } 431 | 432 | public class DbPager 433 | { 434 | public string field; 435 | 436 | public string primaryKey; 437 | 438 | public string tableName; 439 | 440 | public string appendSql; 441 | 442 | public string whereSql; 443 | 444 | public string orderSql; 445 | 446 | public int pagerSize; 447 | 448 | public int pagerIndex; 449 | 450 | public int pagerCount; 451 | 452 | public DbHelper _db = null; 453 | 454 | public List sqlParams = new List(); 455 | 456 | public DbPagerKind kind = DbPagerKind.Row_Number; 457 | 458 | public string pagerCountSql; 459 | 460 | public bool isDefaultRecordCount = true; 461 | 462 | public string pagerSql; 463 | 464 | public string firstPagerSql; 465 | 466 | public string lastPagerSql; 467 | 468 | public DbPager() 469 | { 470 | _db = new DbHelper(); 471 | } 472 | 473 | public DbPager(DbHelper db) 474 | { 475 | _db = db; 476 | } 477 | 478 | public DbPager(DbHelper db, string field, string primaryKey, string tableName, string orderSql, int pagerSize, int pagerIndex, DbPagerKind kind) 479 | { 480 | _db = db; 481 | this.field = field; 482 | this.primaryKey = primaryKey; 483 | this.tableName = tableName; 484 | this.orderSql = orderSql; 485 | this.pagerSize = pagerSize; 486 | this.pagerIndex = pagerIndex; 487 | this.kind = kind; 488 | } 489 | 490 | private DbPagerBase dbPagerBase = null; 491 | 492 | private void CreateDbPagerBase() 493 | { 494 | switch (kind) 495 | { 496 | case DbPagerKind.Row_Number: 497 | dbPagerBase = new SQL_Row_Number(); 498 | break; 499 | 500 | case DbPagerKind.TableVar: 501 | dbPagerBase = new SQL_TableVar(); 502 | break; 503 | 504 | case DbPagerKind.MaxMin: 505 | dbPagerBase = new SQL_Max(); 506 | break; 507 | 508 | case DbPagerKind.TopTop: 509 | dbPagerBase = new SQL_TopTop(); 510 | break; 511 | 512 | case DbPagerKind.Max_TopTop: 513 | if (orderSql.Contains(",")) 514 | dbPagerBase = new SQL_TopTop(); 515 | else 516 | dbPagerBase = new SQL_Max(); 517 | break; 518 | 519 | case DbPagerKind.Max_TableVar: 520 | if (orderSql.Contains(",")) 521 | dbPagerBase = new SQL_TableVar(); 522 | else 523 | dbPagerBase = new SQL_Max(); 524 | break; 525 | } 526 | dbPagerBase.dbPager = this; 527 | } 528 | 529 | private void CreateSql() 530 | { 531 | if (dbPagerBase == null) 532 | { 533 | CreateDbPagerBase(); 534 | } 535 | dbPagerBase.CreateRecordCountSQL(); 536 | dbPagerBase.CreateFirstPageSQL(); 537 | dbPagerBase.CreateNextPageSQL(); 538 | dbPagerBase.CreateLastPageSQL(); 539 | } 540 | 541 | public DataTable GetData(out int rowCount) 542 | { 543 | DataTable dt = GetData(); 544 | rowCount = pagerCount; 545 | return dt; 546 | } 547 | 548 | public DataTable GetData() 549 | { 550 | CreateSql(); 551 | bool ist = _db.IsBeginTransaction; 552 | if (!ist) 553 | { 554 | _db.BeginTransaction(); 555 | } 556 | try 557 | { 558 | string pcount = string.Empty; 559 | 560 | if (sqlParams.Count > 0) 561 | { 562 | pcount = _db.ExecuteScalar(pagerCountSql, sqlParams.ToArray()); 563 | _db.ClearParameters(); 564 | } 565 | else 566 | { 567 | pcount = _db.ExecuteScalar(pagerCountSql); 568 | } 569 | 570 | if (string.IsNullOrEmpty(pcount)) 571 | { 572 | pcount = "0"; 573 | } 574 | pagerCount = int.Parse(pcount); 575 | 576 | string sql = dbPagerBase.GetSQLByPageIndex(); 577 | if (sqlParams.Count > 0) 578 | { 579 | return _db.GetDataTable(sql, sqlParams.ToArray()); 580 | } 581 | else 582 | { 583 | return _db.GetDataTable(sql); 584 | } 585 | } 586 | catch 587 | { 588 | _db.RollbackTransaction(); 589 | throw; 590 | } 591 | finally 592 | { 593 | if (!ist) 594 | { 595 | _db.CommitTransaction(); 596 | } 597 | } 598 | } 599 | } 600 | } 601 | -------------------------------------------------------------------------------- /Database/DbHelper.cs: -------------------------------------------------------------------------------- 1 | using System; 2 | using System.Collections.Generic; 3 | using System.Text; 4 | using System.Data; 5 | using System.Data.Common; 6 | using System.Configuration; 7 | using System.Reflection; 8 | 9 | namespace Cat.Database 10 | { 11 | public enum DbProviderName 12 | { 13 | SqlClient, 14 | 15 | OleDb, 16 | 17 | MySqlClient, 18 | 19 | OracleClient 20 | } 21 | 22 | public static class DbConfig 23 | { 24 | private readonly static string _ConnectionString = ConfigurationManager.ConnectionStrings["ConnectionString"].ConnectionString; 25 | private readonly static string _ProviderName = ConfigurationManager.ConnectionStrings["ConnectionString"].ProviderName; 26 | 27 | public static string ConnectionString 28 | { 29 | get { return _ConnectionString; } 30 | } 31 | 32 | public static string ProviderName 33 | { 34 | get { return _ProviderName; } 35 | } 36 | } 37 | 38 | public sealed class DbHelper 39 | { 40 | public string ConnectionString { get; set; } 41 | 42 | public string ProviderName { get; set; } 43 | 44 | public DbProviderFactory Factory { get; set; } 45 | 46 | public bool IsBeginTransaction { get; set; } 47 | 48 | public DbTransaction Transaction { get; set; } 49 | 50 | public DbConnection Con { get; set; } 51 | 52 | public DbCommand Cmd { get; set; } 53 | 54 | public DbHelper() 55 | { 56 | ConnectionString = DbConfig.ConnectionString; 57 | ProviderName = DbConfig.ProviderName; 58 | CreateFactory(); 59 | } 60 | 61 | public static DbHelper Db 62 | { 63 | get 64 | { 65 | return new DbHelper(); 66 | } 67 | } 68 | 69 | public DbHelper(string ConnectionString, DbProviderName provider) 70 | { 71 | this.ConnectionString = ConnectionString; 72 | ProviderName = GetProviderName(provider); 73 | CreateFactory(); 74 | } 75 | 76 | public DbHelper(string ConnectionString, string providerName) 77 | { 78 | this.ConnectionString = ConnectionString; 79 | this.ProviderName = providerName; 80 | CreateFactory(); 81 | } 82 | 83 | private void CreateFactory() 84 | { 85 | Factory = DbProviderFactories.GetFactory(ProviderName); 86 | } 87 | 88 | public void BeginTransaction() 89 | { 90 | try 91 | { 92 | Con = Factory.CreateConnection(); 93 | Con.ConnectionString = ConnectionString; 94 | if (Con.State == ConnectionState.Closed) 95 | { 96 | Con.Open(); 97 | } 98 | Transaction = Con.BeginTransaction(); 99 | Cmd = Con.CreateCommand(); 100 | Cmd.Transaction = Transaction; 101 | IsBeginTransaction = true; 102 | } 103 | catch 104 | { 105 | IsBeginTransaction = false; 106 | if (Con.State == ConnectionState.Open) 107 | { 108 | Cmd.Dispose(); 109 | Transaction.Dispose(); 110 | Con.Close(); 111 | } 112 | throw; 113 | } 114 | 115 | } 116 | 117 | public void CommitTransaction() 118 | { 119 | try 120 | { 121 | if (IsBeginTransaction && Transaction != null) 122 | { 123 | Transaction.Commit(); 124 | } 125 | } 126 | catch 127 | { 128 | try 129 | { 130 | Transaction.Rollback(); 131 | throw; 132 | } 133 | catch 134 | { 135 | throw; 136 | } 137 | } 138 | finally 139 | { 140 | IsBeginTransaction = false; 141 | if (Con.State == ConnectionState.Open) 142 | { 143 | Cmd.Dispose(); 144 | Transaction.Dispose(); 145 | Con.Close(); 146 | } 147 | } 148 | } 149 | 150 | public void RollbackTransaction() 151 | { 152 | if (IsBeginTransaction) 153 | { 154 | Transaction.Rollback(); 155 | } 156 | IsBeginTransaction = false; 157 | if (Con.State == ConnectionState.Open) 158 | { 159 | Cmd.Dispose(); 160 | Transaction.Dispose(); 161 | Con.Close(); 162 | } 163 | } 164 | 165 | public void ClearParameters() 166 | { 167 | Cmd.Parameters.Clear(); 168 | } 169 | 170 | private string GetProviderName(DbProviderName provider) 171 | { 172 | switch (provider) 173 | { 174 | case DbProviderName.SqlClient: 175 | return "System.Data.SqlClient"; 176 | case DbProviderName.OleDb: 177 | return "System.Data.OleDb"; 178 | case DbProviderName.MySqlClient: 179 | return "MySql.Data.MySqlClient"; 180 | case DbProviderName.OracleClient: 181 | return "System.Data.OracleClient"; 182 | default: 183 | return null; 184 | } 185 | } 186 | 187 | public int ExecuteNonQuery(string sql, CommandType CommandType, params DbParameter[] param) 188 | { 189 | if (IsBeginTransaction) 190 | { 191 | try 192 | { 193 | Cmd.CommandType = CommandType; 194 | Cmd.CommandText = sql; 195 | Cmd.Parameters.AddRange(param); 196 | return Cmd.ExecuteNonQuery(); 197 | } 198 | catch 199 | { 200 | try 201 | { 202 | RollbackTransaction(); 203 | throw; 204 | } 205 | catch 206 | { 207 | throw; 208 | } 209 | } 210 | 211 | } 212 | else 213 | { 214 | using (Con = Factory.CreateConnection()) 215 | { 216 | using (Cmd = Con.CreateCommand()) 217 | { 218 | try 219 | { 220 | Con.ConnectionString = ConnectionString; 221 | Cmd.CommandType = CommandType; 222 | Cmd.CommandText = sql; 223 | Cmd.Parameters.AddRange(param); 224 | Con.Open(); 225 | return Cmd.ExecuteNonQuery(); 226 | } 227 | catch 228 | { 229 | Con.Close(); 230 | throw; 231 | } 232 | } 233 | } 234 | } 235 | } 236 | 237 | public int ExecuteNonQuery(string sql, params DbParameter[] param) 238 | { 239 | return ExecuteNonQuery(sql, CommandType.Text, param); 240 | } 241 | 242 | public DbDataReader ExecuteReader(string sql, CommandType CommandType, params DbParameter[] param) 243 | { 244 | if (IsBeginTransaction) 245 | { 246 | try 247 | { 248 | Cmd.CommandType = CommandType; 249 | Cmd.CommandText = sql; 250 | Cmd.Parameters.AddRange(param); 251 | return Cmd.ExecuteReader(); 252 | 253 | } 254 | catch 255 | { 256 | try 257 | { 258 | RollbackTransaction(); 259 | throw; 260 | } 261 | catch 262 | { 263 | throw; 264 | } 265 | } 266 | 267 | } 268 | else 269 | { 270 | Con = Factory.CreateConnection(); 271 | using (Cmd = Con.CreateCommand()) 272 | { 273 | try 274 | { 275 | Con.ConnectionString = ConnectionString; 276 | Cmd.CommandType = CommandType; 277 | Cmd.CommandText = sql; 278 | Cmd.Parameters.AddRange(param); 279 | Con.Open(); 280 | return Cmd.ExecuteReader(CommandBehavior.CloseConnection); 281 | } 282 | catch 283 | { 284 | Con.Close(); 285 | throw; 286 | } 287 | } 288 | 289 | } 290 | } 291 | 292 | public DbDataReader ExecuteReader(string sql, params DbParameter[] param) 293 | { 294 | return ExecuteReader(sql, CommandType.Text, param); 295 | } 296 | 297 | public object ExecuteScalar(string sql, CommandType CommandType, params DbParameter[] param) 298 | { 299 | if (IsBeginTransaction) 300 | { 301 | try 302 | { 303 | 304 | Cmd.CommandType = CommandType; 305 | Cmd.CommandText = sql; 306 | Cmd.Parameters.AddRange(param); 307 | return Cmd.ExecuteScalar(); 308 | } 309 | catch 310 | { 311 | try 312 | { 313 | RollbackTransaction(); 314 | throw; 315 | } 316 | catch 317 | { 318 | throw; 319 | } 320 | } 321 | 322 | } 323 | else 324 | { 325 | using (Con = Factory.CreateConnection()) 326 | { 327 | using (Cmd = Con.CreateCommand()) 328 | { 329 | try 330 | { 331 | Con.ConnectionString = ConnectionString; 332 | Cmd.CommandType = CommandType; 333 | Cmd.CommandText = sql; 334 | Cmd.Parameters.AddRange(param); 335 | Con.Open(); 336 | return Cmd.ExecuteScalar(); 337 | } 338 | catch 339 | { 340 | Con.Close(); 341 | throw; 342 | } 343 | } 344 | } 345 | } 346 | } 347 | 348 | public object ExecuteScalar(string sql, params DbParameter[] param) 349 | { 350 | return ExecuteScalar(sql, CommandType.Text, param); 351 | } 352 | 353 | public T ExecuteScalar(string sql, CommandType CommandType, params DbParameter[] param) 354 | { 355 | return (T)Convert.ChangeType(ExecuteScalar(sql, CommandType, param), typeof(T)); 356 | } 357 | 358 | public T ExecuteScalar(string sql, params DbParameter[] param) 359 | { 360 | return ExecuteScalar(sql, CommandType.Text, param); 361 | } 362 | 363 | public DataSet GetDataSet(string sql, CommandType CommandType, params DbParameter[] param) 364 | { 365 | if (IsBeginTransaction) 366 | { 367 | try 368 | { 369 | Cmd.CommandType = CommandType; 370 | Cmd.CommandText = sql; 371 | Cmd.Parameters.AddRange(param); 372 | using (DbDataAdapter da = Factory.CreateDataAdapter()) 373 | { 374 | da.SelectCommand = Cmd; 375 | DataSet ds = new DataSet(); 376 | da.Fill(ds); 377 | return ds; 378 | } 379 | } 380 | catch 381 | { 382 | try 383 | { 384 | RollbackTransaction(); 385 | throw; 386 | } 387 | catch 388 | { 389 | throw; 390 | } 391 | } 392 | 393 | } 394 | else 395 | { 396 | using (Con = Factory.CreateConnection()) 397 | { 398 | using (Cmd = Con.CreateCommand()) 399 | { 400 | try 401 | { 402 | Con.ConnectionString = ConnectionString; 403 | Cmd.CommandType = CommandType; 404 | Cmd.CommandText = sql; 405 | Cmd.Parameters.AddRange(param); 406 | Con.Open(); 407 | using (DbDataAdapter da = Factory.CreateDataAdapter()) 408 | { 409 | da.SelectCommand = Cmd; 410 | DataSet ds = new DataSet(); 411 | da.Fill(ds); 412 | return ds; 413 | } 414 | } 415 | catch 416 | { 417 | Con.Close(); 418 | throw; 419 | } 420 | } 421 | } 422 | } 423 | } 424 | 425 | public DataSet GetDataSet(string sql, params DbParameter[] param) 426 | { 427 | return GetDataSet(sql, CommandType.Text, param); 428 | } 429 | 430 | public DataTable GetDataTable(string sql, CommandType CommandType, params DbParameter[] param) 431 | { 432 | if (IsBeginTransaction) 433 | { 434 | try 435 | { 436 | Cmd.CommandType = CommandType; 437 | Cmd.CommandText = sql; 438 | Cmd.Parameters.AddRange(param); 439 | using (DbDataAdapter da = Factory.CreateDataAdapter()) 440 | { 441 | da.SelectCommand = Cmd; 442 | DataTable dt = new DataTable(); 443 | da.Fill(dt); 444 | return dt; 445 | } 446 | 447 | } 448 | catch 449 | { 450 | try 451 | { 452 | RollbackTransaction(); 453 | throw; 454 | } 455 | catch 456 | { 457 | throw; 458 | } 459 | } 460 | 461 | } 462 | else 463 | { 464 | using (Con = Factory.CreateConnection()) 465 | { 466 | using (Cmd = Con.CreateCommand()) 467 | { 468 | try 469 | { 470 | Con.ConnectionString = ConnectionString; 471 | Cmd.CommandType = CommandType; 472 | Cmd.CommandText = sql; 473 | Cmd.Parameters.AddRange(param); 474 | Con.Open(); 475 | using (DbDataAdapter da = Factory.CreateDataAdapter()) 476 | { 477 | da.SelectCommand = Cmd; 478 | DataTable dt = new DataTable(); 479 | da.Fill(dt); 480 | return dt; 481 | } 482 | } 483 | catch 484 | { 485 | Con.Close(); 486 | throw; 487 | } 488 | } 489 | } 490 | } 491 | } 492 | 493 | public DataTable GetDataTable(string sql, params DbParameter[] param) 494 | { 495 | return GetDataTable(sql, CommandType.Text, param); 496 | } 497 | 498 | public DataRow GetDataRow(string sql, int index, CommandType CommandType, params DbParameter[] param) 499 | { 500 | if (IsBeginTransaction) 501 | { 502 | try 503 | { 504 | Cmd.CommandType = CommandType; 505 | Cmd.CommandText = sql; 506 | Cmd.Parameters.AddRange(param); 507 | using (DbDataAdapter da = Factory.CreateDataAdapter()) 508 | { 509 | da.SelectCommand = Cmd; 510 | DataTable dt = new DataTable(); 511 | da.Fill(dt); 512 | if (dt != null && dt.Rows.Count > 0) 513 | { 514 | return dt.Rows[index]; 515 | } 516 | return null; 517 | } 518 | } 519 | catch 520 | { 521 | try 522 | { 523 | RollbackTransaction(); 524 | throw; 525 | } 526 | catch 527 | { 528 | throw; 529 | } 530 | } 531 | 532 | } 533 | else 534 | { 535 | using (Con = Factory.CreateConnection()) 536 | { 537 | using (Cmd = Con.CreateCommand()) 538 | { 539 | try 540 | { 541 | Con.ConnectionString = ConnectionString; 542 | Cmd.CommandType = CommandType; 543 | Cmd.CommandText = sql; 544 | Cmd.Parameters.AddRange(param); 545 | Con.Open(); 546 | using (DbDataAdapter da = Factory.CreateDataAdapter()) 547 | { 548 | da.SelectCommand = Cmd; 549 | DataTable dt = new DataTable(); 550 | da.Fill(dt); 551 | if (dt != null && dt.Rows.Count > 0) 552 | { 553 | return dt.Rows[index]; 554 | } 555 | return null; 556 | } 557 | } 558 | catch 559 | { 560 | Con.Close(); 561 | throw; 562 | } 563 | } 564 | } 565 | } 566 | } 567 | 568 | public DataRow GetDataRow(string sql, params DbParameter[] param) 569 | { 570 | return GetDataRow(sql, 0, CommandType.Text, param); 571 | } 572 | 573 | public DataRow GetDataRow(string sql, int index, params DbParameter[] param) 574 | { 575 | return GetDataRow(sql, index, CommandType.Text, param); 576 | } 577 | 578 | public DbParameterCollection ExecuteProc(string procName, params DbParameter[] param) 579 | { 580 | if (IsBeginTransaction) 581 | { 582 | try 583 | { 584 | Cmd.CommandType = CommandType.StoredProcedure; 585 | Cmd.CommandText = procName; 586 | Cmd.Parameters.AddRange(param); 587 | Cmd.ExecuteNonQuery(); 588 | return Cmd.Parameters; 589 | } 590 | catch 591 | { 592 | try 593 | { 594 | RollbackTransaction(); 595 | throw; 596 | } 597 | catch 598 | { 599 | throw; 600 | } 601 | } 602 | 603 | } 604 | else 605 | { 606 | using (Con = Factory.CreateConnection()) 607 | { 608 | using (Cmd = Con.CreateCommand()) 609 | { 610 | try 611 | { 612 | Con.ConnectionString = ConnectionString; 613 | Cmd.CommandType = CommandType.StoredProcedure; 614 | Cmd.CommandText = procName; 615 | Cmd.Parameters.AddRange(param); 616 | Con.Open(); 617 | Cmd.ExecuteNonQuery(); 618 | return Cmd.Parameters; 619 | } 620 | catch 621 | { 622 | Con.Close(); 623 | throw; 624 | } 625 | } 626 | } 627 | } 628 | } 629 | 630 | public DataSet ExecuteProcDataSet(string procName, params DbParameter[] param) 631 | { 632 | if (IsBeginTransaction) 633 | { 634 | try 635 | { 636 | Cmd.CommandType = CommandType.StoredProcedure; 637 | Cmd.CommandText = procName; 638 | Cmd.Parameters.AddRange(param); 639 | using (DbDataAdapter da = Factory.CreateDataAdapter()) 640 | { 641 | da.SelectCommand = Cmd; 642 | DataSet ds = new DataSet(); 643 | da.Fill(ds); 644 | return ds; 645 | } 646 | } 647 | catch 648 | { 649 | try 650 | { 651 | RollbackTransaction(); 652 | throw; 653 | } 654 | catch 655 | { 656 | throw; 657 | } 658 | } 659 | 660 | } 661 | else 662 | { 663 | using (Con = Factory.CreateConnection()) 664 | { 665 | using (Cmd = Con.CreateCommand()) 666 | { 667 | try 668 | { 669 | Con.ConnectionString = ConnectionString; 670 | Cmd.CommandType = CommandType.StoredProcedure; 671 | Cmd.CommandText = procName; 672 | Cmd.Parameters.AddRange(param); 673 | using (DbDataAdapter da = Factory.CreateDataAdapter()) 674 | { 675 | da.SelectCommand = Cmd; 676 | DataSet ds = new DataSet(); 677 | da.Fill(ds); 678 | return ds; 679 | } 680 | } 681 | catch 682 | { 683 | Con.Close(); 684 | throw; 685 | } 686 | } 687 | } 688 | } 689 | } 690 | 691 | public DataSet ExecuteProcDataSet(string procName, out DbParameterCollection dbpc, params DbParameter[] param) 692 | { 693 | if (IsBeginTransaction) 694 | { 695 | try 696 | { 697 | Cmd.CommandType = CommandType.StoredProcedure; 698 | Cmd.CommandText = procName; 699 | Cmd.Parameters.AddRange(param); 700 | using (DbDataAdapter da = Factory.CreateDataAdapter()) 701 | { 702 | da.SelectCommand = Cmd; 703 | DataSet ds = new DataSet(); 704 | da.Fill(ds); 705 | dbpc = da.SelectCommand.Parameters; 706 | return ds; 707 | } 708 | } 709 | catch 710 | { 711 | try 712 | { 713 | RollbackTransaction(); 714 | throw; 715 | } 716 | catch 717 | { 718 | throw; 719 | } 720 | } 721 | 722 | } 723 | else 724 | { 725 | using (Con = Factory.CreateConnection()) 726 | { 727 | using (Cmd = Con.CreateCommand()) 728 | { 729 | try 730 | { 731 | Con.ConnectionString = ConnectionString; 732 | Cmd.CommandType = CommandType.StoredProcedure; 733 | Cmd.CommandText = procName; 734 | Cmd.Parameters.AddRange(param); 735 | using (DbDataAdapter da = Factory.CreateDataAdapter()) 736 | { 737 | da.SelectCommand = Cmd; 738 | DataSet ds = new DataSet(); 739 | da.Fill(ds); 740 | dbpc = da.SelectCommand.Parameters; 741 | return ds; 742 | } 743 | } 744 | catch 745 | { 746 | Con.Close(); 747 | throw; 748 | } 749 | } 750 | } 751 | } 752 | } 753 | } 754 | } 755 | --------------------------------------------------------------------------------