C# 为什么在尝试使用Datatable更新Access数据库文件（.mdb）时出现此错误：

我已经为我的问题工作了30个小时。每次我修正一件事，就会出现一个新的错误。我所要做的就是从内存中获取一个DataTables并简单地更新一个Access.MDB文件。这是我的密码：

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

namespace LCR_ShepherdStaffupdater_1._0
{
    public class DatabaseHandling
    {
        static DataTable datatableB = new DataTable();
        static DataTable datatableA = new DataTable();
        public static DataSet datasetA = new DataSet();
        public static DataSet datasetB = new DataSet();
        static OleDbDataAdapter adapterA = new OleDbDataAdapter();
        static OleDbDataAdapter adapterB = new OleDbDataAdapter();
        static string connectionstringA = "Provider=Microsoft.Jet.OLEDB.4.0;" + "Data Source=" + Settings.getfilelocationA();
        static string connectionstringB = "Provider=Microsoft.Jet.OLEDB.4.0;" + "Data Source=" + Settings.getfilelocationB();
        static OleDbConnection dataconnectionB = new OleDbConnection(connectionstringB);
        static OleDbConnection dataconnectionA = new OleDbConnection(connectionstringA);
        static DataTable tableListA;
        static DataTable tableListB;

        static public void addTableA(string table, bool addtoDataSet)
        {
            dataconnectionA.Open();
            datatableA = new DataTable(table);
            try
            {
                OleDbCommand commandselectA = new OleDbCommand("SELECT * FROM [" + table + "]", dataconnectionA);
                adapterA.SelectCommand = commandselectA;
                adapterA.Fill(datatableA);
            }
            catch
            {
                Logging.updateLog("Error: Tried to get " + table + " from DataSetA. Table doesn't exist!", true, false, false);
            }

            if (addtoDataSet == true)
            {
                datasetA.Tables.Add(datatableA);
                Logging.updateLog("Added DataTableA: " + datatableA.TableName.ToString() + " Successfully!", false, false, false);
            }

            dataconnectionA.Close();
        }

        static public void addTableB(string table, bool addtoDataSet)
        {
            dataconnectionB.Open();
            datatableB = new DataTable(table);

            try
            {
                OleDbCommand commandselectB = new OleDbCommand("SELECT * FROM [" + table + "]", dataconnectionB);
                adapterB.SelectCommand = commandselectB;
                adapterB.Fill(datatableB);
            }
            catch
            {
                Logging.updateLog("Error: Tried to get " + table + " from DataSetB. Table doesn't exist!", true, false, false);
            }



            if (addtoDataSet == true)
            {
                datasetB.Tables.Add(datatableB);
                Logging.updateLog("Added DataTableB: " + datatableB.TableName.ToString() + " Successfully!", false, false, false);
            }

            dataconnectionB.Close();
        }

        static public string[] getTablesA(string connectionString)
        {
            dataconnectionA.Open();
            tableListA = dataconnectionA.GetOleDbSchemaTable(OleDbSchemaGuid.Tables, new Object[] { null, null, null, "TABLE" });
            string[] stringTableListA = new string[tableListA.Rows.Count];

            for (int i = 0; i < tableListA.Rows.Count; i++)
            {
                stringTableListA[i] = tableListA.Rows[i].ItemArray[2].ToString();
            }
            dataconnectionA.Close();
            return stringTableListA;
        }

        static public string[] getTablesB(string connectionString)
        {
            dataconnectionB.Open();
            tableListB = dataconnectionB.GetOleDbSchemaTable(OleDbSchemaGuid.Tables, new Object[] { null, null, null, "TABLE" });
            string[] stringTableListB = new string[tableListB.Rows.Count];

            for (int i = 0; i < tableListB.Rows.Count; i++)
            {
                stringTableListB[i] = tableListB.Rows[i].ItemArray[2].ToString();
            }
            dataconnectionB.Close();
            return stringTableListB;
        }

        static public void createDataSet()
        {

            string[] tempA = getTablesA(connectionstringA);
            string[] tempB = getTablesB(connectionstringB);
            int percentage = 0;
            int maximum = (tempA.Length + tempB.Length);

            Logging.updateNotice("Loading Tables...");
            Logging.updateLog("Started Loading File A", false, false, true);
            for (int i = 0; i < tempA.Length ; i++)
            {
                if (!datasetA.Tables.Contains(tempA[i]))
                {
                    addTableA(tempA[i], true);
                    percentage++;
                    Logging.loadStatus(percentage, maximum);
                }
                else
                {
                    datasetA.Tables.Remove(tempA[i]);
                    addTableA(tempA[i], true);
                    percentage++;
                    Logging.loadStatus(percentage, maximum);
                }
            }
            Logging.updateLog("Finished loading File A", false, false, true);
            Logging.updateLog("Started loading File B", false, false, true);
            for (int i = 0; i < tempB.Length ; i++)
            {
                if (!datasetB.Tables.Contains(tempB[i]))
                {
                    addTableB(tempB[i], true);
                    percentage++;
                    Logging.loadStatus(percentage, maximum);
                }
                else
                {
                    datasetB.Tables.Remove(tempB[i]);
                    addTableB(tempB[i], true);
                    percentage++;
                    Logging.loadStatus(percentage, maximum);
                }
            }
            Logging.updateLog("Finished loading File B", false, false, true);
            Logging.updateLog("Both files loaded into memory successfully", false, true, false);


        }

