自己寫的AccessDBHelper

最近,一个项目需要用到MDB文件,所以就自己写了一个小类库实现一些用到的功能,这不是一个万能的MDB操作功能类库,功能比我这强百倍的,网上一搜大把.但毕竟不是出自自己之手,用起来是方便,以后维护就是怕会头脑空白一片.

由于是完整代码,有点长.先介绍基本功能,以免误了各位看官的时间,要是这些功能没有值得一看的,路过路过了!

1.MDB的创建;

2.在MDB中创建表;

3.MDB表内容的增删改查;

4.文件的辅助操作类;

5.测试WEB.

项目的结构如下图:

测试内容如下:

详细介绍:

文件的辅助操作类

因为要用到建立文件和读取,从开始就应该想好,要有一个专门的类来处理一些与文件有关的功能,例如以下用到的功能都写入FilePathTools.cs中,这个类的主要作用有

1.给出一个文件的完整路径,得到扩展名;

我为了建立一个MDB文件,一定会输入一个完整的文件路径来创建文件,但是输入的文件是不是MDB文件,就要取出扩展名来判断了,所以要有一个取扩展名的方法.

2.取出文件名简名和全名;

有时候免不了要用到文件名,单单是文件名,不包含路径,这里就有取出带扩展名和不带扩展名的两个方法.

3.取出文件的所在路径;

这里也用到取出文件的路径的方法.

4.判断文件是否存在;

要创建文件,先要看看你想创建的文件是否已存在了.

5.判断文件所在的路径是否存在;

你想建立文件,必需先有路径,所以要判断你的目标路径是否存在.

6.创建路径;

目标路径不存在的时候,你要先创建路径.

以下是类文件的C#代码

FilePathTools.cs

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

namespace Core
{
    public static class FilePathTools
    {
        /// <summary>
        /// 取出文件擴展名
        /// </summary>
        /// <param name="FileName">文件名</param>
        /// <returns></returns>
        public static string GetExtFileTypeName(string FileName)
        {
            string sFile = FileName;
            sFile = sFile.Substring(sFile.LastIndexOf("\\") + 1);
            sFile = sFile.Substring(sFile.LastIndexOf(".")).ToLower();
            return sFile;
        }

        /// <summary>
        /// 取出文件名,包括擴展名的完整名稱
        /// </summary>
        /// <param name="FileName">文件名</param>
        /// <returns></returns>
        public static string GetFileFullName(string FileName)
        {
            string sFile = FileName;
            sFile = sFile.Substring(sFile.LastIndexOf("\\") + 1);
            //sFile = sFile.Substring(sFile.LastIndexOf(".")).ToLower();
            return sFile;
        }

        /// <summary>
        /// 取出文件名,不包括擴展名
        /// </summary>
        /// <param name="FileName">文件名</param>
        /// <returns></returns>
        public static string GetFileName(string FileName)
        {
            string sFile = FileName;
            sFile = sFile.Substring(sFile.LastIndexOf("\\") + 1);
            sFile = sFile.Substring(0,sFile.LastIndexOf(".")).ToLower();
            return sFile;
        }

        /// <summary>
        /// 取出文件所在的路徑
        /// </summary>
        /// <param name="FileName">文件名</param>
        /// <returns></returns>
        public static string GetFilePath(string FileName)
        {
            string sFile = FileName;
            sFile = sFile.Substring(0,sFile.LastIndexOf("\\") );
            return sFile;
        }

        /// <summary>
        /// 文件所在的路徑是否存在
        /// </summary>
        /// <param name="FileName">文件名</param>
        /// <returns></returns>
        public static bool HasFilePath(string FileName)
        {
            return Directory.Exists(GetFilePath(FileName));
        }

