C# 适配数据库（待完成）

 using System;
    using System.Collections.Generic;
    using System.Text;
    using System.Data;
    using System.Configuration;
    using System.Data.Common;
    using System.Data.SqlClient;
    using System.Data.OleDb;
    using System.Data.Odbc;
    using System.Data.OracleClient;
    using System.IO;
using PPS.Tool.Event;
    
    namespace PPS.Tool.DataBass
    {
     public class DataBaseHelper:IDisposable
     {
     private string strConnectionString;
     private DbConnection objConnection;
     private DbCommand objCommand;
     private DbProviderFactory objFactory = null;
     private bool boolHandleErrors;
     private string strLastError;
     private bool boolLogError;
     private string strLogFile;
    
     public DataBaseHelper(string connectionstring,Providers provider)
     {


     strConnectionString = connectionstring;
     switch (provider)
     {
     case Providers.SqlServer:
     objFactory = SqlClientFactory.Instance;
     break;
     case Providers.OleDb:
     objFactory = OleDbFactory.Instance;
     break;
     case Providers.Oracle:
     objFactory = OracleClientFactory.Instance;
     break;
     case Providers.ODBC:
     objFactory = OdbcFactory.Instance;
     break;
     case Providers.ConfigDefined:
     string providername=ConfigurationManager.ConnectionStrings["connectionstring"].ProviderName;
     switch (providername)
     {
     case "System.Data.SqlClient":
     objFactory = SqlClientFactory.Instance;
     break;
     case "System.Data.OleDb":
     objFactory = OleDbFactory.Instance;
     break;
     case "System.Data.OracleClient":
     objFactory = OracleClientFactory.Instance;
     break;
     case "System.Data.Odbc":
     objFactory = OdbcFactory.Instance;
     break;
     }
     break;
    
     }
     objConnection = objFactory.CreateConnection();
     objCommand = objFactory.CreateCommand();
    
     objConnection.ConnectionString = strConnectionString;
     objCommand.Connection = objConnection;
     }
    
     public DataBaseHelper(Providers provider):this(ConfigurationManager.ConnectionStrings["connectionstring"].ConnectionString,provider)
     {
     }
    
     public DataBaseHelper(string connectionstring): this(connectionstring, Providers.SqlServer)
     {
     }
     public DataBaseHelper():this(ConfigurationManager.ConnectionStrings["connectionstring"].ConnectionString,Providers.ConfigDefined)
     {
     }
    


     public bool HandleErrors
     {
     get
     {
     return boolHandleErrors;
     }
     set
     {
     boolHandleErrors = value;
     }
     }
    
     public string LastError
     {
     get
     {
     return strLastError;
     }
     }
    
     public bool LogErrors
     {
     get
     {
     return boolLogError;
     }
     set
     {
     boolLogError=value;
     }
     }
    
     public string LogFile
     {
     get
     {
     return strLogFile;
     }
     set
     {
     strLogFile = value;
     }
     }
    
     public int AddParameter(string name,object value)
     {
     DbParameter p = objFactory.CreateParameter();
     p.ParameterName = name;
     p.Value=value;
     return objCommand.Parameters.Add(p);
     }
    
     public int AddParameter(DbParameter parameter)
     {
     return objCommand.Parameters.Add(parameter);
     }
    
     public DbCommand Command
     {
     get
     {
     return objCommand;
     }
     }
    
     public void BeginTransaction()
     {
     if (objConnection.State == System.Data.ConnectionState.Closed)
     {
     objConnection.Open();
     }
     objCommand.Transaction = objConnection.BeginTransaction();
     }
    
     public void CommitTransaction()
     {
     objCommand.Transaction.Commit();
     objConnection.Close();
     }
    
     public void RollbackTransaction()
     {
     objCommand.Transaction.Rollback();
     objConnection.Close();
     }
    
     public int ExecuteNonQuery(string query)
     {
     return ExecuteNonQuery(query, CommandType.Text, ConnectionState.CloseOnExit);
     }
    
     public int ExecuteNonQuery(string query,CommandType commandtype)
     {
     return ExecuteNonQuery(query, commandtype, ConnectionState.CloseOnExit);
     }
    
     public int ExecuteNonQuery(string query,ConnectionState connectionstate)
     {
     return ExecuteNonQuery(query,CommandType.Text,connectionstate);
     }
    
     public int ExecuteNonQuery(string query,CommandType commandtype, ConnectionState connectionstate)
     {


         if (!PPS.Properties.Settings.Default._svrDataBaseDBType.ToLower().Contains("oledb"))
         {
             query = query.Replace("#", "'");
             query = query.Replace("*"," ");
         }


     objCommand.CommandText = query;
     objCommand.CommandType = commandtype;
     int i=-1;
     try
     {
     if (objConnection.State == System.Data.ConnectionState.Closed)
     {
     objConnection.Open();
     }
     i = objCommand.ExecuteNonQuery();
     }
     catch (Exception ex)
     {
         Console.WriteLine(ex.ToString() + "\r\n" + query);
        HandleExceptions(ex);
     }
     finally
     {
     objCommand.Parameters.Clear();
     if (connectionstate == ConnectionState.CloseOnExit)
     {
     objConnection.Close();
     }
     }
    
     return i;
     }
    
     public object ExecuteScalar(string query)
     {
     return ExecuteScalar(query, CommandType.Text, ConnectionState.CloseOnExit);
     }
    
     public object ExecuteScalar(string query,CommandType commandtype)
     {
     return ExecuteScalar(query, commandtype, ConnectionState.CloseOnExit);
     }
    
     public object ExecuteScalar(string query, ConnectionState connectionstate)
     {
     return ExecuteScalar(query, CommandType.Text, connectionstate);
     }
    
     public object ExecuteScalar(string query,CommandType commandtype, ConnectionState connectionstate)
     {
         if (!PPS.Properties.Settings.Default._svrDataBaseDBType.ToLower().Contains("oledb"))
         {
             query = query.Replace("#", "'");
         }




     objCommand.CommandText = query;
     objCommand.CommandType = commandtype;
     object o = null;
     try
     {
     if (objConnection.State == System.Data.ConnectionState.Closed)
     {
     objConnection.Open();
     }
     o = objCommand.ExecuteScalar();
     }
     catch (Exception ex)
     {
         Console.WriteLine(ex.ToString() + "\r\n" + query);
     HandleExceptions(ex);
     }
     finally
     {
     objCommand.Parameters.Clear();
     if (connectionstate == ConnectionState.CloseOnExit)
     {
     objConnection.Close();
     }
     }
    
     return o;
     }
    
     public DbDataReader ExecuteReader(string query)
     {
     return ExecuteReader(query, CommandType.Text, ConnectionState.CloseOnExit);
     }
    
     public DbDataReader ExecuteReader(string query,CommandType commandtype)
     {
     return ExecuteReader(query, commandtype, ConnectionState.CloseOnExit);
     }
    
     public DbDataReader ExecuteReader(string query, ConnectionState connectionstate)
     {
     return ExecuteReader(query, CommandType.Text, connectionstate);
     }
    
     public DbDataReader ExecuteReader(string query,CommandType commandtype, ConnectionState connectionstate)
     {
         if (!PPS.Properties.Settings.Default._svrDataBaseDBType.ToLower().Contains("oledb"))
         {
             query = query.Replace("#", "'");
         }


     objCommand.CommandText = query;
     objCommand.CommandType = commandtype;
     DbDataReader reader=null;
     try
     {
     if (objConnection.State == System.Data.ConnectionState.Closed)
     {
     objConnection.Open();
     }
     if (connectionstate == ConnectionState.CloseOnExit)
     {
     reader = objCommand.ExecuteReader(CommandBehavior.CloseConnection);
     }
     else
     {
     reader = objCommand.ExecuteReader();
     }
    
     }
     catch (Exception ex)
     {
         Console.WriteLine(ex.ToString() + "\r\n" + query);
     HandleExceptions(ex);
     }
     finally
     {
     objCommand.Parameters.Clear();
     }
    
     return reader;
     }
    
     public DataSet ExecuteDataSet(string query)
     {
     return ExecuteDataSet(query, CommandType.Text, ConnectionState.CloseOnExit);
     }
    
     public DataSet ExecuteDataSet(string query,CommandType commandtype)
     {
     return ExecuteDataSet(query, commandtype, ConnectionState.CloseOnExit);
     }


     public DataSet ExecuteDataSet(string query, CommandType commandtype, List<StringAndObjectNode> _Paras)
     {
         objCommand.Parameters.Clear();
         foreach (StringAndObjectNode pn in _Paras)
         {
             AddParameter(pn.name, pn.value);
         }
         return ExecuteDataSet(query, commandtype, ConnectionState.CloseOnExit);
     }


     public DataSet ExecuteDataSet(string query,ConnectionState connectionstate)
     {
     return ExecuteDataSet(query, CommandType.Text, connectionstate);
     }
    
     public DataSet ExecuteDataSet(string query,CommandType commandtype, ConnectionState connectionstate)
     {
         if (!PPS.Properties.Settings.Default._svrDataBaseDBType.ToLower().Contains("oledb"))
         {
             query = query.Replace("#", "'");
         }


     DbDataAdapter adapter = objFactory.CreateDataAdapter();
     objCommand.CommandText = query;
     objCommand.CommandType = commandtype;
     adapter.SelectCommand = objCommand;
     DataSet ds = new DataSet();
     try
     {
     adapter.Fill(ds);
     }
     catch (Exception ex)
     {
         Console.WriteLine(ex.ToString() +"\r\n" +query);
     HandleExceptions(ex);
     }
     finally
     {
     objCommand.Parameters.Clear();
     if (connectionstate == ConnectionState.CloseOnExit)
     {
     if (objConnection.State == System.Data.ConnectionState.Open)
     {
     objConnection.Close();
     }
     }
     }
     return ds;
     }
    
     private void HandleExceptions(Exception ex)
     {
     if (LogErrors)
     {
     WriteToLog(ex.Message);
     }
     if (HandleErrors)
     {
     strLastError = ex.Message;
     }
     else
     {
     throw ex;
     }
     }
    
     private void WriteToLog(string msg)
     {
     StreamWriter writer= File.AppendText(LogFile);
     writer.WriteLine(DateTime.Now.ToString() + " - " + msg);
     writer.Close();
     }
     
     public void Dispose()
     {
     objConnection.Close();
     objConnection.Dispose();
     objCommand.Dispose();
     }
    
     }
    
     public enum Providers
     {
     SqlServer,OleDb,Oracle,ODBC,ConfigDefined
     }
    
     public enum ConnectionState
     {
     KeepOpen,CloseOnExit
     }

    }

