`
ZOODragon
  • 浏览: 68696 次
  • 性别: Icon_minigender_1
  • 来自: 大连
文章分类
社区版块
存档分类
最新评论

<转>C#数据库封装类

阅读更多
 1using System;
  2using System.Collections.Generic;
  3using System.Text;
  4using System.Data;
  5using System.Configuration;
  6using System.Data.Common;
  7using System.Data.SqlClient;
  8using System.Data.OleDb;
  9using System.Data.Odbc;
 10using System.Data.OracleClient;
 11using System.IO;
 12
 13namespace BinaryIntellect.DataAccess
 14{
 15    public class DatabaseHelper:IDisposable
 16    {
 17        private string strConnectionString;
 18        private DbConnection objConnection;
 19        private DbCommand objCommand;
 20        private DbProviderFactory objFactory = null;
 21        private bool boolHandleErrors;
 22        private string strLastError;
 23        private bool boolLogError;
 24        private string strLogFile;
 25
 26        public DatabaseHelper(string connectionstring,Providers provider)
 27        {
 28            strConnectionString = connectionstring;
 29            switch (provider)
 30            {
 31                case Providers.SqlServer:
 32                    objFactory = SqlClientFactory.Instance;
 33                    break;
 34                case Providers.OleDb:
 35                    objFactory = OleDbFactory.Instance;
 36                    break;
 37                case Providers.Oracle:
 38                    objFactory = OracleClientFactory.Instance;
 39                    break;
 40                case Providers.ODBC:
 41                    objFactory = OdbcFactory.Instance;
 42                    break;
 43                case Providers.ConfigDefined:
 44                    string providername=ConfigurationManager.ConnectionStrings["connectionstring"].ProviderName;
 45                    switch (providername)
 46                    {
 47                        case "System.Data.SqlClient":
 48                            objFactory = SqlClientFactory.Instance;
 49                            break;
 50                        case "System.Data.OleDb":
 51                            objFactory = OleDbFactory.Instance;
 52                            break;
 53                        case "System.Data.OracleClient":
 54                            objFactory = OracleClientFactory.Instance;
 55                            break;
 56                        case "System.Data.Odbc":
 57                            objFactory = OdbcFactory.Instance;
 58                            break;
 59                    }
 60                    break;
 61
 62            }
 63            objConnection = objFactory.CreateConnection();
 64            objCommand = objFactory.CreateCommand();
 65
 66            objConnection.ConnectionString = strConnectionString;
 67            objCommand.Connection = objConnection;
 68        }
 69
 70        public DatabaseHelper(Providers provider):this(ConfigurationManager.ConnectionStrings["connectionstring"].ConnectionString,provider)
 71        {
 72        }
 73
 74        public DatabaseHelper(string connectionstring): this(connectionstring, Providers.SqlServer)
 75        {
 76        }
 77
 78        public DatabaseHelper():this(ConfigurationManager.ConnectionStrings["connectionstring"].ConnectionString,Providers.ConfigDefined)
 79        {
 80        }
 81
 82        public bool HandleErrors
 83        {
 84            get
 85            {
 86                return boolHandleErrors;
 87            }
 88            set
 89            {
 90                boolHandleErrors = value;
 91            }
 92        }
 93
 94        public string LastError
 95        {
 96            get
 97            {
 98                return strLastError;
 99            }
100        }
101
102        public bool LogErrors
103        {
104            get
105            {
106                return boolLogError;
107            }
108            set
109            {
110                boolLogError=value;
111            }
112        }
113
114        public string LogFile
115        {
116            get
117            {
118                return strLogFile;
119            }
120            set
121            {
122                strLogFile = value;
123            }
124        }
125
126        public int AddParameter(string name,object value)
127        {
128            DbParameter p = objFactory.CreateParameter();
129            p.ParameterName = name;
130            p.Value=value;
131            return objCommand.Parameters.Add(p);
132        }
133
134        public int AddParameter(DbParameter parameter)
135        {
136            return objCommand.Parameters.Add(parameter);
137        }
138
139        public DbCommand Command
140        {
141            get
142            {
143                return objCommand;
144            }
145        }
146
147        public void BeginTransaction()
148        {
149            if (objConnection.State == System.Data.ConnectionState.Closed)
150            {
151                objConnection.Open();
152            }
153            objCommand.Transaction = objConnection.BeginTransaction();
154        }
155
156        public void CommitTransaction()
157        {
158            objCommand.Transaction.Commit();
159            objConnection.Close();
160        }
161
162        public void RollbackTransaction()
163        {
164            objCommand.Transaction.Rollback();
165            objConnection.Close();
166        }
167
168        public int ExecuteNonQuery(string query)
169        {
170            return ExecuteNonQuery(query, CommandType.Text, ConnectionState.CloseOnExit);
171        }
172
173        public int ExecuteNonQuery(string query,CommandType commandtype)
174        {
175            return ExecuteNonQuery(query, commandtype, ConnectionState.CloseOnExit);
176        }
177
178        public int ExecuteNonQuery(string query,ConnectionState connectionstate)
179        {
180            return ExecuteNonQuery(query,CommandType.Text,connectionstate);
181        }
182
183        public int ExecuteNonQuery(string query,CommandType commandtype, ConnectionState connectionstate)
184        {
185            objCommand.CommandText = query;
186            objCommand.CommandType = commandtype;
187            int i=-1;
188            try
189            {
190                if (objConnection.State == System.Data.ConnectionState.Closed)
191                {
192                    objConnection.Open();
193                }
194                i = objCommand.ExecuteNonQuery();
195            }
196            catch (Exception ex)
197            {
198                HandleExceptions(ex);
199            }
200            finally
201            {
202                objCommand.Parameters.Clear();
203                if (connectionstate == ConnectionState.CloseOnExit)
204                {
205                    objConnection.Close();
206                }
207            }
208
209            return i;
210        }
211
212        public object ExecuteScalar(string query)
213        {
214            return ExecuteScalar(query, CommandType.Text, ConnectionState.CloseOnExit);
215        }
216
217        public object ExecuteScalar(string query,CommandType commandtype)
218        {
219            return ExecuteScalar(query, commandtype, ConnectionState.CloseOnExit);
220        }
221
222        public object ExecuteScalar(string query, ConnectionState connectionstate)
223        {
224            return ExecuteScalar(query, CommandType.Text, connectionstate);
225        }
226
227        public object ExecuteScalar(string query,CommandType commandtype, ConnectionState connectionstate)
228        {
229            objCommand.CommandText = query;
230            objCommand.CommandType = commandtype;
231            object o = null;
232            try
233            {
234                if (objConnection.State == System.Data.ConnectionState.Closed)
235                {
236                    objConnection.Open();
237                }
238                o = objCommand.ExecuteScalar();
239            }
240            catch (Exception ex)
241            {
242                HandleExceptions(ex);
243            }
244            finally
245            {
246                objCommand.Parameters.Clear();
247                if (connectionstate == ConnectionState.CloseOnExit)
248                {
249                    objConnection.Close();
250                }
251            }
252
253            return o;
254        }
255
256        public DbDataReader ExecuteReader(string query)
257        {
258            return ExecuteReader(query, CommandType.Text, ConnectionState.CloseOnExit);
259        }
260
261        public DbDataReader ExecuteReader(string query,CommandType commandtype)
262        {
263            return ExecuteReader(query, commandtype, ConnectionState.CloseOnExit);
264        }
265
266        public DbDataReader ExecuteReader(string query, ConnectionState connectionstate)
267        {
268            return ExecuteReader(query, CommandType.Text, connectionstate);
269        }
270
271        public DbDataReader ExecuteReader(string query,CommandType commandtype, ConnectionState connectionstate)
272        {
273            objCommand.CommandText = query;
274            objCommand.CommandType = commandtype;
275            DbDataReader reader=null;
276            try
277            {
278                if (objConnection.State == System.Data.ConnectionState.Closed)
279                {
280                    objConnection.Open();
281                }
282                if (connectionstate == ConnectionState.CloseOnExit)
283                {
284                    reader = objCommand.ExecuteReader(CommandBehavior.CloseConnection);
285                }
286                else
287                {
288                    reader = objCommand.ExecuteReader();
289                }
290
291            }
292            catch (Exception ex)
293            {
294                HandleExceptions(ex);
295            }
296            finally
297            {
298                objCommand.Parameters.Clear();
299            }
300
301            return reader;
302        }
303
304        public DataSet ExecuteDataSet(string query)
305        {
306            return ExecuteDataSet(query, CommandType.Text, ConnectionState.CloseOnExit);
307        }
308
309        public DataSet ExecuteDataSet(string query,CommandType commandtype)
310        {
311            return ExecuteDataSet(query, commandtype, ConnectionState.CloseOnExit);
312        }
313
314        public DataSet ExecuteDataSet(string query,ConnectionState connectionstate)
315        {
316            return ExecuteDataSet(query, CommandType.Text, connectionstate);
317        }
318
319        public DataSet ExecuteDataSet(string query,CommandType commandtype, ConnectionState connectionstate)
320        {
321            DbDataAdapter adapter = objFactory.CreateDataAdapter();
322            objCommand.CommandText = query;
323            objCommand.CommandType = commandtype;
324            adapter.SelectCommand = objCommand;
325            DataSet ds = new DataSet();
326            try
327            {
328                adapter.Fill(ds);
329            }
330            catch (Exception ex)
331            {
332                HandleExceptions(ex);
333            }
334            finally
335            {
336                objCommand.Parameters.Clear();
337                if (connectionstate == ConnectionState.CloseOnExit)
338                {
339                    if (objConnection.State == System.Data.ConnectionState.Open)
340                    {
341                        objConnection.Close();
342                    }
343                }
344            }
345            return ds;
346        }
347
348        private void HandleExceptions(Exception ex)
349        {
350            if (LogErrors)
351            {
352                WriteToLog(ex.Message);
353            }
354            if (HandleErrors)
355            {
356                strLastError = ex.Message;
357            }
358            else
359            {
360                throw ex;
361            }
362        }
363
364        private void WriteToLog(string msg)
365        {
366            StreamWriter writer= File.AppendText(LogFile);
367            writer.WriteLine(DateTime.Now.ToString() + " - " + msg);
368            writer.Close();
369        }
370        
371        public void Dispose()
372        {
373            objConnection.Close();
374            objConnection.Dispose();
375            objCommand.Dispose();
376        }
377
378    }
379
380    public enum Providers
381    {
382        SqlServer,OleDb,Oracle,ODBC,ConfigDefined
383    }
384
385    public enum ConnectionState
386    {
387        KeepOpen,CloseOnExit
388    }
389}

 

分享到:
评论

相关推荐

    绝佳C#数据库封装类

    标题:绝佳C#数据库封装类 描述:绝佳C#数据库封装类,非常详细,自己看吧 知识点: 一、C#数据库封装类的作用与优势 C#数据库封装类是一种用于简化数据库操作的代码封装方式,它能够将常见的数据库操作如连接、...

    一个绝佳C#数据库封装类

    "C# 数据库封装类详解" 本文将对 C# 数据库封装类进行详细的解释和分析,包括类的设计、成员变量、方法实现等方面。 类设计 DatabaseHelper 类是 C# 语言中的一种数据库封装类,它实现了 IDisposable 接口,提供...

    C#操作mysql数据库的封装类

    C#操作mysql数据库的封装类,带注释,代码完整,适合企业级开发

    c#几种常用数据库封装

    本文将深入探讨C#中几种常用的数据库封装技术,包括SQLite和BerkeleyDB,以及与数据库交互时涉及的序列化和通信机制。同时,我们将重点关注如何利用数据库连接池来优化性能。 首先,C#中的SQLite是一种轻量级、开源...

    c#.NET万能数据库访问封装类(ACCESS、SQLServer、Oracle)

    ### c#.NET万能数据库访问封装类:ACCESS、SQLServer、Oracle 在现代软件开发中,数据持久化是至关重要的一个环节,而数据库操作作为数据持久化的基础,其效率和可维护性直接影响到整个应用程序的性能和稳定性。...

    C#中oracle连接数据库的封装类

    在本场景中,我们关注的是一个名为"C#中oracle连接数据库的封装类"的主题,这个主题涉及到创建一个名为`DbHelperOra.cs`的类,用于简化与Oracle数据库的交互。这种封装可以提高代码的可读性和复用性,减少直接处理...

    C#数据库操作封装类

    在本场景中,我们讨论的是一个名为"C#数据库操作封装类"的自定义实现,它是一个dll库(myFunClsLib.DataBase.dll),用于简化对SQL Server、Access和Oracle这三种常见数据库的访问。下面我们将深入探讨这个封装类...

    c#操作MySQL数据库封装类

    这个"c#操作MySQL数据库封装类"很可能是为了简化数据库交互,提供一个易于使用的接口,以提高代码的可读性和可维护性。下面我们将详细讨论如何在C#中封装MySQL数据库操作类以及涉及的关键知识点。 1. **数据库连接*...

    C# 21天 电子教案 <<PPT>>

    【C# 21天 电子教案 &lt;&lt;PPT&gt;&gt;】是一个专门为学习C#编程语言设计的教程资源,采用PowerPoint格式,旨在通过21天的学习计划帮助初学者系统地掌握C#的基础和进阶知识。C#(读作"C Sharp")是由微软公司开发的一种面向...

    C#数据库封装class 1.1

    标题提到的"C#数据库封装class 1.1"就是这样一个尝试,旨在简化数据库连接、查询和其他操作的过程。在这个项目中,开发者创建了一个C#类,该类包含了与数据库交互的方法,以方便其他项目引用和使用。 首先,让我们...

    C#操作SQLite数据库帮助类详解

    本文档介绍了C#操作SQLite数据库帮助类的实现和封装技巧,主要涉及到C#针对sqlite数据库的连接、查询、分页等各种常见操作。通过本文,读者可以了解如何使用C#语言来操作SQLite数据库,从而实现离线存储数据和查询...

    CSharp数据库封装类(自己修改的)

    在C#编程中,数据库封装类是将数据库操作抽象化,提供一个简洁的接口供其他代码调用,以此来减少数据库交互的复杂性并提高代码的可维护性。本项目中,开发者创建了一个针对SQL Server数据库的封装类,采用了单例模式...

    c#NET万能数据库访问封装类(ACCESS、SQLServer、Oracle)文库[归类].pdf

    本文档主要介绍了一个使用C#语言开发的万能数据库访问封装类,該类支持ACCESS、SQLServer、Oracle等多种数据库管理系统。该类提供了统一的数据库访问接口,讓开发者可以轻松地访问不同类型的数据库。 首先,类...

    C#操作SqlServer数据库封装类

    C#操作sql server 的类分装,用于大部分的操作,修改,删除,添加,存储过程等等。

    c# 数据库通用类DbUtility

    《C#数据库通用类DbUtility详解》 在软件开发中,数据库操作是不可或缺的一部分,而高效、稳定的数据库访问工具能够极大地提升开发效率。C#语言中的`DbUtility`类就是一个典型的数据库通用类,旨在为开发者提供一个...

    C# 数据库操作封装类

    本主题将详细探讨“C#数据库操作封装类”的设计和应用,以及如何利用此类来简化数据库操作。 首先,"COleDbOperate.cs"文件可能包含一个通用的数据库操作类,它使用ADO.NET中的System.Data.OleDb命名空间,支持多种...

    C#通用数据库帮助类(MyDbHelper.cs)无需修改直接使用

    首先,`MyDbHelper.cs`是一个C#源代码文件,通常它会包含一个静态类或实例类,用于封装数据库操作的通用方法。这类帮助类的主要目的是简化数据库访问,减少重复代码,提高代码的可维护性和复用性。在`MyDbHelper`中...

    .net C# 数据库访问类

    总结来说,".NET C# 数据库访问类"是C#开发中用于简化数据库操作的工具,它们封装了与数据库交互的复杂性,提供统一的接口。DAR.DataAccess这个库很可能是一个多数据库支持的解决方案,能够帮助开发者更高效地管理...

    C#中的oracle数据库连接字符串,数据库帮助类,DBHelper.cs

    数据库帮助类(DBHelper.cs)是指封装了 Oracle 数据库连接和操作的类。该类通常包含了数据库连接、执行 SQL 语句、事务处理等功能。 下面是一个基本的数据库帮助类的实现: ```csharp public class OraDBHelper { ...

    C#数据库操作类,C#数据库操作类

    C#数据库操作类是用来连接、查询、插入、更新和删除数据库中的数据的一系列自定义类或方法。这些类通常封装了ADO.NET(.NET Framework的数据访问组件)中的基本操作,以提供更方便、更安全的数据库访问方式。 以下...

Global site tag (gtag.js) - Google Analytics