        /// <summary>
        /// 路徑創建
        /// </summary>
        /// <param name="FileName">文件名</param>
        /// <returns></returns>
        public static bool CreatePath(string path)
        {
            try
            {
                if (!HasFilePath(GetFilePath(path)))
                {
                    CreatePath(GetFilePath(path));
                }
                Directory.CreateDirectory(path);
                return true;
            }
            catch(Exception ee)
            {
                throw new Exception(ee.Message);
            }
        }

        /// <summary>
        /// 文件是否存在
        /// </summary>
        /// <param name="FileName">文件名</param>
        /// <returns></returns>
        public static bool HasFile(string FileName)
        {
            return File.Exists(FileName);
        }
    }
}

创建MDB文件

创建MDB文件只有一个方法,但是我还是用一个单独的类来写,谁又知道那天会不会要加一些功能呢?

给一个完整的文件路径,做一些判断,你要建立MDB文件,那就要看输入的是不是MDB文件.你还要看目标文件路径是不是已存在,要是没有,那就要先建立路径,再创建文件.

要创建MDB文件,你用ADO.NET是做不来的,需要用到ADOX,引用ADOX的方法是在项目中加入引用,选COM,再找到

Microsoft ADO Ext.x.x for DDL and Security,通常使用2.7或2.8版本,但是现在已有6.0的了,我也是使用6.0版本.用法请参考代码清单.

创建MDB代码清单如下:

CreateMDB.cs

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

namespace Core.AccessDBHelper
{
   public  class CreateMDB:ICreateDB
    {
        #region ICreateDB Members

       public  bool CreateAccessFile(string filename)
       {
           try
           {
               if (FilePathTools.GetExtFileTypeName(filename).ToLower() != ".mdb")
               {
                   throw new Exception("創建MDB文件時,需要一個.mdb擴展名的文件名稱.");
               }
               if (!FilePathTools.HasFilePath(FilePathTools.GetFilePath(filename)))
               {
                   if (FilePathTools.CreatePath(FilePathTools.GetFilePath(filename)))
                   {
                       throw new Exception("創建MDB文件時,需要一個有效的路徑.");
                   }
               }
               ADOX.CatalogClass cat = new CatalogClass();
               string str = "provider=Microsoft.Jet.OleDb.4.0;Data Source=" +  filename + ";";
               cat.Create(str);
               cat = null;
               return true;
           }
           catch (Exception ee)
           {
               throw new Exception(ee.Message);
           }
       }

        #endregion
    }
}

在MDB文件中创建表

创建表的功能也使用单独的类来处理,直接参看以下代码:

CreateTable.cs

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

namespace Core.AccessDBHelper
{
    public static class CreateTable
    {
        public static bool Create(string mdbFile, string strCreateTableSql)
        {
            OleDbConnection DBConnection;
            OleDbCommand DBCommand = new OleDbCommand();   //   数据库命令
            #region   打开数据库
            string strConnect = @"provider=Microsoft.Jet.OleDb.4.0;Data Source=" + mdbFile + "; ";
            DBConnection = new OleDbConnection(strConnect);
            DBCommand.Connection = DBConnection;
            try
            {
                if (DBCommand.Connection.State != ConnectionState.Open)
                {
                    DBCommand.Connection.Open();//打开数据库连接
                }
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
            #endregion
            #region   建表
            //string strSql = "CREATE TABLE "+tableName+"(ID     varchar(2),   name     varchar(50)   NOT   NULL) ";
            DBCommand.CommandText = strCreateTableSql;

            try
            {
                DBCommand.ExecuteNonQuery();
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
            #endregion
            DBCommand.Connection.Close();//   关闭数据库连接
            return true;
        }
    }
}

数据的增删改查

功能与SQLHelper功能相似,不多说.以下是代码,有注释

MDBHelper.cs

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

namespace Core.AccessDBHelper
{
    public static class MDBHelper
    {
        //数据库连接字符串
        public static string GetMDBConnectionString(string mdbFile)
        {
            return @"provider=Microsoft.Jet.OleDb.4.0;Data Source=" + mdbFile + "; ";
        }
        //数据库连接字符串
        public static OleDbConnection GetMDBConnection(string mdbFile)
        {
            return new OleDbConnection(GetMDBConnectionString(mdbFile));
        }

