Accesss

最新推荐文章于 2023-05-09 16:26:55 发布
最新推荐文章于 2023-05-09 16:26:55 发布
阅读量634 收藏 1
点赞数
分类专栏： DotNet 文章标签： access c#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/daividtu/article/details/50480635
版权

Access增删查改 及自己做的项目 采用Access

AccountTable.cs

using Newtonsoft.Json.Linq;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Data.OleDb;
using System.Data.SqlClient;
using System.Linq;
using System.Text;

namespace DAL
{
    public class AccountTable
    {
        public List<Model.Account> GetAccountInfo()
        {
            string sql = "select * from Account where year(date())=year([DateTime]) and month(date()) = month([DateTime])";
            OleDbDataReader dataread = DbHelperOleDb.ExecuteReader(sql);
            List<Model.Account> accounts = new List<Model.Account>();
            try
            {
                if (dataread.HasRows)
                {
                    while (dataread.Read())
                    {
                        accounts.Add(new Model.Account { ID = int.Parse(dataread["AccountId"].ToString()), Date = DateTime.Parse(dataread["DateTime"].ToString()), IncomeSpending = dataread["IncomeSpending"].ToString(), Amount = decimal.Parse(dataread["Amount"].ToString()), Operation = dataread["Operation"].ToString(), PaymentType = dataread["PaymentType"].ToString(), Note = dataread["Note"].ToString() });

                    }
                }
            }
            catch (Exception ex)
            {

                throw;
            }
            return accounts;
        }

        public bool InsertAccount(Model.Account account)
        {
            string sql = "INSERT INTO Account([DateTime], IncomeSpending, Amount, Operation, PaymentType, [Note]) VALUES (@DateTime,@IncomeSpending,@Amount,@Operation,@PaymentType,@Note)";


            OleDbParameter[] parameters = {
                new OleDbParameter("@DateTime",OleDbType.DBDate),
                new OleDbParameter("@IncomeSpending",account.IncomeSpending),
                new OleDbParameter("@Amount",OleDbType.Decimal),
                new OleDbParameter("@Operation", account.Operation),
                new OleDbParameter("@PaymentType", account.PaymentType),
                new OleDbParameter("@Note", account.Note)
            };
            parameters[0].Value = account.Date;
            parameters[2].Value = account.Amount;

            return DbHelperOleDb.ExecuteSql(sql, parameters) > 0;

        }

        public bool DeleteAccountInfo(params string[] ids)
        {
            string strid = string.Join(",", ids);
            string sql = "delete from Account where AccountId in (" + strid + ")";
            return DbHelperOleDb.ExecuteSql(sql) > 0;
        }

        public bool UpdataAccoutInfo(Model.Account account)
        {
            string sql = "UPDATE  Account SET  [DateTime] =@DateTime, IncomeSpending =@IncomeSpending, Amount =@Amount, Operation =@Operation, PaymentType =@PaymentType, [Note] =@Note where AccountId=@AccountId";
            OleDbParameter[] parameters = {
                new OleDbParameter("@DateTime",OleDbType.DBDate),
                new OleDbParameter("@IncomeSpending",account.IncomeSpending),
                new OleDbParameter("@Amount",OleDbType.Decimal),
                new OleDbParameter("@Operation", account.Operation),
                new OleDbParameter("@PaymentType", account.PaymentType),
                new OleDbParameter("@Note", account.Note),
                new OleDbParameter("@AccountId",OleDbType.BigInt)
            };
            parameters[0].Value = account.Date;
            parameters[2].Value = account.Amount;
            parameters[6].Value = account.ID;

            return DbHelperOleDb.ExecuteSql(sql, parameters)>0;
        }

