com.joybase.DB源代码

类别:.NET开发 点击:0 评论:0 推荐:

using System;
using System.Collections;
using System.Data;
using System.Globalization;
using System.ComponentModel;
using System.Drawing.Design;
using System.Windows.Forms.Design;
namespace com.joybase.DB
{
 /// <summary>
 /// <b>程序集名称:com.joybase.DB.dll(开发版)</b><br/>
 /// 版本号:1.4.0.0(for VS.NET正式版);<br/>
 /// 开发人员::开心就好<br/>
 /// </summary>
 /// <remarks>
 /// <b>电子邮件:</b>[email protected]<br/>
 /// <b>网站:</b>http://www.joycode.com(2001/12/1开通)<br/>
 /// 功能列表
 /// 本程序集由<font color="red"><b>开心就好</b></font>开发,如果您在使用中遇到任何疑问,可以<a href="mailto:[email protected]">致信反馈</a>,十分感谢,请在信件中给出使用的代码片段及出错的详细描述!<br/>
 /// 数据库操作类,效果有:<br/>
 /// 1.可以跨越任何ADO.NET支持的数据库;(已经支持,经过测试的数据有MS Access以及MS SQLServer2000,以及Oracle8i系列)<br/>
 /// 2.可以执行存储过程及普通SQL语句;(已经支持)<br/>
 /// 3.可以得到存储过程返回的值及出口参数;(已经支持)<br/>
 /// 4.简单的可以达到分页效果;(DataSet已经支持,DataReader已支持)<br/>
 /// 5.可以以DataSet、DataReader、DataTable以及无结果输出;<br/>
 /// 6.事务批处理功能(暂不支持)<br/>
 /// 7.日后将支持System.Data.ODBC驱动(暂不支持)<br/>
 /// <div align="center"><b>更新列表(1.3.0.1)</b></div>
 /// 1.增加了一个JoyBaseDBException异常类,用户可以自己捕捉异常<br/>
 /// 2.JoyBaseDBException异常类的Reason属性可以查阅当前异常的错误原因<br/>
 /// 3.更新了部分示例<br/>
 /// 4.本升级是由“蓝”请求而特意打造,在此表示一并感谢;<br/>
 /// <div align="center"><b>更新列表(1.3.0.0)</b></div><br/>
 /// 1.修改了原来的构造方法,加进了无参构造,去除了原来的单参构造方法;<br/>
 /// 2.新增加两个属性,即ConnectionSetName,相当于原来的构造方法中的单一入参,即在Config文件中配置连接字符串的键名,以及ConnectionString,可以直接赋入数据库连接字符串,如果此键赋入,则将覆盖原来的ConnectionStringSetName;<br/>
 /// 3.修改了原来的ExecuteDataTable的Bug;<br/>
 /// 4.修改了上一版本的两个分页方法,将out型参数提取为属性;<br/>
 /// 5.内部的一些其它小型Bug
 /// <div align="center"><b>更新列表(1.2.0.3)</b></div><br/>
 /// 1.去除了原来的Execute方法,将其执行分解为多个方法;<br/>
 /// 2.去除了ReturnType属性以及ResultType枚举类型。<br/>
 /// 3.增加了ExecuteNoresult方法,返回值为纪录影响数;<br/>
 /// 4.增加了ExecuteDataTable方法,返回一个System.Data.DataTable,该表的名称默认为“Table”<br/>
 /// 5.增加了ExecuteDataReader方法,返回一个System.Data.IDataReader对象<br/>
 /// 6.重载ExecuteDataReader方法,支持分页显示,参数列表为<br/>
 /// ExecuteDataReader(int PageSize,int CurrentPage,out int PageCount,out int PageSize)<br/>
 /// PageSize:每页显示的纪录数;<br/>
 /// CurrentPage;需要返回的页面号;<br/>
 /// PageCount:回参,返回页面总数;<br/>
 /// PageSize:回参,返回纪录总数;<br/>
 /// 7.增加了ExecuteDataSet方法,并且有四次重载,分别是<br/>
 /// (1)ExecuteDataSet()<br/>
 /// 返回一个System.Data.DataSet<br/>
 /// (2)ExecuteDataSet(string TableName);<br/>
 /// 入参为表的名称;<br/>
 /// (3)ExecuteDataSet(string Tablename,int StartRecord,int MaxRecord);<br/>
 /// 返回从第StartRecord条纪录开始数的总共MaxRecord条纪录。<br/>
 /// (4)ExecuteDataSet(string TableName,int PageSize,int CurrentPage,out int PageCount,out int RecordCount)<br/>
 /// 请参阅关于DataReader分页方法的叙述。<br/>
 ///
 /// </remarks>
 /// <example>
 ///
 /// 注意:在运行示例之前,您必须满足以下条件:<ol><li>请先在您的配置文件(如果是ASP.NET程序为Web.Config,如果是Win Form程序,则为App.Config文件,加上以下一句话:
 /// &lt;appSettings&gt;<br/>
 ///     &lt;add key="DSN" value="server=(local)\NetSDK;database=Northwind;Trusted_Connection=yes" /&gt;<br/>
 /// &lt;/appSettings\&gt;<br/>
 /// 请注意,这句话必须加在配置文件的根节点,即&lt;configuration&gt;之下</li>
 /// <li>您已经安装了微软的MSDE数据库,如果您没有安装,可以在您的VS.NET安装目录下查找到,如我安装在E盘,则MSDE的安装程序为E:\Program Files\Microsoft Visual Studio .NET\FrameworkSDK\Samples\Setup\msde\instmsde.exe,另外,请保证您的MSDE已经启动,可以在命令行使用net start MSSQL$NetSDK 将其进行启动</li>
 /// <li>以下示例仅是给出了MS SQL Server的桌面数据库的示例,在您有条件的情况下,您可以使用其它数据库来做试验,如果有任何问题,可以与我联系</li>
 /// </ol>
 /// <b>例一:执行查询操作,以DataReader返回结果集</b><br/>
 /// <code>
 /// //请注意,此处的"DSN"为您在配置文件中所给的键名,而不是值;<br/>
 /// try<br/>
 /// {<br/>
 ///     Command command=new Command();<br/>
 ///     command.ConnectionString="server=(local)\NetSDK;database=Northwind;Trusted_Connection=yes";<br/>
 ///     command.CommandText="select * from orders where orderid=@orderid";<br/>
 ///      //下面的orders对应于SQL语句中的字段名,同时,如果查询语句为存储过程,此处请插入相应的入参;<br/>
 ///     command.Parameters["orderid"]=10249;<br/>
 ///      System.Data.IDataReader dr=command.ExecuteDataReader();<br/>
 /// }<br/>
 /// catch(JoyBaseDBException e)<br/>
 /// {<br/>
 ///     //根据下面的示例你可以自己制作自己的异常捕捉;<br/>
 ///     Console.WriteLine("错误信息为:"+e.Message);<br/>
 ///     Console.WriteLine("错误可能原因为:"+e.Reason);<br/>
 /// }<br/>
 ///
 ///if(dr.read())<br/>
 ///{<br/>
 ///   //读取数据,按照您原来对DataReader的操作方法即可;<br/>
 ///    ...<br/>
 /// }<br/>
 /// else<br/>
 /// {<br/>
 ///      //执行您的异常操作;<br/>
 ///      ...<br/>
 /// <br/>
 /// }<br/>
 /// dr.Close();<br/>
 /// </code>
 /// <b>例二:执行查询操作,并且返回DataSet对象:</b><br/>
 /// <code>
 /// Command command=new Command();<br/>
 /// command.ConnectionSetName="DSN";<br/>
 /// command.CommandText="select * from orders";<br/>
 /// //下面我们分别返回几个DataSet对象<br/>
 /// //第一种是带默认表名为DataSet为“Table”的DataSet<br/>
 /// System.Data.DataSet ds1=command.ExecuteDataSet();<br/>
 /// //然后再返回一个自定义表名为“TableName”的对象<br/>
 /// System.Data.DataSet ds2=command.ExecuteDataSet("TableName");<br/>
 /// //再返回一个DataSet,我们将限制结果集的返回,假设从第12个纪录开始,查询50个纪录出来<br/>
 /// System.Data.DataSet ds3=command.ExecuteDataSet("TableName",12,50);<br/>
 /// //同时,你如果乐意,还可以只返回一个DataTable<br/>
 /// System.Data.DataTable table=command.Execute.DataTable();<br/>
 /// //现在您可以执行数据绑定操作了,直接取它的defaultView即可<br/>
 /// ...<br/>
 /// </code>
 /// <b>例三:执行分页查询,并且返回DataSet对象以及DataReader对象</b><br/>
 /// <code>
 /// Command command=new Command();<br/>
 /// command.ConnectionSetName="DSN";<br/>
 /// command.CommandText="select * from orders";<br/>
 /// command.PageSize=30;<br/>
 /// //此处您可以用变量替代,即可以达到动态分页的效果<br/>
 /// int CurrentPage=1;<br/>
 /// System.Data.DataSet ds=command.ExecuteDataSet("ordersTable",CurrentPage);<br/>
 /// //执行绑定操作,这样DataList以及其它数据绑定控件均支持分页了(您还得做一些操作,如当前页面数不要大于页面总数也不要小于等于0等的判断)<br/>
 /// ...<br/>
 /// //下面输出DataReader<br/>
 /// System.Data.IDataReader dr=command.ExecuteDataReader(CurrentPage);<br/>
 /// int i=0;<br/>
 /// while(dr.read())<br/>
 /// {<br/>
 ///     //执行您需要的操作<br/>
 ///     ....<br/>
 ///
 /// }<br/>
 /// string showText="共有纪录"+command.RecordSet+"条,共有"+command.PageCount+"页,当前显示第"+CurrentPage+"页";<br/>
 /// <br/>
 /// </code>
 /// </example>
 
