CommonUtils类

一、帮助类

1、Json与对象、DataTable、Collection的转换

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Json;
using System.IO;
using System.Data;
using System.Collections;
using System.Text.RegularExpressions;
using System.Web.Script.Serialization;

public class JsonTools
{

    // 从一个对象信息生成Json串        
    public static string ObjectToJson(object obj)
    {
        //将对象序列化为 JavaScript 对象表示法 (JSON)，并将 JSON 数据反序列化为对象。 此类不能被继承。
        DataContractJsonSerializer serializer = new DataContractJsonSerializer(obj.GetType());
        MemoryStream stream = new MemoryStream();
        serializer.WriteObject(stream, obj);
        byte[] dataBytes = new byte[stream.Length];
        stream.Position = 0;
        stream.Read(dataBytes, 0, (int)stream.Length);
        return Encoding.UTF8.GetString(dataBytes); //Json字符串
    }
    // 从一个Json串生成对象信息        
    public static object JsonToObject(string jsonString, object obj)
    {
        DataContractJsonSerializer serializer = new DataContractJsonSerializer(obj.GetType());
        MemoryStream mStream = new MemoryStream(Encoding.UTF8.GetBytes(jsonString));
        return serializer.ReadObject(mStream);
    }

    /// <summary> 
    /// DataTable转为json 
    /// </summary> 
    /// <param name="dt">DataTable</param> 
    /// <returns>json数据</returns> 
    public static string DataTableToJson(DataTable dt)
    {
        ArrayList dic = new ArrayList();
        foreach (DataRow dr in dt.Rows)
        {
            Dictionary<string, object> result = new Dictionary<string, object>();

            foreach (DataColumn dc in dt.Columns)
            {
                if (dc.DataType == typeof(DateTime) && !dr[dc].ToString().Equals(""))
                    result.Add(dc.ColumnName, DateTime.Parse(dr[dc].ToString()).ToString("yyyy-MM-dd HH:mm:ss"));
                else
                    result.Add(dc.ColumnName, dr[dc].ToString());
            }
            dic.Add(result);

        }
        JavaScriptSerializer javaScriptSerializer = new JavaScriptSerializer();

        javaScriptSerializer.MaxJsonLength = Int32.MaxValue;
        return javaScriptSerializer.Serialize(dic);  
        //return ObjectToJson(dic);
    }

    /// <summary>
    /// json转为DataTable
    /// </summary>
    /// <param name="strJson"></param>
    /// <returns></returns>
    public static DataTable JsonToDataTable(string strJson)
    {
        ////取出表名  
        //Regex rg = new Regex(@"(?<={)[^:]+(?=:/[)", RegexOptions.IgnoreCase);
        //string strName = rg.Match(strJson).Value;
        DataTable dt = null;
        ////去除表名  
        //strJson = strJson.Substring(strJson.IndexOf("[") + 1);
        //strJson = strJson.Substring(0, strJson.IndexOf("]"));

        //获取数据  
        Regex rg = new Regex(@"(?<={)[^}]+(?=})");
        MatchCollection mc = rg.Matches(strJson);
        for (int i = 0; i < mc.Count; i++)
        {
            string strRow = mc[i].Value;
            string[] strRows = strRow.Split(',');

            //创建表  
            if (dt == null)
            {
                dt = new DataTable();
                dt.TableName = "";
                foreach (string str in strRows)
                {
                    DataColumn dc = new DataColumn();
                    string[] strCell = str.Split(':');

                    dc.ColumnName = strCell[0].ToString().Replace("\"", "").Trim();
                    dt.Columns.Add(dc);
                }
                dt.AcceptChanges();
            }

            //增加内容  
            DataRow dr = dt.NewRow();
            for (int r = 0; r < strRows.Length; r++)
            {
                dr[r] = strRows[r].Split(':')[1].Trim().Replace("，", ",").Replace("：", ":").Replace("/", "").Replace("\"", "").Trim();
            }
            dt.Rows.Add(dr);
            dt.AcceptChanges();
        }

        return dt;
    }


