OdbcHelper，链接数据库操作数据

using System;
using System.IO;
using System.Data;
using System.Xml;
using System.Data.Odbc;
using System.Collections;
using System.Web.Security;
using System.Configuration; 

namespace LC.SCS.Accounting.Service
{ 

   

 public class DataOdbcSession
    {// to do
        private static readonly string ConnectionStr = ConfigurationManager.ConnectionStrings["Database"].ToString();
        private static readonly string ConnectionStr2 = ConfigurationManager.ConnectionStrings["Database"].ToString();

        public static OdbcConnection GetConnection()
        {
            var connection = new OdbcConnection(ConnectionStr);
            try
            {
                if (connection.State != ConnectionState.Open)
                {
                    connection.Open();
                }
            }
            catch
            {
                try
                {
                    connection = new OdbcConnection(ConnectionStr2);
                    connection.Open();
                    return connection;
                }
                catch (Exception ex)
                {
                    throw new Exception(ex.Message);
                }
            }
            return connection;
        }
    }

    /// <summary>
    /// The OdbcHelper class is intended to encapsulate high performance, scalable best practices for 
    /// common uses of OdbcClient.
    /// </summary>
    public class OdbcHelper
    { 
        public static OdbcCommand Cmd = null;
        public static OdbcTransaction Trans;

        static OdbcHelper()
        {

        }

        #region 设置OdbcCommand对象

        /// <summary>
        ///     设置OdbcCommand对象
        /// </summary>
        /// <param name="cmd">OdbcCommand对象 </param>
        /// <param name="cmdText">命令文本</param>
        /// <param name="cmdType">命令类型</param>
        /// <param name="cmdParms">参数集合</param>
        private static void SetCommand(OdbcConnection Conn, OdbcCommand cmd, string cmdText, CommandType cmdType,
            OdbcParameter[] cmdParms)
        {
            cmd.Connection = Conn;
            cmd.CommandText = cmdText;
            cmd.CommandType = cmdType;

            if (Trans != null)
                cmd.Transaction = Trans;

            if (cmdParms != null)
            {
                cmd.Parameters.Clear();
                cmd.Parameters.AddRange(cmdParms);
            }
        }

        #endregion

        #region 执行相应的sql语句，返回相应的DataSet对象