 public class Command
 {
  //private DBParameters m_Parameters;
  /// <summary>
  /// 数据库命令,System.Data.IDbCommand接口类型
  /// </summary>
  private System.Data.IDbCommand m_command;
  /// <summary>
  /// 内部参数,每页的纪录数
  /// </summary>
  private int m_PageSize;
  /// <summary>
  /// 总共的页数
  /// </summary>
  private int m_PageCount;
  /// <summary>
  /// 总共的纪录数
  /// </summary>
  private int m_RecordCount;
        /// <summary>
  /// SQL语句及存储过程的命令文本,字符串类型
  /// </summary>
  private string m_CommandText;
  
  /// <summary>
  /// 命令参数集合
  /// </summary>
  private System.Collections.Hashtable m_Parameter;
  /// <summary>
  /// 只写属性,将连接字符串在Config文件中的键名赋值进来
  /// </summary>
  [Category("(Data Binding)"),Description("数据库连接字符串在Config文件中的键名")]
  public string ConnectionSetName
  {
   set
   {
    Provider.ConnectionSetName=value;

   }
  }
  /// <summary>
  /// 只读属性,返回总共的页数
  /// </summary>
  [Browsable(false)]
  public int PageCount
  {
   get
   {
    return this.m_PageCount;
   }
  }
  /// <summary>
  /// 只写属性,设置每页的纪录数
  /// </summary>
  [Category("Pager Info"),Description("每页显示的纪录数")]
  public int PageSize
  {
   set
   {
    this.m_PageSize=value;
   }
  }
  /// <summary>
  /// 只读属性,获得总共的纪录数
  /// </summary>
  [Browsable(false)]
  public int RecordCount
  {
   get
   {
    return this.m_RecordCount;
   }
  }
  /// <summary>
  /// 构造方法
  /// </summary>
  public Command()
  {
   this.m_PageCount=0;
   this.m_PageSize=0;
   this.m_RecordCount=0;
   m_CommandText="";
   m_Parameter=new System.Collections.Hashtable();

  }
  /// <summary>
  /// 只写属性,连接字符串,注意,本属性可以覆盖ConnectionSetName属性的值
  /// </summary>
  [Browsable(true),Category("(Data Binding)"),Description("设置数据库连接字符串"),Editor(typeof(FolderNameEditor), typeof(UITypeEditor))]
  public string test
  {
   get
   {
    System.Resources.ResourceManager rm=new System.Resources.ResourceManager(typeof(Command));
    return rm.GetString("hello");
   }
  }
  public string ConnectionString
  {
   set
   {
    Provider.ConnectionString=value;
   }
  }
  