        public List<Model.Account> SerachByGroup(string jsonStr,out string message)
        {
            JObject jo = JObject.Parse(jsonStr);
            List<OleDbParameter> parameters = new List<OleDbParameter>();
            StringBuilder strb = new StringBuilder();
            strb.Append("select * from Account where");
            strb.Append(" [DateTime]>=@startTime and [DateTime]<=@endTime");
            OleDbParameter start = new OleDbParameter("@startTime", OleDbType.DBDate);
            start.Value = jo["startTime"].Value<DateTime>();
            parameters.Add(start);
            OleDbParameter end = new OleDbParameter("@endTime", OleDbType.DBDate);
            end.Value = jo["endTime"].Value<DateTime>();
            message = "从" + jo["startTime"].Value<DateTime>().ToString("yyyy-MM-dd") + "至" + jo["endTime"].Value<DateTime>().ToString("yyyy-MM-dd") + "";
            parameters.Add(end);
            
            if (!string.IsNullOrWhiteSpace(jo["cominSpending"].Value<string>()))
            {
                strb.Append(" and IncomeSpending=@cominSpending");
                parameters.Add(new OleDbParameter("@cominSpending", jo["cominSpending"].Value<string>()));
            }
            if (!string.IsNullOrWhiteSpace(jo["Opration"].Value<string>()))
            {
                strb.Append(" and Operation=@Opration");
                parameters.Add(new OleDbParameter("@Opration", jo["Opration"].Value<string>()));
                message += " " + jo["Opration"].Value<string>() + "同志";
            }
            if (!string.IsNullOrWhiteSpace(jo["comoutType"].Value<string>()))
            {
                strb.Append(" and PaymentType=@comoutType");
                parameters.Add(new OleDbParameter("@comoutType", jo["comoutType"].Value<string>()));
                message+=" "+jo["comoutType"].Value<string>()+"";
            }
            if (!string.IsNullOrWhiteSpace(jo["Note"].Value<string>()))
            {
                strb.Append(" and [Note] like '%"+jo["Note"].Value<string>()+"%'");
                message+=" 备注包含\""+jo["Note"].Value<string>()+"\"的字符";
            }
            message+="共 收入:{0}元,支出:{1}元,剩余:{2}元";



            OleDbDataReader dataread = DbHelperOleDb.ExecuteReader(strb.ToString(), parameters.ToArray());

            List<Model.Account> accounts = new List<Model.Account>();
            try
            {
                if (dataread.HasRows)
                {
                    while (dataread.Read())
                    {
                        accounts.Add(new Model.Account { ID = int.Parse(dataread["AccountId"].ToString()), Date = DateTime.Parse(dataread["DateTime"].ToString()), IncomeSpending = dataread["IncomeSpending"].ToString(), Amount = decimal.Parse(dataread["Amount"].ToString()), Operation = dataread["Operation"].ToString(), PaymentType = dataread["PaymentType"].ToString(), Note = dataread["Note"].ToString() });

                    }
                }
            }
            catch (Exception ex)
            {

                throw;
            }
            return accounts;

            
        }

        public bool InsertAllAccountInfo(List<Model.Account> accounts,BackgroundWorker bw)
        {
            return DbHelperOleDb.ExecuteSql(accounts,bw)>0;
        }

    }
}

DbHelperOleDb.cs

using System;
using System.Collections;
using System.Collections.Specialized;
using System.Data;
using System.Data.OleDb;
using System.Configuration;
using DBUtility;
using System.Collections.Generic;
using System.ComponentModel;
using System.Threading;


namespace DAL
{
    /// <summary>
    /// 数据访问基础类(基于OleDb) 
    /// 可以用户可以修改满足自己项目的需要。
    /// Copyright (C) Maticsoft
    /// </summary>
    public abstract class DbHelperOleDb
    {
        //数据库连接字符串(web.config来配置)，可以动态更改connectionString支持多数据库.		
        public static string connectionString = PubConstant.ConnectionString;     		
        public DbHelperOleDb()
        {
        }


        #region 公用方法
       
        //public static int GetMaxID(string FieldName, string TableName)
        //{
        //    string strsql = "select max(" + FieldName + ")+1 from " + TableName;
        //    object obj = DbHelperSQL.GetSingle(strsql);
        //    if (obj == null)
        //    {
        //        return 1;
        //    }
        //    else
        //    {
        //        return int.Parse(obj.ToString());
        //    }
        //}
        //public static bool Exists(string strSql)
        //{
        //    object obj = DbHelperSQL.GetSingle(strSql);
        //    int cmdresult;
        //    if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
        //    {
        //        cmdresult = 0;
        //    }
        //    else
        //    {
        //        cmdresult = int.Parse(obj.ToString());
        //    }
        //    if (cmdresult == 0)
        //    {
        //        return false;
        //    }
        //    else
        //    {
        //        return true;
        //    }
        //}
        public static bool Exists(string strSql, params OleDbParameter[] cmdParms)
        {
            object obj = GetSingle(strSql, cmdParms);
            int cmdresult;
            if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
            {
                cmdresult = 0;
            }
            else
            {
                cmdresult = int.Parse(obj.ToString());
            }
            if (cmdresult == 0)
            {
                return false;
            }
            else
            {
                return true;
            }
        }
        