        /// <summary>
        ///     执行相应的sql语句，返回相应的DataSet对象
        /// </summary>
        /// <param name="sqlstr">sql语句</param>
        /// <returns>返回相应的DataSet对象</returns>
        public static DataSet GetDataSet(string sqlstr)
        {
            var set = new DataSet();

            OdbcConnection Conn = DataOdbcSession.GetConnection();
            Cmd = new OdbcCommand(sqlstr, Conn);
            if (Trans != null)
                Cmd.Transaction = Trans;
            try
            {
                var adp = new OdbcDataAdapter(Cmd);
                adp.Fill(set); 
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
            finally
            {
                Conn.Close();
                Conn.Dispose();
            } 
            return set;
        }

        #endregion

        #region 执行相应的sql语句，返回相应的DataSet对象

        /// <summary>
        ///     执行相应的sql语句，返回相应的DataSet对象
        /// </summary>
        /// <param name="sqlstr">sql语句</param>
        /// <param name="tableName">表名</param>
        /// <returns>返回相应的DataSet对象</returns>
        public static DataSet GetDataSet(string sqlstr, string tableName)
        {
            var set = new DataSet();
            OdbcConnection Conn = DataOdbcSession.GetConnection();
            Cmd = new OdbcCommand(sqlstr, Conn);
            if (Trans != null)
                Cmd.Transaction = Trans;
            try
            {
                var adp = new OdbcDataAdapter(Cmd);
                adp.Fill(set, tableName); 
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
            finally
            {
                Conn.Close();
                Conn.Dispose();
            } 
            return set;
        }

        #endregion

        #region 执行不带参数sql语句，返回所影响的行数

        /// <summary>
        ///     执行不带参数sql语句，返回所影响的行数
        /// </summary>
        /// <param name="cmdstr">增，删，改sql语句</param>
        /// <returns>返回所影响的行数</returns>
        public static int ExecuteNonQuery(string cmdText)
        {
            int count;
            OdbcConnection Conn = DataOdbcSession.GetConnection();
            Cmd = new OdbcCommand(cmdText, Conn);
            if (Trans != null)
                Cmd.Transaction = Trans;
            try
            {
                count = Cmd.ExecuteNonQuery(); 
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
            finally
            {
                Conn.Close();
                Conn.Dispose();
            } 
            return count;
        }

        #endregion

        #region 执行带参数sql语句或存储过程，返回所影响的行数

        /// <summary>
        ///     执行带参数sql语句或存储过程，返回所影响的行数
        /// </summary>
        /// <param name="cmdText">带参数的sql语句和存储过程名</param>
        /// <param name="cmdType">命令类型</param>
        /// <param name="cmdParms">参数集合</param>
        /// <returns>返回所影响的行数</returns>
        public static int ExecuteNonQuery(string cmdText, CommandType cmdType, OdbcParameter[] cmdParms)
        {
            int count;
            OdbcConnection Conn = DataOdbcSession.GetConnection();
            Cmd = new OdbcCommand();
            if (Trans != null)
                Cmd.Transaction = Trans;
            try
            {
                SetCommand(Conn, Cmd, cmdText, cmdType, cmdParms);
                count = Cmd.ExecuteNonQuery();
                Cmd.Parameters.Clear();
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
            finally
            {
                Conn.Close();
                Conn.Dispose();
            }
            return count;
        }

         

        #endregion

        #region 执行不带参数sql语句，返回一个从数据源读取数据的OdbcDataReader对象

        /// <summary>
        ///     执行不带参数sql语句，返回一个从数据源读取数据的OdbcDataReader对象
        /// </summary>
        /// <param name="cmdstr">相应的sql语句</param>
        /// <returns>返回一个从数据源读取数据的OracleDataReader对象</returns>
        public static OdbcDataReader ExecuteReader(string cmdText)
        {
            OdbcDataReader reader;

            OdbcConnection Conn = DataOdbcSession.GetConnection();
            Cmd = new OdbcCommand(cmdText, Conn);
            if (Trans != null)
                Cmd.Transaction = Trans;
            try
            {
                reader = Cmd.ExecuteReader(CommandBehavior.CloseConnection);
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
            return reader;
        }

        #endregion

        #region 执行带参数的sql语句或存储过程，返回一个从数据源读取数据的OdbcDataReader对象

        /// <summary>
        ///     执行带参数的sql语句或存储过程，返回一个从数据源读取数据的OdbcDataReader对象
        /// </summary>
        /// <param name="cmdText">sql语句或存储过程名</param>
        /// <param name="cmdType">命令类型</param>
        /// <param name="cmdParms">参数集合</param>
        /// <returns>返回一个从数据源读取数据的OdbcDataReader对象</returns>
        public static OdbcDataReader ExecuteReader(string cmdText, CommandType cmdType, OdbcParameter[] cmdParms)
        {
            OdbcDataReader reader;
            OdbcConnection Conn = DataOdbcSession.GetConnection();
            Cmd = new OdbcCommand(cmdText, Conn);
            if (Trans != null)
                Cmd.Transaction = Trans;
            SetCommand(Conn, Cmd, cmdText, cmdType, cmdParms);
            try
            {
                reader = Cmd.ExecuteReader(CommandBehavior.SequentialAccess);
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
            return reader;
        }

        #endregion

        #region 执行不带参数sql语句,返回结果集首行首列的值object

        /// <summary>
        ///     执行不带参数sql语句,返回结果集首行首列的值object
        /// </summary>
        /// <param name="cmdstr">相应的sql语句</param>
        /// <returns>返回结果集首行首列的值object</returns>
        public static object ExecuteScalar(string cmdText)
        {
            object obj;
            OdbcConnection Conn = DataOdbcSession.GetConnection();
            Cmd = new OdbcCommand(cmdText, Conn);
            if (Trans != null)
                Cmd.Transaction = Trans;
            try
            {
                obj = Cmd.ExecuteScalar();
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
            finally
            {
                Conn.Close();
                Conn.Dispose();
            } 
            return obj;

        }

        #endregion

        #region 执行带参数sql语句或存储过程,返回结果集首行首列的值object

        /// <summary>
        ///     执行带参数sql语句或存储过程,返回结果集首行首列的值object
        /// </summary>
        /// <param name="cmdText">sql语句或存储过程名</param>
        /// <param name="cmdType">命令类型</param>
        /// <param name="cmdParms">返回结果集首行首列的值object</param>
        /// <returns></returns>
        public static object ExecuteScalar(string cmdText, CommandType cmdType, OdbcParameter[] cmdParms)
        {
            object obj;
            OdbcConnection Conn = DataOdbcSession.GetConnection();
            try
            {
                Cmd = new OdbcCommand(cmdText, Conn); 
                SetCommand(Conn, Cmd, cmdText, cmdType, cmdParms);
                obj = Cmd.ExecuteScalar(); 
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
            finally
            {
                Conn.Close();
                Conn.Dispose();
            } 
            return obj;
        }

        #endregion

        /// <summary>
        /// 执行存储过程，返回游标集合
        /// </summary>
        /// <param name="spName">存储过程名</param>
        /// <param name="sqlParme">存储过程参数</param>
        /// <returns></returns>
        public static DataTable DBExecStoredProcedure(string spName, OdbcParameter[] sqlParme)
        {
            OdbcConnection Conn = DataOdbcSession.GetConnection();

            Cmd = new OdbcCommand(spName, Conn);
            SetCommand(Conn, Cmd, spName, CommandType.StoredProcedure, sqlParme); 
            DataSet dsList = new DataSet();
            DateTime BegTime = System.DateTime.Now;
            try
            {
                OdbcDataAdapter adapter = new OdbcDataAdapter(Cmd);
                adapter.Fill(dsList);
                return dsList.Tables[0];
            }
            catch 
            {
                return new DataTable();
            }
            finally
            {
                Conn.Close();
                Conn.Dispose();
            } 
        }
         
    }
}