、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、

using System.Collections;
using System; 
using System.Data; 
using System.Data.Odbc;
using System.Data.OleDb;
using PPS.Tool.Event;
using System.Collections.Generic;
using System.Data.SqlClient;
using System.Data.OracleClient;


namespace PPS.Tool.DataBass
{
    public class SqlSvrData
    {




        private DataBaseHelper _helper;




        public SqlSvrData()
        {
            Providers pro;
            if(PPS.Properties.Settings.Default._svrDataBaseDBType.ToLower().Contains("sql"))
            {
               pro= Providers.SqlServer;
            }else  if(PPS.Properties.Settings.Default._svrDataBaseDBType.ToLower().Contains("odbc"))
            {
               pro= Providers.ODBC;
            }else  if(PPS.Properties.Settings.Default._svrDataBaseDBType.ToLower().Contains("oracle"))
            {
               pro= Providers.Oracle;
            }
            else  if(PPS.Properties.Settings.Default._svrDataBaseDBType.ToLower().Contains("oledb"))
            {
               pro= Providers.OleDb;
            }else{
            pro= Providers.ConfigDefined;
            }
            
            _helper = new DataBaseHelper(PPS.Properties.Settings.Default._svrDataBaseConnetstring,pro);
        }






        public Boolean MyUpdatasql(string strsql)///////////跟新数据库
        {
            if (_helper.ExecuteNonQuery(strsql)==-1)
            {
                return false;
            }
            return true;
            //Debug.Log(dtYourData.Rows[0]["work_1"].ToString());
        }
      


