.net(C#数据库访问) Mysql,Sql server,Sqlite,Access四种数据库的连接方式

便签记录MysqL,sql server,sqlite,Access四种数据库的简单连接方式

//using MysqL.Data.MysqLClient; 
#region  执行简单sql语句,使用MySQL查询
        static string  strConn = "server=.;database=Data20180608;uid=sa;pwd=123456;integrated Security=sspI;persist Security info=false;";
        /// <summary>
        /// 执行sql语句，返回影响的记录数
        /// </summary>
        /// <param name="sqlString">sql语句</param>
        /// <returns>影响的记录数</returns>
        public static int MyExecutesql(string sqlString)
        {
            using (MysqLConnection connection = new MysqLConnection(strConn))
            {
                using (MysqLCommand cmd = new MysqLCommand(sqlString, connection))
                {
                    try
                    {
                        connection.open();
                        int rows = cmd.ExecuteNonQuery();
                        return rows;
                    }
                    catch (System.Data.sqlClient.sqlException e)
                    {
                        connection.Close();
                        throw e;
                    }
                }
            }
        }
        /// <summary>
        /// 执行查询语句，返回DataTable
        /// </summary>
        /// <param name="sqlString">查询语句</param>
        /// <returns>DataSet</returns>
        public static DataTable MyQuery(string sqlString)
        {
            using (MysqLConnection connection = new MysqLConnection(strConn))
            {
                DataSet ds = new DataSet();
                try
                {
                    connection.open();
                    MysqLDataAdapter command = new MysqLDataAdapter(sqlString, connection);
                    command.Fill(ds, "ds");
                }
                catch (System.Data.sqlClient.sqlException ex)
                {
                    throw new Exception(ex.Message);
                }
                return ds.Tables[0];
            }
        }
        #endregion

MysqL

 

 #region  执行简单sql语句,使用sql SERVER查询
        static string strConn = "Data Source=.;database=Data20180608;User id=root;Password=123456;pooling=false;CharSet=utf8;port=3306;";

        /// <summary>
        /// 执行sql语句，返回影响的记录数
        /// </summary>
        /// <param name="sqlString">sql语句</param>
        /// <returns>影响的记录数</returns>
        public static int Executesql(string sqlString)
        {
            using (sqlConnection connection = new sqlConnection(strConn))
            {
                using (sqlCommand cmd = new sqlCommand(sqlString, connection))
                {
                    try
                    {
                        connection.open();
                        int rows = cmd.ExecuteNonQuery();
                        return rows;
                    }
                    catch (System.Data.sqlClient.sqlException e)
                    {
                        connection.Close();
                        throw e;
                    }
                }
            }
        }
        /// <summary>
        /// 执行查询语句，返回DataTable
        /// </summary>
        /// <param name="sqlString">查询语句</param>
        /// <returns>DataSet</returns>
        public static DataTable Query(string sqlString)
        {
            using (sqlConnection connection = new sqlConnection(strConn))
            {
                DataSet ds = new DataSet();
                try
                {
                    connection.open();
                    sqlDataAdapter command = new sqlDataAdapter(sqlString, connection);
                    command.Fill(ds, "ds");
                }
                catch (System.Data.sqlClient.sqlException ex)
                {
                    throw new Exception(ex.Message);
                }
                return ds.Tables[0];
            }
        }
        #endregion

sql server

 

//using System.Data.OleDb;
 public static string OtherPAth = "";
        public static string strConn = "Provider=Microsoft.Jet.OLEDB.4.0;Data Source=";
       public static string sql = String.Empty;
        #region  执行简单sql语句,使用OleDb查询

        /// <summary>
        /// 执行sql语句，返回影响的记录数
        /// </summary>
        /// <param name="sqlString">sql语句</param>
        /// <returns>影响的记录数</returns>
        public static int Executesql(string sqlString)
        {
            using (OleDbConnection connection = new OleDbConnection(strConn + OtherPAth ))
            {
                using (OleDbCommand cmd = new OleDbCommand(sqlString, connection))
                {
                    try
                    {
                        connection.open();
                        int rows = cmd.ExecuteNonQuery();
                        return rows;
                    }
                    catch (System.Data.sqlClient.sqlException e)
                    {
                        connection.Close();
                        throw e;
                    }
                }
            }
        }

      


        /// <summary>
        /// 执行查询语句，返回DataTable
        /// </summary>
        /// <param name="sqlString">查询语句</param>
        /// <returns>DataSet</returns>
        public static DataTable Query(string sqlString)
        {
            using (OleDbConnection connection = new OleDbConnection(strConn + OtherPAth))
            {
                DataSet ds = new DataSet();
                try
                {
                    connection.open();
                    OleDbDataAdapter command = new OleDbDataAdapter(sqlString, connection);
                    command.Fill(ds, "ds");
                }
                catch (Exception ex)
                {
                    System.Windows.Forms.MessageBox.Show(ex.Message);
                }
                return ds.Tables[0];
            }
        }

        /// <summary>
        /// 执行查询语句，返回DataTable
        /// </summary>
        /// <param name="sqlString">查询语句</param>
        /// <returns>DataSet</returns>
        public static DataTable QueryDataname()
        {
            using (OleDbConnection connection = new OleDbConnection(strConn + OtherPAth))
            {
                DataTable ds = new DataTable();
                try
                {
                    connection.open();
                    ds = connection.GetoleDbSchemaTable(OleDbSchemaGuid.Tables, new object[] { null, null, null, "TABLE" });
                }
                catch (Exception ex)
                {
                    System.Windows.Forms.MessageBox.Show(ex.Message);
                }
                return ds;
            }
        }

        #endregion

Access

 

 public static string strConn = @"Data Source=" + @"F:\资料文档\20190227\CAD\0625AnPin\CadDLLcl\Data\Cad_try0626.db";
        public static string sql = String.Empty;

        /// <summary>
        /// 执行sql语句，返回影响的记录数
        /// </summary>
        /// <param name="sqlString">sql语句</param>
        /// <returns>影响的记录数</returns>
        public static int Executesql(string sqlString)
        {
            using (sqliteConnection connection = new sqliteConnection(strConn))
            {
                //事务
                using (sqliteTransaction singleTrans = connection.BeginTransaction(IsolationLevel.ReadCommitted))
                {
                    using (sqliteCommand cmd = new sqliteCommand(sqlString, connection))
                    {
                        try
                        {
                            connection.open();
                            cmd.Transaction = singleTrans;
                            int rows = cmd.ExecuteNonQuery();
                            singleTrans.Commit();
                            return rows;
                        }
                        catch (System.Data.sqlClient.sqlException e)
                        {
                            connection.Close();
                            singleTrans.Rollback();
                            throw e;
                        }
                    }
                }
            }
        }

        /// <summary>
        /// 执行查询语句，返回DataTable
        /// </summary>
        /// <param name = "sqlString" > 查询语句 </ param >
        /// < returns > DataSet </ returns >
        public static DataTable Query(string sqlString)
        {
            using (sqliteConnection connection = new sqliteConnection(strConn))
            {
                DataSet ds = new DataSet();
                try
                {
                    connection.open();
                    sqliteDataAdapter command = new sqliteDataAdapter(sqlString, connection);
                    command.Fill(ds, "ds");
                    return ds.Tables[0];
                }
                catch (Exception ex)
                {
                    connection.Close();
                    throw ex;
                }
            }
        }


        /// <summary>
        /// 执行存储过程，返回影响的记录数
        /// </summary>
        /// <param name="sqlString">sql语句</param>
        /// <returns>影响的记录数</returns>
        public static int ExecuteProc(string procName, sqliteParameter[] coll)
        {
            using (sqliteConnection connection = new sqliteConnection(strConn))
            {
                //事务
                using (sqliteTransaction singleTrans = connection.BeginTransaction(IsolationLevel.ReadCommitted))
                {
                    using (sqliteCommand cmd = new sqliteCommand(connection))
                    {
                        try
                        {
                            connection.open();
                            for (int i = 0; i < coll.Length; i++)
                            {
                                cmd.Parameters.Add(coll[i]);
                            }
                            cmd.CommandType = CommandType.StoredProcedure;
                            cmd.CommandText = procName;
                            cmd.Transaction = singleTrans;
                            int rows = cmd.ExecuteNonQuery();
                            singleTrans.Commit();
                            return rows;
                        }
                        catch (System.Data.sqlClient.sqlException e)
                        {
                            connection.Close();
                            singleTrans.Rollback();
                            throw e;
                        }
                    }
                }
            }
        }


        /// <summary>
        /// 执行带参数的sql语句，返回影响的记录数
        /// </summary>
        /// <param name="sqlString">sql语句</param>
        /// <returns>影响的记录数</returns>
        public static int ExecutesqlPar(string sqlPar, sqliteParameter[] coll)
        {
            using (sqliteConnection connection = new sqliteConnection(strConn))
            {
                //事务
                using (sqliteTransaction singleTrans = connection.BeginTransaction(IsolationLevel.ReadCommitted))
                {
                    using (sqliteCommand cmd = new sqliteCommand(connection))
                    {
                        try
                        {
                            connection.open();
                            for (int i = 0; i < coll.Length; i++)
                            {
                                cmd.Parameters.Add(coll[i]);
                            }
                            cmd.CommandType = CommandType.Text;
                            cmd.CommandText = sqlPar;
                            cmd.Transaction = singleTrans;
                            int rows = cmd.ExecuteNonQuery();
                            singleTrans.Commit();
                            return rows;
                        }
                        catch (System.Data.sqlClient.sqlException e)
                        {
                            connection.Close();
                            singleTrans.Rollback();
                            throw e;
                        }
                    }
                }
            }
        }

sqlite