  /// <summary>
  /// 字符串类型,SQL语句及存储过程的命令文本,只读
  /// </summary>
  /// <remarks>
  /// SQL语句可以以入参方式表示,如"select * from user where username=@username"即为一个合法的命令文本,我们可以以参数形式动态为@username赋值
  /// </remarks>
  
  [Category("(DataBinding"),Description("需要执行的SQL查询的文本以及存储过程的名称")]
  public string CommandText
  {
   set
   {
    
    m_command=Provider.getConn().CreateCommand();
    //this.m_Parameters=(DBParameters)this.m_command.Parameters;
    
    this.m_CommandText=value;
    
    
   }
   
  }
  /// <summary>
  /// 设置当前的参数类型。
  /// </summary>
  [Category("(Data Binding)"),Description("设置连接字符串")]
  public System.Collections.Hashtable Parameter
  {
   set
   {
    this.m_Parameter=value;
   
   }
   get
   {
    return this.m_Parameter;
   

   }
  }
//  /// <summary>
//  /// 暂不支持
//  /// </summary>
//  public DBParameters Parameters
//  {
//   get
//   {
//    return this.m_Parameters;
//    
//
//   }
//   set
//   {
//    this.m_Parameters=value;
//   }
//  }
//  
  /// <summary>
  /// 得到出口参数的值,仅在命令文本为存储过程且设置了出口参数时有效;
  /// </summary>
  public System.Data.IDataParameterCollection ReturnValue
  {
   get
   {
    
    return this.m_command.Parameters;
    
   }
  }
  /// <summary>
  /// 内部处理方法,不对外公开
  /// </summary>
  private void Prepare()
  {
   //System.Threading.Thread.GetDomain().UnhandledException+=new UnhandledExceptionEventHandler(ThrowDBException);
   
   try
   {
    //m_command=Provider.getConn().CreateCommand();
    m_command.CommandText=this.m_CommandText;
    System.Collections.IDictionaryEnumerator One=this.m_Parameter.GetEnumerator();
    while(One.MoveNext())
    {
     
     System.Data.IDataParameter parameter=this.m_command.CreateParameter();
     parameter.SourceVersion =System.Data.DataRowVersion.Current;
     
     parameter.Value=One.Value;
     parameter.ParameterName=(string)One.Key;
     this.m_command.Parameters.Add(parameter);
    }
    this.m_command.Connection.Close();
    this.m_command.Connection.Open();
    //this.m_command.Prepare();
    
   }
   catch(Exception e)
   {
    string reason="(1)SQL语句或者存储过程使用不当,或者将特定数据库的检索语句使用到了不当的数据库上;\r\n(2)SQL语句或者存储过程的入参的的赋值错误,如将字符串赋给了int类型等\r\n";
    throw new JoyBaseDBException(e.Message,reason);
   }

  }
  /// <summary>
  /// 执行一次更新或者插入操作
  /// </summary>
  /// <returns>返回该次操作所影响的纪录集数</returns>
  public int ExecuteNoResult()
  {
   this.Prepare();
   int result=0;
   try
   {

    result=this.m_command.ExecuteNonQuery();
   }
   catch(Exception e)
   {
    throw new JoyBaseDBException(e.Message,e);
   }
   
   //this.m_Parameters.Clear();
   return result;
   
  }
  /// <summary>
  /// 执行查询操作,并且按照规定的分页形式返回DataReader结果集
  /// </summary>
  /// <param name="p_CurrentPageIndex">需要返回的页面号</param>
  /// <returns>返回一个System.Data.IDataReader方法</returns>
  public System.Data.IDataReader ExecuteDataReader(int p_CurrentPageIndex)
  {
   System.Data.IDataReader result=null;
   this.Prepare();
   try
   {
    result=this.m_command.ExecuteReader();
    System.Data.DataSet ds=this.ExecuteDataSet();
    
    this.m_RecordCount=ds.Tables[0].Rows.Count;
    //
    ds.Clear();
    ds.Dispose();
    if(this.m_RecordCount%this.m_PageSize==0)
    {
     this.m_PageCount=this.m_RecordCount/this.m_PageSize;

    }
    else
    {
     this.m_PageCount=this.m_RecordCount/this.m_PageSize+1;
    }
    int StartCount=(p_CurrentPageIndex-1)*this.m_PageSize;
   
    for(int i=0;i<StartCount;i++)
    {
     result.Read();
    }
    
   }
   catch(Exception e)
   {
    string reason="(1)未设置PageSize变量或者将其设为不合理数值,而直接调用了分页方法\r\n;(2)检索的页号不存在或者溢出;\r\n";
    throw new JoyBaseDBException(e.Message,reason);
   }
   //this.m_Parameters.Clear();
   return result;

  }
  /// <summary>
  /// 执行一个查询操作,并且以System.Data.IDataReader()来返回结果集
  /// </summary>
  /// <returns>返回的System.Data.IDataReader</returns>
  public System.Data.IDataReader ExecuteDataReader()
  {
   
   System.Data.IDataReader result=null;
   this.Prepare();
   try
   {
    result=this.m_command.ExecuteReader();
   }
   catch(Exception e)
   {
    throw new JoyBaseDBException(e.Message,e);
   }
   //this.m_Parameters.Clear();
   return result;

 

  }
  /// <summary>
  /// 执行一个查询操作,并且返回一个DataTable
  /// </summary>
  /// <returns>返回一个DataTable</returns>
  public System.Data.DataTable ExecuteDataTable()
  {
   this.Prepare();
   System.Data.DataTable result=new System.Data.DataTable();
   //System.Data.Common.DbDataAdapter Adapter=null;
   try
   {
    if(Provider.Type==DBType.SqlClient)
    {
     System.Data.SqlClient.SqlDataAdapter Adapter=new System.Data.SqlClient.SqlDataAdapter((System.Data.SqlClient.SqlCommand)this.m_command);
     //Adapter.SelectCommand=new System.Data.SqlClient.SqlCommand(,(System.Data.SqlClient.SqlConnection)Provider.getConn());//(System.Data.SqlClient.SqlCommand)this.m_command;

     Adapter.Fill(result);
    

    }
    else
    {
     System.Data.OleDb.OleDbDataAdapter Adapter=new System.Data.OleDb.OleDbDataAdapter((System.Data.OleDb.OleDbCommand)this.m_command);
     //Adapter.SelectCommand=(System.Data.OleDb.OleDbCommand)this.m_command;
     Adapter.Fill(result);
    }
   }
   catch(Exception e)
   {
    throw new JoyBaseDBException(e.Message,e);
   }
   //this.m_Parameters.Clear();
   return result;
   

  }
  /// <summary>
  /// 返回分页的DataSet页面
  /// </summary>
  /// <param name="p_TableName">DataSet中的表名</param>
  /// <param name="p_CurrentPageIndex">需要返回的页面</param>
  /// <returns></returns>
  public System.Data.DataSet ExecuteDataSet(string p_TableName,int p_CurrentPageIndex)