    /// <summary> 
    /// 返回结果将数据表属性转换成Json 
    /// </summary> 
    /// <param name="dt">DataTable</param> 
    /// <returns>json数据</returns> 
    public static SubmitResultJson ResultToResultJson(SubmitResult oResult)
    {
        SubmitResultJson oResultJson = new SubmitResultJson();
        oResultJson.ResultCode = oResult.ResultCode;
        oResultJson.ResultMsg = oResult.ResultMsg;
        if (oResult.ResultCode == "1")
        {
            try
            {
                if (oResult.ResultTable != null)
                {
                    DataTable dt = new DataTable();
                    dt = oResult.ResultTable.Copy();
                    string strResultTable = JsonTools.DataTableToJson(dt);
                    oResultJson.ResultTableJson = strResultTable;
                }
            }
            catch (Exception ex)
            {
                oResultJson.ResultCode = "0";
                oResultJson.ResultMsg = ex.Message;
                return oResultJson;
            }
        }
        return oResultJson;
    }
        /// <summary> 
        /// 序列化方法，把自定义实体类转化为Json格式的字符串 
        /// </summary> 
        /// <typeparam name="T"></typeparam> 
        /// <param name="objToJson"></param> 
        /// <returns></returns> 
        public static string SerializeJson<T>(T objToJson)
        {
            DataContractJsonSerializer json = new DataContractJsonSerializer(objToJson.GetType());
            string resultString;
            //序列化 
            using (MemoryStream stream = new MemoryStream())
            {
                json.WriteObject(stream, objToJson);
                resultString = Encoding.UTF8.GetString(stream.ToArray());
                return resultString;
            }
        }


        /// <summary> 
        /// 反序列化方法。将客户端发来的Json转化为Collection<T> 
        /// </summary> 
        /// <typeparam name="T"></typeparam> 
        /// <param name="sJson"></param> 
        /// <param name="type"></param> 
        /// <returns></returns> 
        public static T DeserializeJson<T>(string sJson, Type type)
        {
            using (MemoryStream ms = new MemoryStream(Encoding.UTF8.GetBytes(sJson)))
            {
                DataContractJsonSerializer serializer = new DataContractJsonSerializer(type);
                object obj = serializer.ReadObject(ms);
                return (T)obj;
            }
        }

}

2、日志文件

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Configuration;

public class LogManager
{
    private static string logPath = ConfigurationSettings.AppSettings["LogPath"];
    /// <summary>
    /// 保存日志的文件夹
    /// </summary>
    public static string LogPath
    {
        get
        {
            //if (logPath == string.Empty)
            //{
            //    logPath = logPath;
            //    //if (System.Web.HttpContext.Current == null)
            //    //    // Windows Forms 应用
            //    //    logPath = AppDomain.CurrentDomain.BaseDirectory;
            //    //else
            //    //    // Web 应用
            //    //    logPath = AppDomain.CurrentDomain.BaseDirectory + @"bin\";
            //}
            return logPath;
        }
        set { logPath = value; }
    }

    private static string logFielPrefix = string.Empty;
    /// <summary>
    /// 日志文件前缀
    /// </summary>
    public static string LogFielPrefix
    {
        get { return logFielPrefix; }
        set { logFielPrefix = value; }
    }

    /// <summary>
    /// 写日志
    /// </summary>
    private static void WriteLog(string logFile, string msg)
    {
        try
        {
            System.IO.StreamWriter sw = System.IO.File.AppendText(
                LogPath + LogFielPrefix + logFile + " " +
                DateTime.Now.ToString("yyyyMMdd") + ".Log"
                );
            sw.WriteLine(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss: ") + msg);
            sw.Close();
        }
        catch(Exception ex)
        {
            throw new Exception(ex.Message);
        }
    }

    /// <summary>
    /// 写日志
    /// </summary>
    public static void WriteLog(LogType logFile, string msg)
    {
        WriteLog(logFile.ToString(), msg);
    }
}


/// <summary>
/// 日志类型
/// </summary>
public enum LogType
{
    Trace,
    Warning,
    Error,
    SQL
}

3、xml与某一类型转换

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Xml;
using System.Xml.Serialization;
using System.Text;
using System.IO;
using System.Data;

/// <summary>
/// 序列化和反序列化XML文件
/// </summary>
public class XmlUtil
{
    public XmlUtil()
    {
        //
        // TODO: 在此处添加构造函数逻辑
        //
    }

    /// <summary>    
    /// XML序列化某一类型到指定的文件    
    /// </summary>    
    /// <param name="filePath"></param>    
    /// <param name="obj"></param>    
    /// <param name="type"></param>    
    public static void SerializeToXml<T>(string filePath, T obj)
    {
        try
        {
            using (System.IO.StreamWriter writer = new System.IO.StreamWriter(filePath))
            {
                System.Xml.Serialization.XmlSerializer xs = new System.Xml.Serialization.XmlSerializer(typeof(T));
                xs.Serialize(writer, obj);
            }
        }
        catch (Exception ex)
        {
            throw ex;
        }
    }