        #endregion

        /// <summary>
        /// 批量插入操作
        /// </summary>
        /// <param name="accounts"></param>
        /// <returns></returns>
        public static int ExecuteSql(List<Model.Account> accounts,BackgroundWorker backwork)
        {
            using (OleDbConnection connection = new OleDbConnection(connectionString))
            {
                connection.Open();
                using (OleDbTransaction transaction = connection.BeginTransaction())
                {
                    try
                    {
                        string sql = "INSERT INTO Account([DateTime], IncomeSpending, Amount, Operation, PaymentType, [Note]) VALUES (@DateTime,@IncomeSpending,@Amount,@Operation,@PaymentType,@Note)";
                        int i = 0;
                        foreach (var account in accounts)
                        {
                            OleDbParameter[] parameters = {
                                    new OleDbParameter("@DateTime",OleDbType.DBDate),
                                    new OleDbParameter("@IncomeSpending",account.IncomeSpending),
                                    new OleDbParameter("@Amount",OleDbType.Decimal),
                                    new OleDbParameter("@Operation", account.Operation),
                                    new OleDbParameter("@PaymentType", account.PaymentType),
                                    new OleDbParameter("@Note", account.Note)
                                };
                            parameters[0].Value = account.Date;
                            parameters[2].Value = account.Amount;
                            int count = ExecuteSql(transaction, sql, parameters);
                            backwork.ReportProgress(++i);
                            Thread.Sleep(200);
                        }
                        transaction.Commit();
                        return 1;
                    }
                    catch (Exception ex)
                    {
                        transaction.Rollback();
                        throw ex;
                    }
                    finally
                    {
                        connection.Close();
                    }
                }
               
            }
        }

        private static int ExecuteSql(OleDbTransaction transaction, string sql, OleDbParameter[] parameters)
        {
            if (transaction.Connection.State != ConnectionState.Open)
                transaction.Connection.Open();
            using (OleDbCommand cmd = new OleDbCommand())
            {
                cmd.Connection = transaction.Connection;
                cmd.Transaction = transaction;
                cmd.CommandType = CommandType.Text;
                cmd.CommandText = sql;
                foreach (var a in parameters)
                    cmd.Parameters.Add(a);
                int val = cmd.ExecuteNonQuery();
                cmd.Parameters.Clear();
                return val;
            }
        }

        #region  执行简单SQL语句

        /// <summary>
        /// 执行SQL语句，返回影响的记录数
        /// </summary>
        /// <param name="SQLString">SQL语句</param>
        /// <returns>影响的记录数</returns>
        public static int ExecuteSql(string SQLString)
        {
            using (OleDbConnection connection = new OleDbConnection(connectionString))
            {
                using (OleDbCommand cmd = new OleDbCommand(SQLString, connection))
                {
                    try
                    {
                        connection.Open();
                        int rows = cmd.ExecuteNonQuery();
                        return rows;
                    }
                    catch (System.Data.OleDb.OleDbException E)
                    {
                        connection.Close();
                        throw new Exception(E.Message);
                    }
                }
            }
        }

