C#,ADO封装,SqlHelper.cs

using System;
using System.Data;
using System.Configuration;
using System.Web;
using System.Web.Security;
using System.Collections;
using System.Data.Common;
using System.Text;
/// <summary>
/// 数据库的通用访问代码
/// 此类为抽象类，不允许实例化，在应用时直接调用即可
/// </summary>
public abstract class SqlHelper
{
    private const string SQLconnStrName = "SqlConnection";
    private const string OracleconnStrName="OracleConnection";
    public static readonly ConnectionStringSettings SQLconnStringSettings
        = ConfigurationManager.ConnectionStrings[SQLconnStrName];
    public static readonly ConnectionStringSettings OracleconnStringSettings
= ConfigurationManager.ConnectionStrings[OracleconnStrName];
    private static DbProviderFactory m_dbProvFactory;
    public static string MessgeToScriptMessage(string message)
    {
        return message.Replace("/r/n", "//r//n");
    }
    public static string LineToScript()
    {
        return "//r//n";
    }
    private static DbProviderFactory dbProvFactory
    {
        get
        {
            return m_dbProvFactory;
        }
        set
        {
            m_dbProvFactory = value;
        }
    }
    /// <summary>
    /// 打开数据连接
    /// </summary>
    /// <param name="strConnectionString">连接字符串</param>
    /// <returns>IDbConnection</returns>
    public static IDbConnection OpenDatabase(ConnectionStringSettings strConnectionString)
    {
        if (null == strConnectionString)
        {
            Exception exceptObj = new Exception(string.Format(
                "配置文件Web.config的数据库连接名错误,无连接名为{0}的数据!", strConnectionString.Name));
                exceptObj.Source = "SqlHelper.dbProvFactory";
            throw exceptObj;
        }
        dbProvFactory = DbProviderFactories.GetFactory(strConnectionString.ProviderName);
      
        IDbConnection conn = dbProvFactory.CreateConnection();
        conn.ConnectionString = strConnectionString.ConnectionString;
        conn.Open();
        return conn;
    }
    /// <summary>
    /// 关闭连接
    /// </summary>
    /// <param name="dbConn">IDbConnection</param>
    public static void CloseDatabase(IDbConnection dbConn)
    {
        dbConn.Close();
        dbProvFactory = null;
    }
    /// <summary>
    /// 创建command参数
    /// </summary>
    /// <param name="paramName">参数名</param>
    /// <param name="dbType">参数类型</param>
    /// <param name="size">参数大小</param>
    /// <returns>command参数</returns>
    public static DbParameter CreateDbParam(string paramName, DbType dbType, int size, object value)
    {
        DbParameter dbParam = dbProvFactory.CreateParameter();
        dbParam.DbType = dbType;
        dbParam.ParameterName = paramName;
        dbParam.Size = size;
        dbParam.Value = value;
        return dbParam;
    }
    
