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文件，加上以下一句话:
/// <appSettings><br/>
/// <add key="DSN" value="server=(local)\NetSDK;database=Northwind;Trusted_Connection=yes" /><br/>
/// </appSettings\><br/>
/// 请注意，这句话必须加在配置文件的根节点，即<configuration>之下</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);
//
// }
}
|
本类阅读TOP10