        /// <summary>
        /// 执行多条SQL语句，实现数据库事务。
        /// </summary>
        /// <param name="SQLStringList">多条SQL语句</param>		
        public static void ExecuteSqlTran(ArrayList SQLStringList)
        {
            using (OleDbConnection conn = new OleDbConnection(connectionString))
            {
                conn.Open();
                OleDbCommand cmd = new OleDbCommand();
                cmd.Connection = conn;
                OleDbTransaction tx = conn.BeginTransaction();
                cmd.Transaction = tx;
                try
                {
                    for (int n = 0; n < SQLStringList.Count; n++)
                    {
                        string strsql = SQLStringList[n].ToString();
                        if (strsql.Trim().Length > 1)
                        {
                            cmd.CommandText = strsql;
                            cmd.ExecuteNonQuery();
                        }
                    }
                    tx.Commit();
                }
                catch (System.Data.OleDb.OleDbException E)
                {
                    tx.Rollback();
                    throw new Exception(E.Message);
                }
            }
        }
        /// <summary>
        /// 执行带一个存储过程参数的的SQL语句。
        /// </summary>
        /// <param name="SQLString">SQL语句</param>
        /// <param name="content">参数内容,比如一个字段是格式复杂的文章，有特殊符号，可以通过这个方式添加</param>
        /// <returns>影响的记录数</returns>
        public static int ExecuteSql(string SQLString, string content)
        {
            using (OleDbConnection connection = new OleDbConnection(connectionString))
            {
                OleDbCommand cmd = new OleDbCommand(SQLString, connection);
                System.Data.OleDb.OleDbParameter myParameter = new System.Data.OleDb.OleDbParameter("@content", OleDbType.VarChar);
                myParameter.Value = content;
                cmd.Parameters.Add(myParameter);
                try
                {
                    connection.Open();
                    int rows = cmd.ExecuteNonQuery();
                    return rows;
                }
                catch (System.Data.OleDb.OleDbException E)
                {
                    throw new Exception(E.Message);
                }
                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 (OleDbConnection connection = new OleDbConnection(connectionString))
            {
                OleDbCommand cmd = new OleDbCommand(strSQL, connection);
                System.Data.OleDb.OleDbParameter myParameter = new System.Data.OleDb.OleDbParameter("@fs", OleDbType.Binary);
                myParameter.Value = fs;
                cmd.Parameters.Add(myParameter);
                try
                {
                    connection.Open();
                    int rows = cmd.ExecuteNonQuery();
                    return rows;
                }
                catch (System.Data.OleDb.OleDbException E)
                {
                    throw new Exception(E.Message);
                }
                finally
                {
                    cmd.Dispose();
                    connection.Close();
                }
            }
        }

        /// <summary>
        /// 执行一条计算查询结果语句，返回查询结果（object）。
        /// </summary>
        /// <param name="SQLString">计算查询结果语句</param>
        /// <returns>查询结果（object）</returns>
        public static object GetSingle(string SQLString)
        {
            using (OleDbConnection connection = new OleDbConnection(connectionString))
            {
                using (OleDbCommand cmd = new OleDbCommand(SQLString, connection))
                {
                    try
                    {
                        connection.Open();
                        object obj = cmd.ExecuteScalar();
                        if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
                        {
                            return null;
                        }
                        else
                        {
                            return obj;
                        }
                    }
                    catch (System.Data.OleDb.OleDbException e)
                    {
                        connection.Close();
                        throw new Exception(e.Message);
                    }
                }
            }
        }
        /// <summary>
        /// 执行查询语句，返回OleDbDataReader
        /// </summary>
        /// <param name="strSQL">查询语句</param>
        /// <returns>OleDbDataReader</returns>
        public static OleDbDataReader ExecuteReader(string strSQL)
        {
            OleDbConnection connection = new OleDbConnection(connectionString);
            OleDbCommand cmd = new OleDbCommand(strSQL, connection);
            try
            {
                connection.Open();
                OleDbDataReader myReader = cmd.ExecuteReader();
                return myReader;
            }
            catch (System.Data.OleDb.OleDbException e)
            {
                throw new Exception(e.Message);
            }

        }
        /// <summary>
        /// 执行查询语句，返回DataSet
        /// </summary>
        /// <param name="SQLString">查询语句</param>
        /// <returns>DataSet</returns>
        public static DataSet Query(string SQLString)
        {
            using (OleDbConnection connection = new OleDbConnection(connectionString))
            {
                DataSet ds = new DataSet();
                try
                {
                    connection.Open();
                    OleDbDataAdapter command = new OleDbDataAdapter(SQLString, connection);
                    command.Fill(ds, "ds");
                }
                catch (System.Data.OleDb.OleDbException ex)
                {
                    throw new Exception(ex.Message);
                }
                return ds;
            }
        }


        #endregion

        #region 执行带参数的SQL语句

        /// <summary>
        /// 执行SQL语句，返回影响的记录数
        /// </summary>
        /// <param name="SQLString">SQL语句</param>
        /// <returns>影响的记录数</returns>
        public static int ExecuteSql(string SQLString, params OleDbParameter[] cmdParms)
        {
            using (OleDbConnection connection = new OleDbConnection(connectionString))
            {
                using (OleDbCommand cmd = new OleDbCommand())
                {
                    try
                    {
                        PrepareCommand(cmd, connection, null, SQLString, cmdParms);
                        int rows = cmd.ExecuteNonQuery();
                        cmd.Parameters.Clear();
                        return rows;
                    }
                    catch (System.Data.OleDb.OleDbException E)
                    {
                        throw new Exception(E.Message);
                    }
                }
            }
        }

        
        /// <summary>
        /// 执行多条SQL语句，实现数据库事务。
        /// </summary>
        /// <param name="SQLStringList">SQL语句的哈希表（key为sql语句，value是该语句的OleDbParameter[]）</param>
        public static void ExecuteSqlTran(Hashtable SQLStringList)
        {
            using (OleDbConnection conn = new OleDbConnection(connectionString))
            {
                conn.Open();
                using (OleDbTransaction trans = conn.BeginTransaction())
                {
                    OleDbCommand cmd = new OleDbCommand();
                    try
                    {
                        //循环
                        foreach (DictionaryEntry myDE in SQLStringList)
                        {
                            string cmdText = myDE.Key.ToString();
                            OleDbParameter[] cmdParms = (OleDbParameter[])myDE.Value;
                            PrepareCommand(cmd, conn, trans, cmdText, cmdParms);
                            int val = cmd.ExecuteNonQuery();
                            cmd.Parameters.Clear();

                            trans.Commit();
                        }
                    }
                    catch
                    {
                        trans.Rollback();
                        throw;
                    }
                }
            }
        }


        /// <summary>
        /// 执行一条计算查询结果语句，返回查询结果（object）。
        /// </summary>
        /// <param name="SQLString">计算查询结果语句</param>
        /// <returns>查询结果（object）</returns>
        public static object GetSingle(string SQLString, params OleDbParameter[] cmdParms)
        {
            using (OleDbConnection connection = new OleDbConnection(connectionString))
            {
                using (OleDbCommand cmd = new OleDbCommand())
                {
                    try
                    {
                        PrepareCommand(cmd, connection, null, SQLString, cmdParms);
                        object obj = cmd.ExecuteScalar();
                        cmd.Parameters.Clear();
                        if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
                        {
                            return null;
                        }
                        else
                        {
                            return obj;
                        }
                    }
                    catch (System.Data.OleDb.OleDbException e)
                    {
                        throw new Exception(e.Message);
                    }
                }
            }
        }

        /// <summary>
        /// 执行查询语句，返回OleDbDataReader
        /// </summary>
        /// <param name="strSQL">查询语句</param>
        /// <returns>OleDbDataReader</returns>
        public static OleDbDataReader ExecuteReader(string SQLString, params OleDbParameter[] cmdParms)
        {
            OleDbConnection connection = new OleDbConnection(connectionString);
            OleDbCommand cmd = new OleDbCommand();
            try
            {
                PrepareCommand(cmd, connection, null, SQLString, cmdParms);
                OleDbDataReader myReader = cmd.ExecuteReader();
                cmd.Parameters.Clear();
                return myReader;
            }
            catch (System.Data.OleDb.OleDbException e)
            {
                throw new Exception(e.Message);
            }

        }

        /// <summary>
        /// 执行查询语句，返回DataSet
        /// </summary>
        /// <param name="SQLString">查询语句</param>
        /// <returns>DataSet</returns>
        public static DataSet Query(string SQLString, params OleDbParameter[] cmdParms)
        {
            using (OleDbConnection connection = new OleDbConnection(connectionString))
            {
                OleDbCommand cmd = new OleDbCommand();
                PrepareCommand(cmd, connection, null, SQLString, cmdParms);
                using (OleDbDataAdapter da = new OleDbDataAdapter(cmd))
                {
                    DataSet ds = new DataSet();
                    try
                    {
                        da.Fill(ds, "ds");
                        cmd.Parameters.Clear();
                    }
                    catch (System.Data.OleDb.OleDbException ex)
                    {
                        throw new Exception(ex.Message);
                    }
                    return ds;
                }
            }
        }


        private static void PrepareCommand(OleDbCommand cmd, OleDbConnection conn, OleDbTransaction trans, string cmdText, OleDbParameter[] 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 (OleDbParameter parm in cmdParms)
                    cmd.Parameters.Add(parm);
            }
        }