    /// <summary>    
    /// 从某一XML文件反序列化到某一类型    
    /// </summary>    
    /// <param name="filePath">待反序列化的XML文件名称</param>    
    /// <param name="type">反序列化出的</param>    
    /// <returns></returns>    
    public static T DeserializeFromXml<T>(string filePath)
    {
        try
        {
            if (!System.IO.File.Exists(filePath))
            {
                throw new ArgumentNullException(filePath + " 不存在");
            }
             
            using (StreamReader reader = new StreamReader(filePath))
            {
                System.Xml.Serialization.XmlSerializer xs = new System.Xml.Serialization.XmlSerializer(typeof(T));
                T ret = (T)xs.Deserialize(reader); 
                return ret;
            }
        }
        catch (Exception ex)
        {
            return default(T);
        }
    }
}

4、数据库帮助类

4.1、创建DalFactory类库项目：

  -- 工厂类：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;


public class MESDalContext
{
    public static readonly MESDalContext instance = new MESDalContext();
    private MESDalContext()
    {

    }
    public ISQL_DAL GetDalObject()
    {
        return new SQL_DAL();
    }
}

 -- DbHelper类：

using Oracle.ManagedDataAccess.Client;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Configuration;
using System.Data;

public abstract class DatabaseHelper
{
    AppSettingsReader AppRead = new AppSettingsReader();

      private static readonly string connectionString = ConfigurationSettings.AppSettings["ConnectionString"];
    #region "执行简单SQL语句"
    /// <summary>
    /// 执行多条SQL语句，实现数据库事务。
    /// </summary>
    /// <param name="SQLStringList">SQL语句的哈希表（key为sql语句，value是该语句的OracleParameter[]）</param>
    public static void ExecuteSqlTranByHash(Dictionary<string, OracleParameter[]> SQLStringList)
    {
        using (OracleConnection conn = new OracleConnection(connectionString))
        {
            conn.Open();
            using (OracleTransaction trans = conn.BeginTransaction())
            {
                OracleCommand cmd = new OracleCommand();
                try
                {
                    //循环
                    foreach (var myDE in SQLStringList)
                    {
                        string cmdText = myDE.Key.ToString();
                        //获得键值
                        OracleParameter[] cmdParms = myDE.Value;
                        //通过键值获得值
                        PrepareCommand(cmd, conn, trans, cmdText, cmdParms);
                        int val = cmd.ExecuteNonQuery();
                        cmd.Parameters.Clear();
                    }
                    //事务提交
                    trans.Commit();
                }
                catch (Exception ex)
                {
                    trans.Rollback();
                    throw ex;
                }
            }
        }
    }
    /// <summary>
    /// 执行SQL语句，返回影响的记录数
    /// 例如数据添加、删除、更新操作
    /// </summary>
    /// <param name="SQLString">SQL语句</param>
    /// <returns>影响的记录数</returns>
    public static int ExecuteSql(string SQLString)
    {
        using (OracleConnection connection = new OracleConnection(connectionString))
        {
            using (OracleCommand cmd = new OracleCommand(SQLString, connection))
            {
                try
                {
                    connection.Open();
                    int rows = cmd.ExecuteNonQuery();
                    return rows;
                }
                catch (OracleException ex)
                {
                    connection.Close();
                    throw ex;
                }
            }
        }
    }
    /// <summary>
    /// 执行多条SQL语句，实现数据库事务。
    /// 当所有的执行语句全部执行成功，没有异常后才能进行事务的提交
    /// </summary>
    /// <param name="SQLStringList">多条SQL语句</param>        
    public static void ExecuteSqlTran(ArrayList SQLStringList)
    {

        using (OracleConnection conn = new OracleConnection(connectionString))
        {
            conn.Open();
            OracleCommand cmd = new OracleCommand();
            cmd.Connection = conn;
            OracleTransaction tx = conn.BeginTransaction();
            cmd.Transaction = tx;
            try
            {
                for (int i = 0; i < SQLStringList.Count; i++)
                {
                    string strSql = SQLStringList[i].ToString();
                    if (strSql.Trim().Length > 1)
                    {
                        cmd.CommandText = strSql;
                        cmd.ExecuteNonQuery();
                    }
                }
                //事务提交
                tx.Commit();
            }
            catch (OracleException ex)
            {
                tx.Rollback();
                //事务回滚
                throw ex;
            }
        }
    }
    /// <summary>
    /// 执行带一个存储过程参数的的SQL语句。
    /// </summary>
    /// <param name="strSQL">SQL语句/或者是存储过程</param>
    /// <param name="content">参数内容,比如一个字段是格式复杂的文章，有特殊符号，可以通过这个方式添加</param>
    /// <returns>影响的记录数</returns>
    public static int ExecuteSql(string strSQL, string content)
    {
        using (OracleConnection connection = new OracleConnection(connectionString))
        {
            OracleCommand cmd = new OracleCommand(strSQL, connection);
            OracleParameter myParameter = new OracleParameter("content", SqlDbType.Image);
            myParameter.Value = content;
            cmd.Parameters.Add(myParameter);
            try
            {
                connection.Open();
                int rows = cmd.ExecuteNonQuery();
                return rows;
            }
            catch (OracleException ex)
            {
                throw ex;
            }
            finally
            {
                cmd.Dispose();
                connection.Close();
            }
        }
    }
    /// <summary>
    /// 向数据库里插入图像格式的字段(和上面情况类似的另一种实例)
    /// </summary>
    /// <param name="strSQL">SQL语句</param>
    /// <param name="fs">图像字节,数据库的字段类型为image的情况</param>
    /// <returns>影响的记录数</returns>
    public static int ExecuteSqlInsertImg(string strSQL, Byte[] fs)
    {
        using (OracleConnection connection = new OracleConnection(connectionString))
        {
            OracleCommand cmd = new OracleCommand(strSQL, connection);
            OracleParameter myParameter = new OracleParameter("fs", SqlDbType.Image);
            myParameter.Value = fs;
            cmd.Parameters.Add(myParameter);
            try
            {
                connection.Open();
                int rows = cmd.ExecuteNonQuery();
                return rows;
            }
            catch (OracleException ex)
            {
                throw ex;
            }
            finally
            {
                cmd.Dispose();
                connection.Close();
            }
        }
    }