        public DataSet selectDataSet(string sql)
        {
            return _helper.ExecuteDataSet(sql);
           
        }
        public DataSet selectDataSet(string query, CommandType commandtype)
        {
            return _helper.ExecuteDataSet( query, commandtype);


        }


        public DataSet selectDataSet(string query, CommandType commandtype, List<StringAndObjectNode> _Paras)
        {
            return _helper.ExecuteDataSet(query, commandtype, _Paras);


        }


        //插入数据 
        public bool InsertRow(string tableName, List<Node> arrayLiat,
             PictureNode pictureNode)
        {


            try
            {


                string col = "";
                string val = "";


                if (PPS.Properties.Settings.Default._svrDataBaseDBType.ToLower().Contains("sql"))
                {


                    foreach (Node node in arrayLiat)
                    {
                         if (node.NodeType.Contains("_count"))
                        {
                            col += node.NodeType + ",";
                            val = val + "" + node.NodeValue + ",";
                        }
                        else 
                        {
                            col += node.NodeType + ",";
                            val = val + "'" + node.NodeValue + "',";
                        }


                    }
                    col = col.TrimEnd(',');
                    val = val.TrimEnd(',');


                    if (pictureNode.NodeType != "" && pictureNode.NodeValue.Length != 1)
                    {
                        col += ',' + pictureNode.NodeType;
                        val += ",@Image";
                    }


                    string sql = "insert into " + tableName + " (" + col + ") values" + "(" + val + ")";


                    if (pictureNode.NodeType != "" && pictureNode.NodeValue.Length != 1)
                    {
                        SqlParameter param = new SqlParameter("@Image", pictureNode.NodeValue);
                        _helper.Command.Parameters.Add(param);
                    }
                    _helper.Command.CommandText = sql;
                }
                else if (PPS.Properties.Settings.Default._svrDataBaseDBType.ToLower().Contains("odbc"))
                {
                    if (pictureNode.NodeType != "" && pictureNode.NodeValue.Length != 1)
                    {
                        OdbcParameter[] param = new OdbcParameter[] { new OdbcParameter("@Image", pictureNode.NodeValue) };
                        _helper.Command.Parameters.Add(param);
                    }
                   
                }
                else if (PPS.Properties.Settings.Default._svrDataBaseDBType.ToLower().Contains("oracle"))
                {
                    OracleParameter[] param = new OracleParameter[] { new OracleParameter("@Image", pictureNode.NodeValue) };
                    _helper.Command.Parameters.Add(param);
                   
                }
                else if (PPS.Properties.Settings.Default._svrDataBaseDBType.ToLower().Contains("oledb"))
                {




                    foreach (Node node in arrayLiat)
                    {
                        if (node.NodeType.Contains("_date"))
                        {
                            col += node.NodeType + ",";
                            val = val + "#" + node.NodeValue + "#,";
                        }
                        else if (node.NodeType.Contains("_count"))
                        {
                            col += node.NodeType + ",";
                            val = val + "" + node.NodeValue + ",";
                        }
                        else
                        {
                            col += node.NodeType + ",";
                            val = val + "'" + node.NodeValue + "',";
                        }


                    }
                    col = col.TrimEnd(',');
                    val = val.TrimEnd(',');


                    if (pictureNode.NodeType != "" && pictureNode.NodeValue.Length != 1)
                    {
                        col += ',' + pictureNode.NodeType;
                        val += ",@Image";
                    }


                    string sql = "insert into " + tableName + " (" + col + ") values" + "(" + val + ")";


                    if (pictureNode.NodeType != "" && pictureNode.NodeValue.Length != 1)
                    {
                        OleDbParameter[] param = new OleDbParameter[] { new OleDbParameter("@Image", pictureNode.NodeValue) };
                        _helper.Command.Parameters.Add(param);
                      
                    }
                    _helper.Command.CommandText = sql;
                }


                _helper.Command.Connection.Open();
                if (_helper.Command.ExecuteNonQuery() != -1)
                { return true; }
                else {
                    return false;
                }


               
            }
            catch (Exception err)
            {
                Console.WriteLine(err.ToString());
                return false;
            }
            finally
            {
                _helper.Command.Connection.Close();
                GC.Collect();
            }
        }