  {
   System.Data.DataSet ds=this.ExecuteDataSet();
   try
   {
    
    
    this.m_RecordCount=ds.Tables[0].Rows.Count;
    //
    ds.Clear();
    ds.Dispose();
    if(this.m_RecordCount%this.m_PageSize==0)
    {
     this.m_PageCount=this.m_RecordCount/this.m_PageSize;

    }
    else
    {
     this.m_PageCount=this.m_RecordCount/this.m_PageSize+1;
    }
    int StartCount=(p_CurrentPageIndex-1)*this.m_PageSize;
    ds=this.ExecuteDataSet(p_TableName,StartCount,this.m_PageSize);
   }
   catch(Exception e)
   {
    string reason="(1)未设置PageSize变量或者将其设为不合理数值,而直接调用了分页方法\r\n;(2)检索的页号不存在或者溢出;\r\n";
    throw new JoyBaseDBException(e.Message,reason);
   }
   //this.m_Parameters.Clear();

   return ds;


  }
  /// <summary>
  /// 执行一个查询操作,并且返回一个DataSet对象,能够执行分页操作
  /// </summary>
  /// <param name="p_StartRecord">起始的记录号,以0开始</param>
  /// <param name="p_MaxRecords">返回的最多的记录号</param>
  /// <param name="p_TableName">返回的DataSet中包含的表的名称</param>
  /// <returns>返回一个DataSet对象</returns>
  public System.Data.DataSet ExecuteDataSet(string p_TableName,int p_StartRecord,int p_MaxRecords)
  {
   this.Prepare();
   System.Data.DataSet result=new System.Data.DataSet();
   //System.Data.Common.DbDataAdapter Adapter=null;
   try
   {
    if(Provider.Type==DBType.SqlClient)
    {
     System.Data.SqlClient.SqlDataAdapter Adapter=new System.Data.SqlClient.SqlDataAdapter((System.Data.SqlClient.SqlCommand)this.m_command);
     //Adapter.SelectCommand=new System.Data.SqlClient.SqlCommand("select * from orders",(System.Data.SqlClient.SqlConnection)Provider.getConn("DSN"));//(System.Data.SqlClient.SqlCommand)this.m_command;

     Adapter.Fill(result,p_StartRecord,p_MaxRecords,p_TableName);
    

    }
    else
    {
     System.Data.OleDb.OleDbDataAdapter Adapter=new System.Data.OleDb.OleDbDataAdapter((System.Data.OleDb.OleDbCommand)this.m_command);
     //Adapter.SelectCommand=(System.Data.OleDb.OleDbCommand)this.m_command;
     Adapter.Fill(result,p_StartRecord,p_MaxRecords,p_TableName);
    }
   }
   catch(Exception e)
   {
    throw new JoyBaseDBException(e.Message,e);
   }
   //this.m_Parameters.Clear();
   return result;
   

  }
  /// <summary>
  /// 执行查询操作,并且返回一个DataSet对象
  /// </summary>
  /// <param name="p_TableName">DataSet中包含的表的名称</param>
  /// <returns>返回一个DataSet对象</returns>
  public System.Data.DataSet ExecuteDataSet(string p_TableName)
  {
   this.Prepare();
   System.Data.DataSet result=new System.Data.DataSet();
   try
   {
    //System.Data.Common.DbDataAdapter Adapter=null;
    if(Provider.Type==DBType.SqlClient)
    {
     System.Data.SqlClient.SqlDataAdapter Adapter=new System.Data.SqlClient.SqlDataAdapter((System.Data.SqlClient.SqlCommand)this.m_command);
     //Adapter.SelectCommand=new System.Data.SqlClient.SqlCommand("select * from orders",(System.Data.SqlClient.SqlConnection)Provider.getConn("DSN"));//(System.Data.SqlClient.SqlCommand)this.m_command;

     Adapter.Fill(result,p_TableName);
    

    }
    else
    {
     System.Data.OleDb.OleDbDataAdapter Adapter=new System.Data.OleDb.OleDbDataAdapter((System.Data.OleDb.OleDbCommand)this.m_command);
     //Adapter.SelectCommand=(System.Data.OleDb.OleDbCommand)this.m_command;
     Adapter.Fill(result,p_TableName);
    }
   }
   catch(Exception e)
   {
    

    throw new JoyBaseDBException(e.Message,e);
   }
   //this.m_Parameters.Clear();
   return result;
   

  }
  /// <summary>
  /// 执行查询操作,并且返回一个DataSet对象
  /// </summary>
  /// <returns>返回一个DataSet对象,并且其中的DataSet中的表名称为默认的“Table”</returns>
  public System.Data.DataSet ExecuteDataSet()
  {
   this.Prepare();
   System.Data.DataSet result=new System.Data.DataSet();
   try
   {
    if(Provider.Type==DBType.SqlClient)
    {
     System.Data.SqlClient.SqlDataAdapter Adapter=new System.Data.SqlClient.SqlDataAdapter((System.Data.SqlClient.SqlCommand)this.m_command);
     

     Adapter.Fill(result);

    }
    else
    {
     System.Data.OleDb.OleDbDataAdapter Adapter=new System.Data.OleDb.OleDbDataAdapter((System.Data.OleDb.OleDbCommand)this.m_command);
     
     Adapter.Fill(result);
    }
   }
   catch(Exception e)
   {
    throw new JoyBaseDBException(e.Message,e);
   }
   //this.m_Parameters.Clear();
   return result;
   

  }
  
  
  /// <summary>
  /// 内部保护的数据库连接类
  /// </summary>
  protected abstract class Provider
  {
   //一个静态的连接接口;
   private static System.Data.IDbConnection conn;
   /// <summary>
   /// 构造方法,设为私有类型,是防止外部无效的引用;
   /// </summary>
   protected Provider()
   {
    System.Data.IDbCommand x=new System.Data.OleDb.OleDbCommand();
   }