    /// <summary>
    /// 执行一条计算查询结果语句，返回查询结果（object）。
    /// </summary>
    /// <param name="strSQL">计算查询结果语句</param>
    /// <returns>查询结果（object）</returns>
    public static object GetSingle(string strSQL)
    {
        using (OracleConnection connection = new OracleConnection(connectionString))
        {
            using (OracleCommand cmd = new OracleCommand(strSQL, connection))
            {
                try
                {
                    connection.Open();
                    object obj = cmd.ExecuteScalar();
                    //统计功能（一行一列）
                    if ((obj == null) || (obj == System.DBNull.Value))
                    {
                        return null;
                    }
                    else
                    {
                        return obj;
                    }
                }
                catch (OracleException ex)
                {
                    connection.Close();
                    throw new Exception(ex.Message);
                }
            }
        }
    }
    /// <summary>
    /// 执行查询语句，返回OracleDataAdapter
    /// </summary>
    /// <param name="strSQL">查询语句</param>
    /// <returns>OracleDataAdapter</returns>
    public static OracleDataReader ExecuteReader(string strSQL)
    {
        OracleConnection connection = new OracleConnection(connectionString);
        OracleCommand cmd = new OracleCommand(strSQL, connection);
        try
        {
            connection.Open();
            OracleDataReader myReader = cmd.ExecuteReader();
            return myReader;
        }
        catch (OracleException ex)
        {
            connection.Close();
            throw new Exception(ex.Message);
        }
    }
    /// <summary>
    /// 执行查询语句，返回DataSet
    /// </summary>
    /// <param name="strSQL">查询语句</param>
    /// <returns>DataSet</returns>
    public static DataSet Query_ReturnDataSet(string strSQL)
    {
        using (OracleConnection connection = new OracleConnection(connectionString))
        {
            DataSet ds = new DataSet();
            try
            {
                connection.Open();
                OracleDataAdapter command = new OracleDataAdapter(strSQL, connection);
                command.Fill(ds, "ds");
            }
            catch (OracleException ex)
            {
                connection.Close();
                throw new Exception(ex.Message);
            }
            return ds;
        }
    }