        //更新一行数据 
        public bool UpdateRow(string tableName, List<Node> arrayLiat,
             PictureNode pictureNode)
        {
            
            try
            {


                //2、打开连接 
             
                string sql = "";
                Node KeyNode = new Node(((Node)arrayLiat[0]).NodeType, ((Node)arrayLiat[0]).NodeValue); ;
                arrayLiat.RemoveAt(0);


               
                if (PPS.Properties.Settings.Default._svrDataBaseDBType.ToLower().Contains("sql"))
                {


                    foreach (Node node in arrayLiat)
                    {
                        
                        if (node.NodeType.Contains("_count"))
                        {
                            sql += node.NodeType + "=" + node.NodeValue + ",";
                        }
                        else
                        {
                            sql += node.NodeType + "='" + node.NodeValue + "',";
                        }


                    }
                    sql = sql.TrimEnd(',');


                    if (pictureNode.NodeType != "" && pictureNode.NodeValue.Length != 1)
                    {
                        sql += "," + pictureNode.NodeType + "=@Image ";


                    }


                    if (KeyNode.NodeType.Contains("_count"))
                    {
                    }
                    else
                    {
                        KeyNode.NodeValue = "'" + KeyNode.NodeValue + "'";
                    }


                    string mysql = "update " + tableName + " set " + sql +


                     " where " + KeyNode.NodeType + " = " + KeyNode.NodeValue;


                    if (pictureNode.NodeType != "" && pictureNode.NodeValue.Length != 1)
                    {
                        SqlParameter param = new SqlParameter("@Image", pictureNode.NodeValue);
                        _helper.Command.Parameters.Add(param);
                    }
                    _helper.Command.CommandText = mysql;
                }
                else if (PPS.Properties.Settings.Default._svrDataBaseDBType.ToLower().Contains("odbc"))
                {
                    if (pictureNode.NodeType != "" && pictureNode.NodeValue.Length != 1)
                    {
                        OdbcParameter[] param = new OdbcParameter[] { new OdbcParameter("@Image", pictureNode.NodeValue) };
                        _helper.Command.Parameters.Add(param);
                    }
                }
                else if (PPS.Properties.Settings.Default._svrDataBaseDBType.ToLower().Contains("oracle"))
                {
                    OracleParameter[] param = new OracleParameter[] { new OracleParameter("@Image", pictureNode.NodeValue) };
                    _helper.Command.Parameters.Add(param);
                }
                else if (PPS.Properties.Settings.Default._svrDataBaseDBType.ToLower().Contains("oledb"))
                {


                    foreach (Node node in arrayLiat)
                    {
                        if (node.NodeType.Contains("_date"))
                        {
                            sql += node.NodeType + "=#" + node.NodeValue + "#,";
                        }
                        else if (node.NodeType.Contains("_count"))
                        {
                            sql += node.NodeType + "=" + node.NodeValue + ",";
                        }
                        else
                        {
                            sql += node.NodeType + "='" + node.NodeValue + "',";
                        }


                    }
                    sql = sql.TrimEnd(',');


                    if (pictureNode.NodeType != "" && pictureNode.NodeValue.Length != 1)
                    {
                        sql += "," + pictureNode.NodeType + "=@Image ";


                    }




                    if (KeyNode.NodeType.Contains("_date"))
                    {
                        KeyNode.NodeValue = "#" + KeyNode.NodeValue + "#";
                    }
                    else if (KeyNode.NodeType.Contains("_count"))
                    {
                    }
                    else
                    {
                        KeyNode.NodeValue = "'" + KeyNode.NodeValue + "'";
                    }


                    string mysql = "update " + tableName + " set " + sql +


                     " where " + KeyNode.NodeType + " = " + KeyNode.NodeValue;


                    if (pictureNode.NodeType != "" && pictureNode.NodeValue.Length != 1)
                    {
                        OleDbParameter[] param = new OleDbParameter[] { new OleDbParameter("@Image", pictureNode.NodeValue) };
                        _helper.Command.Parameters.Add(param);
                    } _helper.Command.CommandText = mysql;


                }
                _helper.Command.Connection.Open();
                if (_helper.Command.ExecuteNonQuery() != -1)
                { return true; }
                else
                {
                    return false;
                }


            }
            catch (Exception err)
            {
                Console.WriteLine(err.ToString());
                return false;
            }
            finally
            {
                _helper.Command.Connection.Close();
                GC.Collect();
            }
        }
    }


}