   /// <summary>
   /// 返回数据库边接类型
   /// </summary>
   public static DBType Type
   {
    get
    {
     
     return Provider.m_DBType;
    }
    set
    {
     Provider.m_DBType=value;
    }
   }
   private static string m_ConnectionString;
   private static string m_ConnectionStringSetName;
   /// <summary>
   /// 数据库连接字符串设置名称
   /// </summary>
   public static string ConnectionSetName
   {
    set
    {
     Provider.m_ConnectionStringSetName=value;

    }
   }
   /// <summary>
   /// 数据库连接字符串
   /// </summary>
   public static string ConnectionString
   {
    set
    {
     Provider.m_ConnectionString=value;

    }
   }
   private static DBType m_DBType;
   
   /// <summary>
   /// 获得数据库连接接口
   /// </summary>
   /// <returns>返回一个连接</returns>
   public static System.Data.IDbConnection getConn()
   {
    string ConnStr="";
    try{
    //System.Threading.Thread.GetDomain().UnhandledException+=new UnhandledExceptionEventHandler(ThrowDBException);
     if(Provider.m_ConnectionString==""||Provider.m_ConnectionString==null)
     {
      if(Provider.m_ConnectionStringSetName.Trim()=="")
      {
       ConnStr=System.Configuration.ConfigurationSettings.AppSettings["DataBase.ConnectionString"];
      }
      else
      {
       ConnStr=System.Configuration.ConfigurationSettings.AppSettings[Provider.m_ConnectionStringSetName];
      }
      

     }
     else
     {
      ConnStr=Provider.m_ConnectionString;
     }
     if(ConnStr==null||ConnStr=="")
     {
      throw new JoyBaseDBException("连接字符串为空或者是null类型,请检查您的ConnectionString以及ConnectionSetName是否进行正确设置,或者阅读相关说明.");
     }
     //DBType m_DBType;//=Provider.DataBaseType;
     /*                             
      * 注释:我们对前面的编码进行了部分的修改,鉴于System.Data.SqlClient的连接
      * 字符串当中不可能出现"Provider"字样,所以我们根据是否有Provider字样来判断
      * 该连接是基于System.Data.SqlClient的或者System.Data.OleDB的。
      * 参考资料:
      * 可以将 ConnectionString 属性设置为单个单元。(不能为 SqlConnection 对象指定 Provider 属性。)
      * –或–
      *
      * 可以设置单个属性(DataSource、Database、UserName 等等)。如果设置单个属性,则将为您生成连接字符串。
      * 注意   在连接字符串中存储用户名和密码有安全性设置的意味。有关详细信息,请参阅Introduction to ADO.NET Connection Design Tools。
      *
      */
     if(ConnStr.ToLower().IndexOf("provider")==-1) Provider.Type=DBType.SqlClient;
     else Provider.Type=DBType.OleDB;
     //throw new Exception("here");
    
     if(m_DBType==DBType.SqlClient)
     {
      conn=new System.Data.SqlClient.SqlConnection(ConnStr);
     }
     else
     {
      conn=new System.Data.OleDb.OleDbConnection(ConnStr);
     }
    }
    catch(Exception e)
    {
     string reason="(1)未设置数据库连接字符串,请重新检查连接字符串\r\n(2)目标数据库不存在,或者是没有启动数据库或者无法登录;\r\n(3)连接字符串设置不正确,请按照标准的连接方式来写。\r\n";
     throw new JoyBaseDBException(e.Message,reason);
    }
    return conn;
   }
  }
 }