        #endregion

    

    }
}
Access 配置文件 

<?xml version=" 1.0" encoding=" utf-8"?>
<configuration>
  <appSettings>
    <!-- 连接字符串是否加密 -->
    < add key ="ConStringEncrypt " value ="false " />
    <!-- 数据库连接字符串,（如果采用加密方式，上面一项要设置为true；加密工具，可在官方下载，
     如果使用明文这样server=127.0.0.1;database=.....,上面则设置为false。 -->
    < add key ="ConnectionString " value ="server=127.0.0.1;database=codematic;uid=sa;pwd=1 " />
    <!-- 其它模块连接字符串，可以不断增加以便同一个项目支持连接多个数据库。如果没有，可以删除该行 -->
    < add key ="ConnectionString2 " value ="server=127.0.0.1;database=codematic2;uid=sa;pwd=1 " />
    < add key ="ClientSettingsProvider.ServiceUri " value ="" />
  </appSettings>
  <connectionStrings>
    < add name ="ConnectionString " connectionString ="Provider=Microsoft.Jet.OLEDB.4.0;Data Source=|DataDirectory|\Data\MyAccount.mdb;Jet OLEDB:Database Password=a5332577;" providerName=" System.Data.OleDb" />
    <!-- <add name="ConnectionString"
          connectionString="Provider=Microsoft.Jet.OLEDB.4.0;Data Source=|DataDirectory|\Data\MyAccount.mdb;Persist Security Info=True"
          providerName="System.Data.OleDb" /> -->
  </connectionStrings>
  <system.web>
    < membership defaultProvider ="ClientAuthenticationMembershipProvider ">
      < providers>
        < add name ="ClientAuthenticationMembershipProvider " type=" System.Web.ClientServices.Providers.ClientFormsAuthenticationMembershipProvider, System.Web.Extensions, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" serviceUri="" />
      </ providers>
    </ membership>
    < roleManager defaultProvider ="ClientRoleProvider " enabled ="true ">
      < providers>
        < add name ="ClientRoleProvider " type ="System.Web.ClientServices.Providers.ClientRoleProvider, System.Web.Extensions, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" serviceUri="" cacheTimeout= "86400" />
      </ providers>
    </ roleManager>
  </system.web>