    /// <summary>
    /// 执行查询语句，返回DataTable
    /// </summary>
    /// <param name="strSQL">查询语句</param>
    /// <returns>DataTable</returns>
    public static DataTable Query_ReturnDatTable_old(string strSQL)
    {      
        using (OracleConnection connection = new OracleConnection(connectionString))       
        {
            DataTable dt = new DataTable("dt");
            try
            {
                connection.Open();
                OracleDataAdapter command = new OracleDataAdapter(strSQL, connection);
                command.Fill(dt);
            }
            catch (OracleException ex)
            {
                connection.Close();
                throw new Exception(ex.Message);
            }
            return dt;
        }
    }




    ///// <summary>
    ///// 执行查询语句，返回DataTable
    ///// </summary>
    ///// <param name="strSQL">查询语句</param>
    ///// <returns>DataTable</returns>
    //public static DataTable Query_ReturnDatTable_old(string strSQL)
    //{

    //    using (OracleConnection connection = new OracleConnection("data source=KDMESDB;User Id=kdmesdb;Password=kdmesdb;"))       
    //    {
    //        DataTable dt = new DataTable();
    //        try
    //        {
    //            connection.Open();
    //            OracleDataAdapter command = new OracleDataAdapter(strSQL, connection);
    //            command.Fill(dt);
    //        }
    //        catch (OracleException ex)
    //        {
    //            connection.Close();
    //            throw new Exception(ex.Message);
    //        }
    //        return dt;
    //    }
    //}



    /// <summary>
    /// 带数据库连接参数执行查询语句，返回DataSet
    /// </summary>
    /// <param name="strSQL">查询语句</param>
    /// <returns>DataSet</returns>
    public static DataSet QueryByConn(string strSQL, string strConn)
    {
        using (OracleConnection connection = new OracleConnection(strConn))
        {
            DataSet ds = new DataSet("ds");
            try
            {
                connection.Open();
                OracleDataAdapter command = new OracleDataAdapter(strSQL, connection);
                command.Fill(ds, "ds");
            }
            catch (OracleException ex)
            {
                connection.Close();
                throw new Exception(ex.Message);
            }
            return ds;
        }
    }
    #endregion