 /// <summary>
 /// 枚举类型,即一个数据库连接类型的枚举
 /// </summary>
 public enum DBType
 {
  /// <summary>
  /// SQL方式连接
  /// </summary>
  SqlClient=0,
  /// <summary>
  /// OLEDB方式连接
  /// </summary>
  OleDB=1
 }
 /// <summary>
 /// 本程序集的异常信息
 /// </summary>
 public class JoyBaseDBException:Exception
 {
  /// <summary>
  /// 构造方法
  /// </summary>
  public JoyBaseDBException():base()
  {
   this.HelpLink="http://www.joycode.com";
   this._Reason="无特定原因";
  }
  /// <summary>
  /// 构造方法
  /// </summary>
  /// <param name="message">错误信息</param>
  public JoyBaseDBException(string message):base("com.joybase.DB.dll Exception Message:"+message)
  {
   //this.Message=message;
   this._Reason="无特定原因";
   this.HelpLink="http://www.joycode.com";
  }
  /// <summary>
  /// 构造方法
  /// </summary>
  /// <param name="message">错误信息</param>
  /// <param name="e">内部异常</param>
  public JoyBaseDBException(string message,System.Exception e):base("com.joybase.DB.dll Exception Message:"+message,e)
  {
   //this.Message=;
   this.HelpLink="http://www.joycode.com";
   this._Reason="无特定原因";
  }
  /// <summary>
  /// 构造方法
  /// </summary>
  /// <param name="message">错误信息</param>
  /// <param name="reason">错误原因</param>
  public JoyBaseDBException(string message,string reason):base("com.joybase.DB.dll Exception Message:"+message+".更多信息请捕捉本异常的Reason变量")
  {

   this._Reason="可能原因如下:\r\n"+reason;
  }