    /// <summary>
    ///执行一条不返回结果的Sql命令，通过一个已经存在的数据库连接
    /// <param name="conn">一个现有的数据库连接</param>
    /// <param name="commandType">SqlCommand命令类型 (存储过程， T-SQL语句， 等等。)</param>
    /// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
    /// <param name="cmdParams">以数组形式提供SqlCommand命令中用到的参数列表</param>
    /// <returns>此SqlCommand命令执行后影响的行数</returns>
    public static int ExecuteNonQuery(IDbConnection connection, CommandType cmdType,
        string cmdText, DbParameter[] cmdParams)
    {
        IDbCommand cmd = dbProvFactory.CreateCommand();
        PrepareCommand(cmd, connection, cmdType, cmdText, cmdParams);
        int val = cmd.ExecuteNonQuery();
        cmd.Parameters.Clear();
        return val;
    }
    /// <summary>
    /// 执行一条不返回结果的SqlCommand，通过一个已经存在的数据库事物处理
    /// </summary>
    /// <param name="trans">一个存在的 sql 事物处理</param>
    /// <param name="commandType">SqlCommand命令类型 (存储过程， T-SQL语句， 等等。)</param>
    /// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
    /// <param name="cmdParams">以数组形式提供SqlCommand命令中用到的参数列表</param>
    /// <returns>成功：返回一个数值表示此SqlCommand命令执行后影响的行数，-1：失败</returns>
    public static int ExecuteNonQuery(IDbTransaction trans, CommandType cmdType,
        string cmdText, DbParameter[] cmdParams)
    {
        IDbCommand cmd = dbProvFactory.CreateCommand();
        PrepareCommand(cmd, trans, cmdType, cmdText, cmdParams);
        int val = cmd.ExecuteNonQuery();
        cmd.Parameters.Clear();
        return val;
    }
    /// <summary>
    ///  执行一条不返回结果的SqlCommand,通过一个已经存在的数据库连接
    /// </summary>
    /// <param name="connection">一个现有的数据库连接</param>
    /// <param name="cmdType">SqlCommand命令类型 (存储过程， T-SQL语句， 等等。)</param>
    /// <param name="cmdText">存储过程的名字或者 T-SQL 语句</param>
    /// <param name="cmdParams">以数组形式提供SqlCommand命令中用到的参数列表</param>
    /// <returns>IDataReader</returns>
    public static IDataReader ExecuteReader(IDbConnection connection, CommandType cmdType,
        string cmdText, DbParameter[] cmdParams)
    {
        IDbCommand cmd = dbProvFactory.CreateCommand();
        PrepareCommand(cmd, connection, cmdType, cmdText, cmdParams);
        IDataReader rdr = cmd.ExecuteReader();
        cmd.Parameters.Clear();
        return rdr;
    }
    /// <summary>
    /// 执行一条返回第一条记录第一列的SqlCommand命令，通过已经存在的数据库连接。
    /// </summary>
    /// <param name="conn">一个已
4000
经存在的数据库连接</param>
    /// <param name="commandType">SqlCommand命令类型 (存储过程， T-SQL语句， 等等。)</param>
    /// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
    /// <param name="cmdParams">以数组形式提供SqlCommand命令中用到的参数列表</param>
    /// <returns>成功：返回一个object类型的数据，可以通过 Convert.To{Type}方法转换类型，失败：null</returns>
    public static object ExecuteScalar(IDbConnection connection, CommandType cmdType,
        string cmdText, DbParameter[] cmdParams)
    {
        IDbCommand cmd = dbProvFactory.CreateCommand();
        PrepareCommand(cmd, connection, cmdType, cmdText, cmdParams);
        object val = cmd.ExecuteScalar();
        cmd.Parameters.Clear();
        return val;
    }
    /// <summary>
    /// 通过字段名获取字段的字符串值
    /// </summary>
    /// <param name="reader">数据集</param>
    /// <param name="fieldName">字段名</param>
    /// <returns>字段值</returns>
    public static string GetFieldByName(IDataReader reader, string fieldName)
    {
        try
        {
            return (string)reader[fieldName];
        }
        catch (Exception)
        {
            return "";
        }
    }
    /// <summary>
    /// 通过字段号获取字段的字符串值
    /// </summary>
    /// <param name="reader">数据集</param>
    /// <param name="fieldPos">字段号</param>
    /// <returns>字段值</returns>
    public static string GetFieldByPos(IDataReader reader, int fieldPos)
    {
        try
        {
            return reader.GetString(fieldPos);
        }
        catch (Exception)
        {
            return "";
        }
    }
    /// <summary>
    /// 通过字段名获取字段的Int32值
    /// </summary>
    /// <param name="reader">数据集</param>
    /// <param name="fieldName">字段名</param>
    /// <returns>字段值</returns>
    public static int GetInt32ByName(IDataReader reader, string fieldName)
    {
        try
        {
            return Convert.ToInt32(reader[fieldName]);
        }
        catch (Exception)
        {
            return 0;
        }
    }
    /// <summary>
    /// 通过字段号获取字段的Int32值
    /// </summary>
    /// <param name="reader">数据集</param>
    /// <param name="fieldPos">字段号</param>
    /// <returns>字段值</returns>
    public static int GetInt32ByPos(IDataReader reader, int fieldPos)
    {
        try
        {
            return reader.GetInt32(fieldPos);
        }
        catch (Exception)
        {
            return 0;
        }
    }
    /// <summary>
    /// 为执行命令准备参数
    /// </summary>
    /// <param name="cmd">SqlCommand 命令</param>
    /// <param name="trans">数据库事物处理</param>
    /// <param name="cmdType">SqlCommand命令类型 (存储过程， T-SQL语句， 等等。)</param>
    /// <param name="cmdText">Command text，T-SQL语句 例如 Select * from Products</param>
    /// <param name="cmdParms">返回带参数的命令</param>
    private static void PrepareCommand(IDbCommand cmd, IDbTransaction trans,
        CommandType cmdType, string cmdText, DbParameter[] cmdParms)
    {
        cmd.Transaction = trans;
        cmd.CommandText = cmdText;
        cmd.CommandType = cmdType;
        if (cmdParms != null)
        {
            foreach (DbParameter parm in cmdParms)
            {
                cmd.Parameters.Add(parm);
            }
        }
    }
    /// <summary>
    /// 为执行命令准备参数
    /// </summary>
    /// <param name="cmd">SqlCommand 命令</param>
    /// <param name="conn">已经存在的数据库连接</param>
    /// <param name="cmdType">SqlCommand命令类型 (存储过程， T-SQL语句， 等等。)</param>
    /// <param name="cmdText">Command text，T-SQL语句 例如 Select * from Products</param>
    /// <param name="cmdParms">返回带参数的命令</param>
    private static void PrepareCommand(IDbCommand cmd, IDbConnection conn,
        CommandType cmdType, string cmdText, DbParameter[] cmdParms)
    {
        if (conn.State != ConnectionState.Open)
        {
            conn.Open();
        }
        cmd.Connection = conn;
        cmd.CommandText = cmdText;
        cmd.CommandType = cmdType;
        if (cmdParms != null)
        {
            foreach (DbParameter parm in cmdParms)
            {
                cmd.Parameters.Add(parm);
            }
        }
    }
}