        static public DataTable getDataTableA()
        {
            datatableA = datasetA.Tables[Settings.textA];

            return datatableA;
        }
        static public DataTable getDataTableB()
        {
            datatableB = datasetB.Tables[Settings.textB];
            return datatableB;
        }

        static public DataSet getDataSetA()
        {
            return datasetA;
        }

        static public DataSet getDataSetB()
        {
            return datasetB;
        }

        static public void InitiateCopyProcessA()
        {
            DataSet tablesA;
            tablesA = DatabaseHandling.getDataSetA();

                foreach (DataTable table in tablesA.Tables)
                {
                    OverwriteTable(table, table.TableName);
                    Logging.updateLog("Copied " + table.TableName + " successfully.", false, true, false);
                }

        }

        static void OverwriteTable(DataTable sourceTable, string tableName)
        {
            using (var destConn = new OleDbConnection(connectionstringA))
            using (var destCmd = new OleDbCommand(tableName, destConn) { CommandType = CommandType.TableDirect })
            using (var destDA = new OleDbDataAdapter(destCmd))
            {
                // Since we're using a single table, we can have the CommandBuilder
                // generate the appropriate INSERT and DELETE SQL statements
                using (var destCmdB = new OleDbCommandBuilder(destDA))
                {
                    destCmdB.QuotePrefix = "["; // quote reserved column names
                    destCmdB.QuoteSuffix = "]";
                    destDA.DeleteCommand = destCmdB.GetDeleteCommand();
                    destDA.InsertCommand = destCmdB.GetInsertCommand();

                    // Get rows from destination, and delete them
                    var destTable = new DataTable();
                    destDA.Fill(destTable);
                    foreach (DataRow dr in destTable.Rows)
                    {
                        dr.Delete();
                    }

                     destDA.Update(destTable); // !!! Run-time error: Syntax error in FROM clause. !!!

                    // Set rows from source as Added, so the DataAdapter will insert them
                    foreach (DataRow dr in sourceTable.Rows)
                    {
                        dr.SetAdded();
                    }
                    destDA.Update(sourceTable);
                }
            }
        }



        }          
    }

使用系统；
使用System.Collections.Generic；
使用系统数据；
使用System.Data.OleDb；
使用System.IO；
使用System.Linq；
使用系统文本；
命名空间LCR_ShepherdStaffupdater_1._0
{
公共类数据库处理
{
静态DataTable datatableB=新DataTable（）；
静态DataTable datatableA=新DataTable（）；
公共静态数据集datasetA=新数据集（）；
公共静态数据集datasetB=新数据集（）；
静态OleDbDataAdapter adapter=新OleDbDataAdapter（）；
静态OleDbDataAdapter适配器B=新OleDbDataAdapter（）；
静态字符串连接stringga=“Provider=Microsoft.Jet.OLEDB.4.0；”“+”数据源=“+Settings.getfilelocationA（）；
静态字符串连接stringb=“Provider=Microsoft.Jet.OLEDB.4.0；”“+”数据源=“+Settings.getfilelocationB（）；
静态OLEDB连接dataconnectionB=新的OLEDB连接（connectionstringB）；
静态OLEDB连接dataconnectionA=新OLEDB连接（connectionstringA）；
静态数据表tableListA；
静态数据表tableListB；
静态公共void addTableA（字符串表，bool addtoDataSet）
{
dataconnectionA.Open（）；
datatableA=新的DataTable（表）；
尝试
{
OleDbCommand commandselectA=新的OleDbCommand（“从[“+表+”]”中选择*，数据连接A）；
adapterA.SelectCommand=commandselectA；
adapterA.Fill（数据表a）；
}
抓住
{
Logging.updateLog（“错误：试图从DataSetA获取“+table+”。table不存在！”，true、false、false）；
}
if（addtoDataSet==true）
{
datasetA.Tables.Add（datatableA）；
Logging.updateLog（“添加的DataTableA:+DataTableA.TableName.ToString（）+”成功！”，false，false，false）；
}
dataconnectionA.Close（）；
}
静态公共void addTableB（字符串表，bool addtoDataSet）
{
dataconnectionB.Open（）；
datatableB=新的DataTable（表格）；
尝试
{
OleDbCommand commandselectB=新的OleDbCommand（“从[“+表格+”]”中选择*，数据连接B）；
adapterB.SelectCommand=commandselectB；
适配器B.填充（数据表B）；
}
抓住
{
Logging.updateLog（“错误：试图从DataSetB.table不存在中获取“+table+”），true、false、false）；
}
if（addtoDataSet==true）
{
datasetB.Tables.Add（datatableB）；
Logging.updateLog（“添加的DataTableB:+DataTableB.TableName.ToString（）+”成功！”，false，false，false）；
}
dataconnectionB.Close（）；
}
静态公共字符串[]getTablesA（字符串连接字符串）
{
dataconnectionA.Open（）；
tableListA=dataconnectionA.GetOleDbSchemaTable（OleDbSchemaGuid.Tables，新对象[]{null，null，null，“TABLE”}）；
string[]stringTableListA=新字符串[tableListA.Rows.Count]；
for（int i=0；idestCmdB.QuotePrefix = "["; // quote reserved column names
destCmdB.QuotePrefix = "]";

destCmdB.QuotePrefix = "["; // quote reserved column names
destCmdB.QuoteSuffix = "]";