  private string _Reason;
  /// <summary>
  /// 错误原因,只读
  /// </summary>
  public string Reason
  {
   get
   {
    return this._Reason;
   }
  }
  
 }
// /// <summary>
// ///
// /// </summary>
// public class DBParameter:IDataParameter
// {
//  DbType m_dbType  = DbType.Object;
//  ParameterDirection m_direction = ParameterDirection.Input;
//  bool m_fNullable  = false;
//  string m_sParamName;
//  string m_sSourceColumn;
//  DataRowVersion m_sourceVersion = DataRowVersion.Current;
//  object m_value;
//
//  public DBParameter()
//  {
//  }
//
//  public DBParameter(string parameterName, DbType type)
//  {
//   m_sParamName = parameterName;
//   m_dbType   = type;
//  }
//
//  public DBParameter(string parameterName, object value)
//  {
//   m_sParamName = parameterName;
//   this.Value = value;  
//   // Setting the value also infers the type.
//  }
//
//  public DBParameter( string parameterName, DbType dbType, string sourceColumn )
//  {
//   m_sParamName  = parameterName;
//   m_dbType    = dbType;
//   m_sSourceColumn = sourceColumn;
//  }
//
//  public DbType DbType
//  {
//   get  { return m_dbType; }
//   set  { m_dbType = value;  }
//  }
//
//  public ParameterDirection Direction
//  {
//   get { return m_direction; }
//   set { m_direction = value; }
//  }
//
//  public Boolean IsNullable
//  {
//   get { return m_fNullable; }
//  }
//
//  public String ParameterName
//  {
//   get { return m_sParamName; }
//   set { m_sParamName = value; }
//  }
//
//  public String SourceColumn
//  {
//   get { return m_sSourceColumn; }
//   set { m_sSourceColumn = value; }
//  }
//
//  public DataRowVersion SourceVersion
//  {
//   get { return m_sourceVersion; }
//   set { m_sourceVersion = value; }
//  }
//
//  public object Value
//  {
//   get
//   {
//    return m_value;
//   }
//   set
//   {
//    m_value    = value;
//    m_dbType  = _inferType(value);
//   }
//  }
//
//  private DbType _inferType(Object value)
//  {
//   switch (Type.GetTypeCode(value.GetType()))
//   {
//    case TypeCode.Empty:
//     throw new SystemException("Invalid data type");
//
//    case TypeCode.Object:
//     return DbType.Object;
//
//    case TypeCode.DBNull:
//    case TypeCode.Char:
//    case TypeCode.SByte:
//    case TypeCode.UInt16:
//    case TypeCode.UInt32:
//    case TypeCode.UInt64:
//     // Throw a SystemException for unsupported data types.
//     throw new SystemException("Invalid data type");
//
//    case TypeCode.Boolean:
//     return DbType.Boolean;
//
//    case TypeCode.Byte:
//     return DbType.Byte;
//
//    case TypeCode.Int16:
//     return DbType.Int16;
//
//    case TypeCode.Int32:
//     return DbType.Int32;
//
//    case TypeCode.Int64:
//     return DbType.Int64;
//
//    case TypeCode.Single:
//     return DbType.Single;
//
//    case TypeCode.Double:
//     return DbType.Double;
//
//    case TypeCode.Decimal:
//     return DbType.Decimal;
//
//    case TypeCode.DateTime:
//     return DbType.DateTime;
//
//    case TypeCode.String:
//     return DbType.String;
//
//    default:
//     throw new SystemException("Value is of unknown data type");
//   }
//  }
// }
//
// public class DBParameters: System.Collections.ArrayList,IDataParameterCollection
// {
//  //private DBParameter x[int];
////  public object this[string index]
////  {
////   get;set;
////  }
//
//  public object this[string index]
//  {
//   get
//   {
//    
//    return this[IndexOf(index)];
//   }
//   set
//   {
//    this[IndexOf(index)] = value;
//   }
//  }
//
//
////  public DBParameter this[string x]
////  {
////   get
////   {
////   }
////   set
////   {
////   }
////  }
////  public DBParameter this[string index]
////  {
////   get
////   {
////    return (DBParameter)this[IndexOf(index)];
////    
////    
////   }
////   set
////   {
////    this[IndexOf(index)]=value;
////   }
////  }
////  public DBParameter this[int index]
////  {
////   get
////   {
////    return (DBParameter)this[index];
////   }
////   set
////   {
////    this[index]=value;
////   }
////  }
//
//  public bool Contains(string parameterName)
//  {
//   return(-1 != IndexOf(parameterName));
//   
//  }
//
//  public int IndexOf(string parameterName)
//  {
//   int index = 0;
//   foreach(System.Data.IDataParameter item in this)
//   {
//    if (0 == _cultureAwareCompare(item.ParameterName,parameterName))
//    {
//     return index;
//    }
//    index++;
//   }
//   return -1;
//  }
//
//  public void RemoveAt(string parameterName)
//  {
//   RemoveAt(IndexOf(parameterName));
//  }
//
//  public override int Add(object value)
//  {
//   return Add((DBParameter)value);
//  }
//
//  public int Add(DBParameter valueIn)
//  {
//   if (valueIn.ParameterName != null)
//   {
//    return base.Add(valueIn);
//   }
//   else
//    throw new ArgumentException("parameter must be named");
//  }
//
//  public int Add(string parameterName, System.Data.DbType type)
//  {
//   return Add(new DBParameter(parameterName, type));
//  }
//
//  public int Add(string parameterName, object value)
//  {
//   return Add(new DBParameter(parameterName, value));
//  }
//
//  public int Add(string parameterName, DbType dbType, string sourceColumn)
//  {
//   return Add(new DBParameter(parameterName, dbType, sourceColumn));
//  }
//
//  private int _cultureAwareCompare(string strA, string strB)
//  {
//   return System.Globalization.CultureInfo.CurrentCulture.CompareInfo.Compare(strA, strB, System.Globalization.CompareOptions.IgnoreKanaType | CompareOptions.IgnoreWidth | CompareOptions.IgnoreCase);
//  }
//
//  
//
//  
// }

// public abstract class datareader:system.data.idatareader
// {
//  public abstract int depth {get;}
//  public abstract bool isclosed{get;}
//  public abstract int recordsaffected{get;}
//  public abstract void close();
//  public abstract bool nextresult();
//  public abstract bool read();
//  public abstract datatable getschematable();
//  public abstract int fieldcount{get;}
//  public abstract string getname(int i);
//  public abstract string getdatatypename(int i);
//  public abstract type getfieldtype(int i);
//  public abstract object getvalue(int i);
//  public abstract int getvalues(object[] values);
//  public abstract int getordinal(string name);
//  public abstract object this [ int i ]{get;}
//  public abstract object this [ string name ]{get;}
//  public abstract bool getboolean(int i);
//  public abstract byte getbyte(int i);
//  public abstract long getbytes(int i, long fieldoffset, byte[] buffer, int bufferoffset, int length);
//  public abstract char getchar(int i);
//  public abstract long getchars(int i, long fieldoffset, char[] buffer, int bufferoffset, int length);
//  public abstract guid getguid(int i);
//  public abstract int16 getint16(int i);
//  public abstract int32 getint32(int i);
//  public abstract int64 getint64(int i);
//  public abstract float getfloat(int i);
//  public abstract double getdouble(int i);
//  public abstract string getstring(int i);
//  public abstract decimal getdecimal(int i);
//  public abstract datetime getdatetime(int i);
//  public abstract idatareader getdata(int i);
//  public abstract bool isdbnull(int i);
//  public abstract void dispose();
//  //private abstract int _cultureawarecompare(string stra, string strb);
//  
// }

 
}

本文地址:http://com.8s8s.com/it/it46029.htm