</configuration>

Windows(64位IIS)未在本地计算机上注册“Microsoft.Jet.OLEDB.4.0”提供程序 
在Windows 7(32位)用.Net开发的Excel导入数据表功能，测试后一切正常，站点发布挪到Windows Server 2008(64位)上就意外了，出现错误提示，运行程序，抛出异常：未在本地计算机上注册 Microsoft.Jet.OLEDB.4.0 提供程序，搞了老半天，不知道什么原因，后来搜过了一下，才发现解决问题的办法是如此简单：
解决方法之一：

编译项目指定目标平台为x86就完了，不能用any cpu

生成->配置管理器->平台->点击Any Cpu选项卡->新建->新建平台->X86

解决方法之二：

在对应的 IIS 应用程序池中，“设置应用程序池默认属性”/“常规”/”启用32位应用程序”，设置为 true。

Access实例下载





涂文远
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Access基础教程--第八章 使用VBA编程
孤夜寒心泪学习随笔
03-12 2万+
 本章内容 ◆ VBA编程基础◆ 创建和设计VBA程序◆ VBA程序调试与运行  一、VBA编程基础知识     在执行简单的操作时，宏可以完成，如窗体的打开与关闭、工具栏的显示和隐藏等。对于稍复杂一些的任务，则可用Visual Basic for Application进行编程完成。 1．VBA的数据类型 下面对VBA中的数据类型、数据类型