        // 用于缓存参数的HASH表
        private static Hashtable parmCache = Hashtable.Synchronized(new Hashtable());
        /// <summary>
        /// 给定连接的数据库用假设参数执行一个sql命令（不返回数据集）
        /// </summary>
        /// <param name="connectionString">一个有效的连接字符串</param>
        /// <param name="commandText">存储过程名称或者sql命令语句</param>
        /// <param name="commandParameters">执行命令所用参数的集合</param>
        /// <returns>执行命令所影响的行数</returns>
        public static int ExecuteNonQuery(string connectionString, string cmdText, params OleDbParameter[] commandParameters)
        {

            OleDbCommand cmd = new OleDbCommand();
            using (OleDbConnection conn = new OleDbConnection(connectionString))
            {
                try
                {
                    PrepareCommand(cmd, conn, null, cmdText, commandParameters);
                    int val = cmd.ExecuteNonQuery();
                    cmd.Parameters.Clear();
                    return val;
                }
                catch (Exception ee)
                {
                    throw ee;
                }
                finally
                {
                    if (conn.State != ConnectionState.Closed)
                    {
                        conn.Close();
                    }
                }
            }


        }
        /// <summary>
        /// 用现有的数据库连接执行一个sql命令（不返回数据集）
        /// </summary>
        /// <remarks>
        ///举例:
        /// int result = ExecuteNonQuery(connString, "PublishOrders", new OleDbParameter("@prodid", 24));
        /// </remarks>
        /// <param name="conn">一个现有的数据库连接</param>
        /// <param name="commandText">存储过程名称或者sql命令语句</param>
        /// <param name="commandParameters">执行命令所用参数的集合</param>
        /// <returns>执行命令所影响的行数</returns>
        public static int ExecuteNonQuery(OleDbConnection conn, string cmdText, params OleDbParameter[] commandParameters)
        {
            try
            {
                OleDbCommand cmd = new OleDbCommand();
                PrepareCommand(cmd, conn, null, cmdText, commandParameters);
                int val = cmd.ExecuteNonQuery();
                cmd.Parameters.Clear();
                return val;
            }
            catch (Exception ee)
            {
                throw ee;
            }
            finally
            {
                if (conn.State != ConnectionState.Closed)
                {
                    conn.Close();
                }
            }
        }
        /// <summary>
        ///使用现有的SQL事务执行一个sql命令（不返回数据集）
        /// </summary>
        /// <remarks>
        ///举例:
        /// int result = ExecuteNonQuery(trans, "PublishOrders", new OleDbParameter("@prodid", 24));
        /// </remarks>
        /// <param name="trans">一个现有的事务</param>
        /// <param name="commandText">存储过程名称或者sql命令语句</param>
        /// <param name="commandParameters">执行命令所用参数的集合</param>
        /// <returns>执行命令所影响的行数</returns>
        public static int ExecuteNonQuery(OleDbTransaction trans, string cmdText, params OleDbParameter[] commandParameters)
        {
            try
            {
                OleDbCommand cmd = new OleDbCommand();
                PrepareCommand(cmd, trans.Connection, trans, cmdText, commandParameters);
                int val = cmd.ExecuteNonQuery();
                cmd.Parameters.Clear();
                return val;
            }
            catch (Exception ee)
            {
                throw ee;
            }

        }
        /// <summary>
        /// 用执行的数据库连接执行一个返回数据集的sql命令
        /// </summary>
        /// <remarks>
        /// 举例:
        /// OleDbDataReader r = ExecuteReader(connString, "PublishOrders", new OleDbParameter("@prodid", 24));
        /// </remarks>
        /// <param name="connectionString">一个有效的连接字符串</param>
        /// <param name="commandText">存储过程名称或者sql命令语句</param>
        /// <param name="commandParameters">执行命令所用参数的集合</param>
        /// <returns>包含结果的读取器</returns>
        public static OleDbDataReader ExecuteReader(string connectionString, string cmdText, params OleDbParameter[] commandParameters)
        {
            //创建一个SqlCommand对象
            OleDbCommand cmd = new OleDbCommand();
            //创建一个SqlConnection对象
            OleDbConnection conn = new OleDbConnection(connectionString);
            //在这里我们用一个try/catch结构执行sql文本命令/存储过程，因为如果这个方法产生一个异常我们要关闭连接，因为没有读取器存在，
            //因此commandBehaviour.CloseConnection 就不会执行
            try
            {
                //调用 PrepareCommand 方法，对 SqlCommand 对象设置参数
                PrepareCommand(cmd, conn, null, cmdText, commandParameters);
                //调用 SqlCommand 的 ExecuteReader 方法
                OleDbDataReader reader = cmd.ExecuteReader(CommandBehavior.CloseConnection);
                //清除参数
                cmd.Parameters.Clear();
                return reader;
            }
            catch (Exception ee)
            {
                throw ee;
            }
            finally
            {
                if (conn.State != ConnectionState.Closed)
                {
                    conn.Close();
                }
            }
        }
        /// <summary>
        /// 返回一个DataSet数据集
        /// </summary>
        /// <param name="connectionString">一个有效的连接字符串</param>
        /// <param name="cmdText">存储过程名称或者sql命令语句</param>
        /// <param name="commandParameters">执行命令所用参数的集合</param>
        /// <returns>包含结果的数据集</returns>
        public static DataSet ExecuteDataSet(string connectionString, string cmdText, params OleDbParameter[] commandParameters)
        {
            //创建一个SqlCommand对象，并对其进行初始化
            OleDbCommand cmd = new OleDbCommand();
            using (OleDbConnection conn = new OleDbConnection(connectionString))
            {
                PrepareCommand(cmd, conn, null, cmdText, commandParameters);
                //创建SqlDataAdapter对象以及DataSet
                OleDbDataAdapter da = new OleDbDataAdapter(cmd);
                DataSet ds = new DataSet();
                try
                {
                    //填充ds
                    da.Fill(ds);
                    // 清除cmd的参数集合
                    cmd.Parameters.Clear();
                    //返回ds
                    return ds;
                }
                catch (Exception ee)
                {
                    throw ee;
                }
                finally
                {
                    if (conn.State != ConnectionState.Closed)
                    {
                        conn.Close();
                    }
                }
            }
        }
        /// <summary>
        /// 用指定的数据库连接字符串执行一个命令并返回一个数据集的第一列
        /// </summary>
        /// <remarks>
        ///例如:
        /// Object obj = ExecuteScalar(connString, "PublishOrders", new OleDbParameter("@prodid", 24));
        /// </remarks>
        ///<param name="connectionString">一个有效的连接字符串</param>
        /// <param name="commandText">存储过程名称或者sql命令语句</param>
        /// <param name="commandParameters">执行命令所用参数的集合</param>
        /// <returns>用 Convert.To{Type}把类型转换为想要的 </returns>
        public static object ExecuteScalar(string connectionString, string cmdText, params OleDbParameter[] commandParameters)
        {
            OleDbCommand cmd = new OleDbCommand();
            using (OleDbConnection conn = new OleDbConnection(connectionString))
            {
                try
                {
                    PrepareCommand(cmd, conn, null, cmdText, commandParameters);
                    object val = cmd.ExecuteScalar();
                    cmd.Parameters.Clear();
                    return val;
                }
                catch (Exception ee)
                {
                    throw ee;
                }
                finally
                {
                    if (conn.State != ConnectionState.Closed)
                    {
                        conn.Close();
                    }
                }
            }
        }
        /// <summary>
        /// 用指定的数据库连接执行一个命令并返回一个数据集的第一列
        /// </summary>
        /// <remarks>
        /// 例如:
        /// Object obj = ExecuteScalar(connString, "PublishOrders", new OleDbParameter("@prodid", 24));
        /// </remarks>
        /// <param name="conn">一个存在的数据库连接</param>
        /// <param name="commandText">存储过程名称或者sql命令语句</param>
        /// <param name="commandParameters">执行命令所用参数的集合</param>
        /// <returns>用 Convert.To{Type}把类型转换为想要的 </returns>
        public static object ExecuteScalar(OleDbConnection conn, string cmdText, params OleDbParameter[] commandParameters)
        {
            try
            {
                OleDbCommand cmd = new OleDbCommand();
                PrepareCommand(cmd, conn, null, cmdText, commandParameters);
                object val = cmd.ExecuteScalar();
                cmd.Parameters.Clear();
                return val;
            }
            catch (Exception ee)
            {
                throw ee;
            }
            finally
            {
                if (conn.State != ConnectionState.Closed)
                {
                    conn.Close();
                }
            }
        }
        /// <summary>
        /// 将参数集合添加到缓存
        /// </summary>
        /// <param name="cacheKey">添加到缓存的变量</param>
        /// <param name="cmdParms">一个将要添加到缓存的sql参数集合</param>
        public static void CacheParameters(string cacheKey, params OleDbParameter[] commandParameters)
        {
            try
            {
                parmCache[cacheKey] = commandParameters;
            }
            catch (Exception ee)
            {
                throw ee;
            }
        }
        /// <summary>
        /// 找回缓存参数集合
        /// </summary>
        /// <param name="cacheKey">用于找回参数的关键字</param>
        /// <returns>缓存的参数集合</returns>
        public static OleDbParameter[] GetCachedParameters(string cacheKey)
        {
            try
            {
                OleDbParameter[] cachedParms = (OleDbParameter[])parmCache[cacheKey];
                if (cachedParms == null)
                    return null;
                OleDbParameter[] clonedParms = new OleDbParameter[cachedParms.Length];
                for (int i = 0, j = cachedParms.Length; i < j; i++)
                    clonedParms = (OleDbParameter[])((ICloneable)cachedParms).Clone();
                return clonedParms;
            }
            catch (Exception ee)
            {
                throw ee;
            }

        }
        /// <summary>
        /// 准备执行一个命令
        /// </summary>
        /// <param name="cmd">sql命令</param>
        /// <param name="conn">Sql连接</param>
        /// <param name="trans">Sql事务</param>
        /// <param name="cmdText">命令文本,例如：Select * from Products</param>
        /// <param name="cmdParms">执行命令的参数</param>
        private static void PrepareCommand(OleDbCommand cmd, OleDbConnection conn, OleDbTransaction trans, string cmdText, OleDbParameter[] cmdParms)
        {
            try
            {
                //判断连接的状态。如果是关闭状态，则打开
                if (conn.State != ConnectionState.Open)
                    conn.Open();
                //cmd属性赋值
                cmd.Connection = conn;
                cmd.CommandText = cmdText;
                //是否需要用到事务处理
                if (trans != null)
                    cmd.Transaction = trans;
                cmd.CommandType = CommandType.Text;
                //添加cmd需要的存储过程参数
                if (cmdParms != null)
                {
                    foreach (OleDbParameter parm in cmdParms)
                        cmd.Parameters.Add(parm);
                }
            }
            catch (Exception ee)
            {
                throw ee;
            }

        }
    }
}

测试代码

用一个页面来看看功能的工作是否正常,对以上的功能进行测试

测试取扩展名、取文件名、文件路径、检测文件和路径、建立MDB、建立表、写入数据等等功能。

Default.aspx

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
    <title></title>
</head>
<body>
    <form id="form1" runat="server">
    <div>
        <asp:TextBox ID="TextBox1" runat="server" Width="383px"></asp:TextBox>
        <asp:Button ID="Button1" runat="server" Text="Button" onclick="Button1_Click" />
        <asp:GridView ID="GridView1" runat="server">
        </asp:GridView>
    </div>
    </form>
</body>
</html>

Default.aspx.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
using Core;
using Core.AccessDBHelper;

public partial class _Default : System.Web.UI.Page
{
    protected void Page_Load(object sender, EventArgs e)
    {

    }
    protected void Button1_Click(object sender, EventArgs e)
    {
        try
        {
            Response.Write("擴展名:" + FilePathTools.GetExtFileTypeName(TextBox1.Text));
            Response.Write("<br/>");
        }
        catch (Exception ee)
        {
            Response.Write(ee.Message);
            Response.Write("<br/>");
        }
        try
        {
            Response.Write("文件名:" + FilePathTools.GetFileName(TextBox1.Text));
            Response.Write("<br/>");
        }
        catch (Exception ee)
        {
            Response.Write(ee.Message);
            Response.Write("<br/>");
        }
        try
        {
            Response.Write("文件全名:" + FilePathTools.GetFileFullName(TextBox1.Text));
            Response.Write("<br/>");
        }
        catch (Exception ee)
        {
            Response.Write(ee.Message);
            Response.Write("<br/>");
        }

        try
        {
            Response.Write("文件路徑:" + FilePathTools.GetFilePath(TextBox1.Text));
            Response.Write("<br/>");
        }
        catch (Exception ee)
        {
            Response.Write(ee.Message);
            Response.Write("<br/>");
        }
        try
        {
            Response.Write("文件是否存在:" + FilePathTools.HasFile(TextBox1.Text).ToString());
            Response.Write("<br/>");
        }
        catch (Exception ee)
        {
            Response.Write(ee.Message);
            Response.Write("<br/>");
        }
        try
        {
            Response.Write("文件路徑是否存在:" + FilePathTools.HasFilePath(TextBox1.Text).ToString());
            Response.Write("<br/>");
        }
        catch (Exception ee)
        {
            Response.Write(ee.Message);
            Response.Write("<br/>");
        }
        try
        {
            Response.Write("創建文件夾:" + FilePathTools.CreatePath(FilePathTools.GetFilePath(TextBox1.Text)).ToString());
            Response.Write("<br/>");
        }
        catch (Exception ee)
        {
            Response.Write(ee.Message);
            Response.Write("<br/>");
        }
        try
        {
            Response.Write("創建MDB文件:" + new CreateMDB().CreateAccessFile(TextBox1.Text));
            Response.Write("<br/>");
        }
        catch (Exception ee)
        {
            Response.Write(ee.Message);
            Response.Write("<br/>");
        }
        try
        {
            Response.Write("創建表:" + CreateTable.Create(TextBox1.Text, "CREATE TABLE test(ID varchar(2),name nvarchar(50) NOT NULL)").ToString());
            Response.Write("<br/>");
        }
        catch (Exception ee)
        {
            Response.Write(ee.Message);
            Response.Write("<br/>");
        }
        try
        {
            Response.Write("寫入記錄:" + MDBHelper.ExecuteNonQuery(MDBHelper.GetMDBConnection(TextBox1.Text),"insert into test(ID,name) values(1,'謝堂文');",null).ToString());
            Response.Write("<br/>");
        }
        catch (Exception ee)
        {
            Response.Write(ee.Message);
            Response.Write("<br/>");
        }
        try
        {
            GridView1.DataSource = MDBHelper.ExecuteDataSet(MDBHelper.GetMDBConnectionString(TextBox1.Text), "select * from test;", null);
            GridView1.DataBind();
        }
        catch
        {
        }
    }
}

源代码可从这里下载

生成的DLL文件从这里下载

本文原创,转载请注明出处.