    #region "执行带参数的SQL语句"
    /// <summary>
    /// 执行SQL语句，返回影响的记录数
    /// </summary>
    /// <param name="strSQL">SQL语句</param>
    /// <returns>影响的记录数</returns>
    public static int ExecuteSql(string strSQL, params OracleParameter[] cmdParms)
    {
        using (OracleConnection connection = new OracleConnection(connectionString))
        {
            using (OracleCommand cmd = new OracleCommand())
                try
                {
                    PrepareCommand(cmd, connection, null, strSQL, cmdParms);
                    int rows = cmd.ExecuteNonQuery();
                    cmd.Parameters.Clear();
                    return rows;
                }
                catch (OracleException ex)
                {
                    throw new Exception(ex.Message);
                }
        }
    }
    /// <summary>
    /// 执行多条SQL语句，实现数据库事务。
    /// </summary>
    /// <param name="SQLStringList">SQL语句的哈希表（key为sql语句，value是该语句的OracleParameter[]）</param>
    public static void ExecuteSqlTran(Hashtable SQLStringList)
    {
        using (OracleConnection connection = new OracleConnection(connectionString))
        {
            connection.Open();
            using (OracleTransaction trans = connection.BeginTransaction())
            {
                OracleCommand cmd = new OracleCommand();
                try
                {
                    //循环
                    foreach (DictionaryEntry myDE in SQLStringList)
                    {
                        string cmdText = myDE.Key.ToString();
                        //获得键值
                        OracleParameter[] cmdParms = (OracleParameter[])myDE.Value;
                        //通过键值获得值
                        PrepareCommand(cmd, connection, trans, cmdText, cmdParms);
                        int val = cmd.ExecuteNonQuery();
                        cmd.Parameters.Clear();
                        //事务提交
                        trans.Commit();
                    }
                }
                catch (OracleException ex)
                {
                    trans.Rollback();
                    throw new Exception(ex.Message);
                }
            }
        }
    }
    /// <summary>
    /// 执行一条计算查询结果语句，返回查询结果（object）。
    /// </summary>
    /// <param name="strSQL">计算查询结果语句</param>
    /// <param name="cmdParms">查询参数</param>
    /// <returns>查询结果（object）</returns>
    public static object GetSingle(string strSQL, params OracleParameter[] cmdParms)
    {
        using (OracleConnection connection = new OracleConnection(connectionString))
        {
            using (OracleCommand cmd = new OracleCommand())
            {
                try
                {
                    PrepareCommand(cmd, connection, null, strSQL, cmdParms);
                    object obj = cmd.ExecuteScalar();
                    cmd.Parameters.Clear();
                    //统计功能（一行一列）
                    if ((obj == null) || (obj == System.DBNull.Value))
                    {
                        return null;
                    }
                    else
                    {
                        return obj;
                    }
                }
                catch (OracleException ex)
                {
                    throw new Exception(ex.Message);
                }

            }
        }
    }
    /// <summary>
    /// 执行查询语句，返回OracleDataAdapter
    /// </summary>
    /// <param name="strSQL">查询语句</param>
    /// <param name="cmdParms">查询参数</param>
    /// <returns>OracleDataAdapter</returns>
    public static OracleDataReader ExecuteReader(string strSQL, params OracleParameter[] cmdParms)
    {
        OracleConnection connection = new OracleConnection(connectionString);
        OracleCommand cmd = new OracleCommand();
        try
        {
            PrepareCommand(cmd, connection, null, strSQL, cmdParms);
            OracleDataReader myReader = cmd.ExecuteReader();
            cmd.Parameters.Clear();
            return myReader;
        }
        catch (OracleException ex)
        {
            throw new Exception(ex.Message);
        }
    }
    /// <summary>
    /// 执行查询语句，返回DataSet
    /// </summary>
    /// <param name="strSQL">查询语句</param>
    /// <param name="cmdParms">查询参数</param>
    /// <returns>DataSet</returns>
    public static DataSet Query(string strSQL, params OracleParameter[] cmdParms)
    {
        using (OracleConnection connection = new OracleConnection(connectionString))
        {
            OracleCommand cmd = new OracleCommand();
            PrepareCommand(cmd, connection, null, strSQL, cmdParms);

            using (OracleDataAdapter da = new OracleDataAdapter(cmd))
            {
                DataSet ds = new DataSet();
                try
                {
                    da.Fill(ds, "ds");
                    cmd.Parameters.Clear();
                }
                catch (OracleException ex)
                {
                    throw new Exception(ex.Message);
                }
                return ds;
            }
        }
    }
    /// <summary>
    ///在存在事务的情况下，新建数据库连接，执行sql语句，此处是关键，上面的所有功能操作都沿此而进行
    /// 此处的sql语句可能是增加、删除、更新、查询等等操作
    /// Prepare a command for execution
    /// </summary>
    /// <param name="cmd">OracleCommand对象</param>
    /// <param name="conn">OracleConnection对象</param>
    /// <param name="trans">OracleTransaction对象</param>
    /// <param name="cmdType">Cmd type e.g. 存储过程或者sql语句</param>
    /// <param name="cmdText">Command text, e.g. Select * from Products</param>
    /// <param name="cmdParms">OracleParameters to use in the command</param>
    private static void PrepareCommand(OracleCommand cmd, OracleConnection conn, OracleTransaction trans, string cmdText, OracleParameter[] cmdParms)
    {
        if (conn.State != ConnectionState.Open)
        {
            conn.Open();
        }
        cmd.Connection = conn;
        cmd.CommandText = cmdText;
        if (trans != null)
        {
            cmd.Transaction = trans;
        }
        cmd.CommandType = CommandType.Text;
        //cmdType;
        if (cmdParms != null)
        {
            foreach (OracleParameter parm in cmdParms)
            {
                cmd.Parameters.Add(parm);
            }
        }
    }
    #endregion