Access_VBA编程(使用技巧大全)
10-03
Access_VBA编程(使用技巧大全)
新手菜鸟学习VBA—用宏录制的简单VBA小程序：加粗斜体并居中
killspeeder的博客
05-03 1495
程序目的：我们分别录制“文本居中”、“文本加粗”、“文本斜体”三个宏，然后经过加工形成了一个居中加粗并斜体的VBA小程序。程序如下： Sub 文字居中并加粗斜体()'' 文字居中并加粗斜体 宏'' 快捷键: Ctrl+Shift+K'   Selection.NumberFormatLocal = "0_ "   Selection.Font.Bold = True   Selection.Fon...
Excel中VBA编程学习笔记（十六）--Access数据库更新操作
数据之道
11-26 6858
【例1】使用Connection的Execute的方法 数据库格式:   Sub test()     Dim conString$, sqlString$     Dim cnn, rst         Set cnn = CreateObject("ADODB.Connection")     Set rst = CreateObject("ADODB.Recordset...
asp.net：webconfig简单数据库配置
qq_28585545的博客
06-12 389
一、     后台获取代码：  string _connectionString = ConfigurationManager.AppSettings["ConnectionString"];  二、                  数据库配置        字符串获取：     private static readonly string co
accesss数据库 注入
安全界的彭于晏的博客
06-27 93
Access数据库及注入方法 Access数据库的函数 select len("string") 查询给定字符串的长度 select asc("a") 查询给定字符串的ascii值 top n 查询前n条记录 select mid("string",2,1) 查询给定字符串从指定索引开始的长度 盲注Access数据库 Access没有数据库的概念，所有的表都是在同一个数据库下。所以，我们不用去判断当前的数据库
组态王曲线控件读取access_组态王连接Accesss大数据库与历史曲线显示
weixin_39778218的博客
12-22 555
大全我是依据组态王帮助文件里面的案例，不过我写的会更详细！以某工业现场应用为例，需要对原料进行称量，并记录原料的生产厂家、原料编号、称量日期、称量时间，值班人员、原料重量。针对这种关系数据，使用组态王的历史库是无法记录的，因此我们使用关系数据库Access进行记录。下面就以此为例来演示完成这一现场需求的设置步骤。操作步骤：1、新建数据库以及表：1.1)在Access中新建一个空数据库，例如建立路径...
docker private repository accesss
fan_ping的博客
08-02 193
docker
第一周Accesss课总结
weixin_30814319的博客
03-16 76
1。这节课学到了什么知识？ 数据库是存放数据的仓库，是长期存放在计算机内，有组织的、大量的、可共享的数据集合。数据库技术是应数据管理任务的需要而产生的，随着计算机软件硬件的发展，计算机数据管理技术经历了人工管理、文件系统、数据库系统等几个阶段。数据模型是数据库的基础，任何数据库管理系统都是基于某种数据模型的。模型又分为：概念模型和结构模型。关系模型是目前最常见的一种数据模型，而关系数据库就是...
asp+accesss 网上书店
09-16
在这个"asp+accesss 网上书店"项目中，ASP技术被用来构建网站的后端逻辑，处理用户请求，如浏览书籍、搜索、购物车操作以及订单处理等。 Access是微软出品的一款关系型数据库管理系统（RDBMS），它使用Structured ...
E090-数据库安全-accesss数据库改名.pdf
12-02
【数据库安全】与【Access数据库改名】是本课程的核心知识点。Access数据库是Microsoft Office套件中的一个组件，常用于创建小型数据管理应用。...本课程通过实际操作展示了如何保护Access数据库免受潜在攻击。...
wincc.rar_WinCC_steel_wincc accesss_wincc 数据库_钢铁
09-24
"wincc_accesss"标签暗示了WinCC可能利用Access数据库进行数据管理，Access以其易于使用和灵活的数据处理能力，成为许多中小型企业首选的数据库解决方案。 数据库接口在WinCC中的实现，通常通过OPC（OLE for ...
学生信息管理系统accesss
12-26
学生信息管理系统基于accesss系统针对高中学校的教务管理，分为两个模块，学生信息模块，教师管理模块；各模块功能如下： 学生模块：可以查看自己最近的考试成绩以及班级里的成绩情况，查看自己历史成绩查询，查看...
delphi-Access.zip_Delphi Database_accesss_delphi
09-14
在本文中，我们将深入探讨如何使用Delphi编程语言与Microsoft Access数据库进行交互。"delphi-Access.zip" 文件提供了一个Delphi操作Access数据库的简单示例，这将帮助开发者了解如何利用Delphi强大的数据库功能来...
Accesss数据库的那点事
简单点的博客
05-09 1402
Accesss数据库的那点事
C# 读写文件(StreamRead,StreamWrite,File,FileStream)
热门推荐
涂文远的博客
01-07 1万+
（StreamRead，StreamWrite，File，FileStream他们读写文件操作）、Stream 和 文件之间的转换、FileStream文件流及使用文件流来实现多媒体文件的复制示例
在一个ACCESSS文件中使用python实现查询功能
最新发布
09-24
### 回答1： 在 Python 中使用 ACCESS 文件的一种方法是使用 pyodbc 模块连接到 ACCESS 数据库，然后使用 SQL 语句执行查询。 首先，你需要安装 pyodbc 模块。在命令行中输入： ``` pip install pyodbc ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值