    #region "存储过程操作"
    /// <summary>
    /// 执行存储过程
    /// </summary>
    /// <param name="storedProcName">存储过程名</param>
    /// <param name="parameters">存储过程参数</param>
    /// <returns>OracleDataAdapter</returns>
    public static OracleDataReader RunProcedure(string strProcedureName, IDataParameter[] parameters)
    {
        OracleConnection connection = new OracleConnection(connectionString);
        OracleDataReader returnReader;
        connection.Open();
        OracleCommand command = BuildQueryCommand(connection, strProcedureName, parameters);
        command.CommandType = CommandType.StoredProcedure;
        returnReader = command.ExecuteReader();
        return returnReader;
    }
    /// <summary>
    /// 执行存储过程
    /// </summary>
    /// <param name="storedProcName">存储过程名</param>
    /// <param name="parameters">存储过程参数</param>
    /// <param name="tableName">DataSet结果中的表名</param>
    /// <returns>DataSet</returns>
    public static DataSet RunProcedure(string strProcedureName, IDataParameter[] parameters, string tableName)
    {
        
        try
        {
            using (OracleConnection connection = new OracleConnection(connectionString))
            {
                DataSet dataSet = new DataSet();
                connection.Open();
                OracleDataAdapter da = new OracleDataAdapter();
                da.SelectCommand = BuildQueryCommand(connection, strProcedureName, parameters);
                da.Fill(dataSet, tableName);
                connection.Close();
                //trans.Dispose();
                return dataSet;
            }
        }

        catch (Exception ex)
        {
            throw ex;
        }
    }
    
    /// <summary>
    /// 构建 OracleCommand 对象(用来返回一个结果集，而不是一个整数值)
    /// </summary>
    /// <param name="connection">数据库连接</param>
    /// <param name="storedProcName">存储过程名</param>
    /// <param name="parameters">存储过程参数</param>
    /// <returns>OracleCommand</returns>
    private static OracleCommand BuildQueryCommand(OracleConnection connection, string strProcedureName, IDataParameter[] parameters)
    {
        OracleCommand command = new OracleCommand(strProcedureName, connection);
        command.CommandType = CommandType.StoredProcedure;
        foreach (OracleParameter parameter in parameters)
        {
            command.Parameters.Add(parameter);
        }
        return command;
    }
    /// <summary>
    /// 执行存储过程，返回影响的行数        
    /// </summary>
    /// <param name="storedProcName">存储过程名</param>
    /// <param name="parameters">存储过程参数</param>
    /// <param name="rowsAffected">影响的行数</param>
    /// <returns></returns>
    public static int RunProcedure(string strProcedureName, IDataParameter[] parameters, ref int rowsAffected)
    {
        int result = 0;
        try
        {
            using (OracleConnection connection = new OracleConnection(connectionString))
            {
                connection.Open();
                OracleCommand command = BuildIntCommand(connection, strProcedureName, parameters);
                OracleTransaction trans = connection.BeginTransaction(IsolationLevel.ReadCommitted);
                if (trans != null)
                {
                    command.Transaction = trans;
                    result = command.ExecuteNonQuery();
                    trans.Commit();
                }
            }
        }
        catch (Exception ex)
        {
            throw ex;
        }
        rowsAffected = result;
        return result;
    }
    /// <summary>
    /// 执行存储过程，查询，并且有输出参数    
    /// </summary>
    /// <param name="storedProcName">存储过程名</param>
    /// <param name="parameters">存储过程参数</param>
    /// <param name="rowsAffected">影响的行数</param>
    /// <returns></returns>
    public static string RunProcedureQuery(string strProcedureName, IDataParameter[] parameters, ref int rowsAffected)
    {
        string outString = "";
        try
        {
            using (OracleConnection connection = new OracleConnection(connectionString))
            {
                connection.Open();
                OracleCommand command = BuildIntCommand(connection, strProcedureName, parameters);
                OracleTransaction trans = connection.BeginTransaction(IsolationLevel.ReadCommitted);
                if (trans != null)
                {
                    command.Transaction = trans;
                    command.ExecuteNonQuery();
                    trans.Commit();
                }
                //输出参数
                outString = command.Parameters["TempID"].Value.ToString();
            }
        }
        catch (Exception ex)
        {
            throw ex;
        }
        rowsAffected = 0;
        return outString;
    }
    /// <summary>
    /// 创建 OracleCommand 对象实例(用来返回一个整数值)    
    /// </summary>
    /// <param name="storedProcName">存储过程名</param>
    /// <param name="parameters">存储过程参数</param>
    /// <returns>OracleCommand 对象实例</returns>
    private static OracleCommand BuildIntCommand(OracleConnection connection, string strProcedureName, IDataParameter[] parameters)
    {
        OracleCommand command = BuildQueryCommand(connection, strProcedureName, parameters);
        return command;
    }
    /// <summary>
    /// 执行存储过程，没有返回任何信息，如插入数据等
    /// </summary>
    /// <param name="procname"></param>
    /// <param name="cmdParms"></param>
    public static void ExecuteProc(string procname, params OracleParameter[] cmdParms)
    {
        using (OracleConnection SqlConn = new OracleConnection(connectionString))
        {
            if (SqlConn.State == ConnectionState.Closed)
            {
                SqlConn.Open();
            }
            OracleDataAdapter da = new OracleDataAdapter();
            da.SelectCommand = new OracleCommand();
            da.SelectCommand.Connection = SqlConn;
            da.SelectCommand.CommandText = procname;
            da.SelectCommand.CommandType = CommandType.StoredProcedure;
            if (cmdParms != null)
            {
                foreach (OracleParameter parm in cmdParms)
                {
                    da.SelectCommand.Parameters.Add(parm);
                }
            }
            int i = da.SelectCommand.ExecuteNonQuery();
            da.Dispose();
        }
    }
    /// <summary>
    /// 执行参数化的Sql语句,返回DataTable
    /// </summary>
    /// <param name="p_ProcedureName">sql语句</param>
    /// <param name="p_OracleParameterArray">Parm数组</param>
    /// <returns>返回DataTable</returns>
    public static DataTable ExeParameDataTable(string p_ProcedureName, OracleParameter[] p_OracleParameterArray)
    {
        try
        {
            using (OracleConnection SqlConn = new OracleConnection(connectionString))
            {
                if (SqlConn.State == ConnectionState.Closed)
                {
                    SqlConn.Open();
                }
                DataTable dt = new DataTable();
                OracleDataAdapter da = new OracleDataAdapter(p_ProcedureName, SqlConn);
                foreach (OracleParameter Sq in p_OracleParameterArray)
                {
                    da.SelectCommand.Parameters.Add(Sq);
                }
                da.Fill(dt);
                da.SelectCommand.Parameters.Clear();
                return dt;
            }
        }
        catch (Exception ex)
        {
            throw ex;
        }
    }

    /// <summary>
    /// 批量执行Command对象列表
    /// </summary>
    public static void ExecCmdListTrans(List<OracleCommand> list)
    {
        using (OracleConnection connection = new OracleConnection(connectionString))
        {
            if (connection.State == ConnectionState.Closed)
            {
                connection.Open();
            }
            OracleTransaction trans = connection.BeginTransaction();
            try
            {
                for (int i = 0; i < list.Count; i++)
                {
                    list[i].Connection = connection;
                    list[i].Transaction = trans;
                    list[i].ExecuteNonQuery();
                }
                trans.Commit();
            }
            catch (Exception ex)
            {
                trans.Rollback();
                throw ex;
            }
        }
    }
    #endregion

    #region oracle select
    /// <summary>
    /// 执行查询语句，返回DataTable
    /// </summary>
    /// <param name="strSQL">查询语句</param>
    /// <returns>DataTable</returns>
    public static DataTable Query_ReturnDatTable(string strSQL)
    {

        using (  OracleConnection connection = new OracleConnection(connectionString))
        {
            DataTable dt = new DataTable();
            try
            {
                connection.Open();
                OracleDataAdapter command = new OracleDataAdapter(strSQL, connection);
                command.Fill(dt);
            }
            catch (OracleException ex)
            {
                connection.Close();
                throw new Exception(ex.Message);
            }
            return dt;
        }
    }

    #endregion


}

4.2、创建接口ISQL_DAL,实现类SQL_DAL。

public class SQL_DAL : ISQL_DAL
{
    AppSettingsReader AppRead = new AppSettingsReader();
    private static readonly string connectionString = ConfigurationManager.AppSettings["ConnectionString"];
    private static readonly string strSpecType_Completion = ConfigurationSettings.AppSettings["SpecType_Completion"];
    private static readonly string strSpecType_Stock = ConfigurationSettings.AppSettings["SpecType_Stock"];

    #region 新增托盘信息返回日志信息
    public void InsertReWorkConfirmLog(string tableName, string handleResult, string date, string desc)
    {
        try
        {
            string sql = "insert into meslog (tablename, handleresult, handledate, describe) values (:tablename, :handleresult, :handledate, :describe)";
            OracleParameter[] pars = {
                new OracleParameter(":tablename",tableName),
                new OracleParameter(":handleresult",handleResult),
                new OracleParameter(":handledate",DateTime.Parse(date)),
                new OracleParameter(":describe",desc)
            };
            DatabaseHelper.ExecuteSql(sql, pars);
        }
        catch (Exception ex)
        {
            throw new Exception("添加总日志信息出错:" + ex.Message);
        }
    }
    #endregion