using System;
using System.Collections;
using System.Collections.Generic;
using System.Configuration;
using System.Data;
using System.Threading;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Threading;
using Transmission.SDK.ThreadPool;

namespace CoopMerchantClient
{
    /// <summary>
    /// MainWindow.xaml 的交互逻辑
    /// </summary>
    public partial class MainWindow : Window
    {
        protected string TimerInterval = ConfigurationManager.AppSettings["Interval"];

        /// <summary>
        /// 移动业务数据传输线程
        /// </summary>
        ClientThread MSPClientThread = new ClientThread();

        /// <summary>
        /// 移动业务数据传输配置
        /// </summary>
        ConfigThread MSPConfigThread = null;

        /// <summary>
        /// 普通业务数据传输线程
        /// </summary>
        ClientThread HWSClientThread = new ClientThread();

        /// <summary>
        /// 普通业务数据传输配置
        /// </summary>
        ConfigThread HWSConfigThread = null;

        /// <summary>
        /// 基础业务数据传输线程
        /// </summary>
        ClientThread PFFWClientThread = new ClientThread();

        /// <summary>
        /// 基础业务数据传输配置
        /// </summary>
        ConfigThread PFFWConfigThread = null;

        /// <summary>
        /// 交易业务数据传输线程
        /// </summary>
        ClientThread HWSDClientThread = new ClientThread();

        /// <summary>
        /// 交易业务数据传输配置
        /// </summary>
        ConfigThread HWSDConfigThread = null;

        /// <summary>
        /// 数据版本反馈传输线程
        /// </summary>
        ClientThread CMFBClientThread = new ClientThread();

        /// <summary>
        /// 数据版本反馈传输配置
        /// </summary>
        ConfigThread CMFBConfigThread = null;

        /// <summary>
        /// 传输客户端定时器
        /// </summary>
        DispatcherTimer CilentTimer = new DispatcherTimer();

        /// <summary>
        /// HIGHWAY_STORAGE数据库连接类
        /// </summary>
        Transmission.SDK.OracleHelper HWSOracle;

        /// <summary>
        /// HIGHWAY_SELLDATA数据库连接类
        /// </summary>
        Transmission.SDK.OracleHelper HWSDOracle;

        /// <summary>
        /// PLATFORM_FRAMEWORK数据库连接类
        /// </summary>
        Transmission.SDK.OracleHelper PFFWOracle;

        /// <summary>
        /// HIGHWAY_EXCHANGE数据库连接类
        /// </summary>
        Transmission.SDK.OracleHelper HWEXOracle;

        /// <summary>
        /// 运行状态上报时间
        /// </summary>
        DateTime StateUploadTime;

        /// <summary>
        /// 运行状态上报线程
        /// </summary>
        Thread StateUploadThread;

        /// <summary>
        /// 运行日志记录
        /// </summary>
        DataTable TransResultTable;

        /// <summary>
        /// 省份信息缓存表
        /// </summary>
        DataTable ProvinceTable;

        /// <summary>
        /// 省份信息缓存有效期
        /// </summary>
        DateTime ProvinceCacheTime;

        /// <summary>
        /// 是否首次执行
        /// </summary>
        bool IsFirstRun = true;


        public MainWindow()
        {
            InitializeComponent();
            //绑定上传回调事件
            MSPClientThread.UploadStringEvent += new ClientThread.OutputResultsUploadArg(ClientThread_UploadStringEvent);
            HWSClientThread.UploadStringEvent += new ClientThread.OutputResultsUploadArg(ClientThread_UploadStringEvent);
            HWSDClientThread.UploadStringEvent += new ClientThread.OutputResultsUploadArg(ClientThread_UploadStringEvent);
            PFFWClientThread.UploadStringEvent += new ClientThread.OutputResultsUploadArg(ClientThread_UploadStringEvent);
            CMFBClientThread.UploadStringEvent += new ClientThread.OutputResultsUploadArg(ClientThread_UploadStringEvent);
            CilentTimer.Tick += CilentTimer_Tick;
            double timeInterval = 0;
            try
            {
                if (!double.TryParse(TimerInterval, out timeInterval) || timeInterval < 1 || timeInterval > 10)
                {
                    timeInterval = 5;
                }
            }
            catch
            {
                timeInterval = 5;
            }
            timeInterval = timeInterval * 60 * 1000;
            CilentTimer.Interval = TimeSpan.FromMilliseconds(timeInterval);
            CilentTimer.Start();
            BtnTimerState.Content = "停止";
            Title = "省份数据传输工具  CMCv" + System.Windows.Forms.Application.ProductVersion;
            int _FileCount = 0;
            string[] _masks = { ".log" };
            try
            {
                Transmission.SDK.LogHelper.DeleteFiles(
                    AppDomain.CurrentDomain.BaseDirectory + "\\log",
                    new string[] { ".log" }, false, false, ref _FileCount);
            }
            catch { }

        }

        #region 事件 -> 主窗体按钮事件
        /// <summary>
        /// 主窗体按钮事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void Button_Click(object sender, RoutedEventArgs e)
        {
            Button _Button = (Button)sender;
            switch (_Button.Name)
            {
                case "BtnTimerState":
                    if (CilentTimer != null)
                    {
                        if (CilentTimer.IsEnabled)
                        {
                            CilentTimer.Stop();
                            _Button.Content = "启动";
                            TransResultBeginInvoke(DateTime.Now, "数据传输定时器已停止");
                        }
                        else
                        {
                            CilentTimer.Start();
                            _Button.Content = "停止";
                            TransResultBeginInvoke(DateTime.Now, "数据传输定时器已启动");
                        }
                    }
                    else
                    {
                        TransResultBeginInvoke(DateTime.Now, "数据传输定时器初始化失败，请重启程序！");
                    }
                    break;
                case "BtnClosed":
                    if (CilentTimer != null && CilentTimer.IsEnabled)
                    {
                        CilentTimer.Stop();
                    }
                    Close();
                    break;
            }
        }
        #endregion

        #region 事件 -> 主线程定时器
        /// <summary>
        /// 主线程定时器
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void CilentTimer_Tick(object sender, EventArgs e)
        {
            try
            {
                if (HWSOracle == null || !HWSOracle.ConnTest())
                {
                    string _HWSConnString = ConfigurationManager.AppSettings["HIGHWAY_STORAGE"];
                    HWSOracle = new Transmission.SDK.OracleHelper(_HWSConnString.Split(',')[0], _HWSConnString.Split(',')[4],
                        _HWSConnString.Split(',')[1], _HWSConnString.Split(',')[2], _HWSConnString.Split(',')[3]);
                }
                if (HWSDOracle == null || !HWSDOracle.ConnTest())
                {
                    string _HWSDConnString = ConfigurationManager.AppSettings["HIGHWAY_SELLDATA"];
                    HWSDOracle = new Transmission.SDK.OracleHelper(_HWSDConnString.Split(',')[0], _HWSDConnString.Split(',')[4],
                        _HWSDConnString.Split(',')[1], _HWSDConnString.Split(',')[2], _HWSDConnString.Split(',')[3]);
                }
                if (PFFWOracle == null || !PFFWOracle.ConnTest())
                {
                    string _PFFWConnString = ConfigurationManager.AppSettings["PLATFORM_FRAMEWORK"];
                    PFFWOracle = new Transmission.SDK.OracleHelper(_PFFWConnString.Split(',')[0], _PFFWConnString.Split(',')[4],
                        _PFFWConnString.Split(',')[1], _PFFWConnString.Split(',')[2], _PFFWConnString.Split(',')[3]);
                }
                if (HWEXOracle == null || !HWEXOracle.ConnTest())
                {
                    string _HWEXConnString = ConfigurationManager.AppSettings["HIGHWAY_EXCHANGE"];
                    HWEXOracle = new Transmission.SDK.OracleHelper(_HWEXConnString.Split(',')[0], _HWEXConnString.Split(',')[4],
                        _HWEXConnString.Split(',')[1], _HWEXConnString.Split(',')[2], _HWEXConnString.Split(',')[3]);
                }
                if (IsFirstRun)
                {
                    IsFirstRun = false;
                    Dictionary<string, string> _CheckList = new Dictionary<string, string>();
                    _CheckList.Add("HIGHWAY_STORAGE.T_SERVERPARTSHOP", "门店表添加字段");
                    CheckOracleTable(HWSOracle, _CheckList);
                }
                //运行状态上传线程
                if (StateUploadTime < DateTime.Now)
                {
                    StateUploadTime = DateTime.Now.AddMinutes(5);
                    if (StateUploadThread == null || !StateUploadThread.IsAlive)
                    {
                        StateUploadThread = new Thread(() => AppStateUpload(HWSOracle))
                        {
                            IsBackground = true
                        };
                        StateUploadThread.Start();
                    }
                }

                TransResultBeginInvoke(DateTime.Now, "正在预启动上传子线程......");
                if (HWSConfigThreadConfigure())
                {
                    if (HWSClientThread.onState(HWSOracle))
                    {
                        TransResultBeginInvoke(DateTime.Now, "普通业务数据上传线程预启动成功");
                    }
                    else
                    {
                        TransResultBeginInvoke(DateTime.Now, "普通业务数据上传线程预启动失败");
                    }
                }
                if (HWSDConfigThreadConfigure())
                {
                    if (HWSDClientThread.onState(HWSDOracle))
                    {
                        TransResultBeginInvoke(DateTime.Now, "交易业务数据上传线程预启动成功");
                    }
                    else
                    {
                        TransResultBeginInvoke(DateTime.Now, "交易业务数据上传线程预启动失败");
                    }
                }
                if (MSPConfigThreadConfigure())
                {
                    if (MSPClientThread.onState(HWSOracle))
                    {
                        TransResultBeginInvoke(DateTime.Now, "移动业务数据上传线程预启动成功");
                    }
                    else
                    {
                        TransResultBeginInvoke(DateTime.Now, "移动业务数据上传线程预启动失败");
                    }
                }
                if (PFFWConfigThreadConfigure())
                {
                    if (PFFWClientThread.onState(PFFWOracle))
                    {
                        TransResultBeginInvoke(DateTime.Now, "基础业务数据上传线程预启动成功");
                    }
                    else
                    {
                        TransResultBeginInvoke(DateTime.Now, "基础业务数据上传线程预启动失败");
                    }
                }
                if (CMFBConfigThreadConfigure())
                {
                    if (CMFBClientThread.onState(PFFWOracle))
                    {
                        TransResultBeginInvoke(DateTime.Now, "数据版本反馈上传线程预启动成功");
                    }
                    else
                    {
                        TransResultBeginInvoke(DateTime.Now, "数据版本反馈上传线程预启动失败");
                    }
                }
            }
            catch (Exception ex)
            {
                TransResultBeginInvoke(DateTime.Now, "传输启动失败：" + ex.Message);
                Transmission.SDK.LogHelper.WriteServiceLog("传输启动失败：" + ex.Message);
            }
        }
        #endregion

        #region 方法 -> 校验并更新数据库表结构
        /// <summary>
        /// 校验并更新数据库表结构
        /// </summary>
        /// <param name="localOracle"></param>
        /// <param name="checkList"></param>
        private void CheckOracleTable(Transmission.SDK.OracleHelper localOracle, Dictionary<string, string> checkList)
        {
            DataBaseUpdate _DataBaseUpdate = new DataBaseUpdate(localOracle);
            foreach (string _Key in checkList.Keys)
            {
                _DataBaseUpdate.AlterTable(_Key);
            }
        }
        #endregion

        #region 方法 -> APP运行状态上报
        /// <summary>
        /// APP运行状态上报
        /// </summary>
        /// <param name="localOracle">数据库连接类</param>
        private void AppStateUpload(Transmission.SDK.OracleHelper localOracle)
        {
            try
            {
                int _DeleteCount = localOracle.ExcuteSql("DELETE FROM HIGHWAY_STORAGE.T_OPERATELOG WHERE NVL(TRANSFER_STATE,0) = 9");
                TransResultBeginInvoke(DateTime.Now, $"无效传输日志记录清理完成：本次清理{_DeleteCount}条。");
            }
            catch (Exception ex)
            {
                TransResultBeginInvoke(DateTime.Now, $"无效传输日志记录清理失败。原因：{ex.Message}");
            }
            try
            {
                if (ProvinceTable == null || ProvinceCacheTime < DateTime.Now)
                {
                    ProvinceTable = localOracle.ExcuteSqlGetDataSet(
                        @"SELECT SERVERPARTCODE,PROVINCE_CODE,SERVERPART_NAME 
                        FROM HIGHWAY_EXCHANGE.T_SYSCODE").Tables[0];
                    if (ProvinceTable.Rows.Count == 0)
                    {
                        ProvinceCacheTime = DateTime.Now.AddMinutes(5);
                    }
                    else
                    {
                        ProvinceCacheTime = DateTime.Now.AddHours(1);
                    }
                }
                string _UploadRuningStateUrl = ConfigurationManager.AppSettings["UploadRuningStateUrl"];
                if (string.IsNullOrWhiteSpace(_UploadRuningStateUrl))
                {
                    TransResultBeginInvoke(DateTime.Now, $"APP运行状态上报失败。原因：参数[UploadRuningStateUrl]未配置。");
                    return;
                }
                foreach (DataRow ProvinceRow in ProvinceTable.Rows)
                {
                    Hashtable hashtable = new Hashtable
                    {
                        { "provinceCode", ProvinceRow["SERVERPART_CODE"].ToString() },
                        { "provinceName", ProvinceRow["SERVERPART_NAME"].ToString() },
                        { "serverPartCode", ProvinceRow["SERVERPART_CODE"].ToString() },
                        { "serverPartName", ProvinceRow["SERVERPART_NAME"].ToString() },
                        { "appName", System.Windows.Forms.Application.ProductName },
                        { "appVersion", $"CMCv{System.Windows.Forms.Application.ProductVersion}" }
                    };

                    Transmission.SDK.SoapWSHelper.QuerySoapWebServiceString(
                        $"{_UploadRuningStateUrl}/Service.asmx", "UploadTransClientState", hashtable);
                }
            }
            catch (Exception ex)
            {
                TransResultBeginInvoke(DateTime.Now, $"APP运行状态上报失败。原因：{ex.Message}");
            }
        }
        #endregion

        #region 方法 -> 基础业务数据上传配置
        /// <summary>
        /// 基础业务数据上传配置
        /// </summary>
        private bool PFFWConfigThreadConfigure()
        {
            string _MobileServicePlatformDataUrl;
            try
            {
                _MobileServicePlatformDataUrl = ConfigurationManager.AppSettings["MobileServicePlatformDataUrl"];
            }
            catch
            {
                _MobileServicePlatformDataUrl = "";
            }
            if (string.IsNullOrWhiteSpace(_MobileServicePlatformDataUrl))
            {
                TransResultBeginInvoke(DateTime.Now, $"基础业务数据上传线程启动失败。原因：参数[MobileServicePlatformDataUrl]未配置。");
                return false;
            }

            if (PFFWConfigThread == null)
            {
                PFFWConfigThread = new ConfigThread("");
            }
            PFFWClientThread.IsUpload(true, new List<string>
            {
                "T_USER",
                "T_USERTYPE"
            });
            PFFWClientThread.IsDownload(false);
            try
            {
                PFFWClientThread.setConfiguration($"{_MobileServicePlatformDataUrl}/Service.asmx", "", "888888", "", "", "", "", 50, 1);
                PFFWClientThread.setConfigThread(PFFWConfigThread);
            }
            catch (Exception ex)
            {
                TransResultBeginInvoke(DateTime.Now, "基础业务数据上传配置失败：" + ex.Message);
                Transmission.SDK.LogHelper.WriteServiceLog("基础业务数据上传配置失败：" + ex.Message);
            }
            return true;
        }
        #endregion

        #region 方法 -> 普通业务数据上传配置
        /// <summary>
        /// 普通业务数据上传配置
        /// </summary>
        private bool HWSConfigThreadConfigure()
        {
            string _HighwayStorageDataUrl;
            try
            {
                _HighwayStorageDataUrl = ConfigurationManager.AppSettings["HighwayStorageDataUrl"];
            }
            catch
            {
                _HighwayStorageDataUrl = "";
            }
            if (string.IsNullOrWhiteSpace(_HighwayStorageDataUrl))
            {
                TransResultBeginInvoke(DateTime.Now, $"普通业务数据上传线程启动失败。原因：参数[HighwayStorageDataUrl]未配置。");
                return false;
            }

            if (HWSConfigThread == null)
            {
                HWSConfigThread = new ConfigThread("");
            }
            HWSClientThread.IsUpload(true, new List<string>
            {
                "T_WECHATPUSHDETAIL",
                "T_WECHATPUSHSALES"
            });
            HWSClientThread.IsDownload(false);
            try
            {
                HWSClientThread.setConfiguration($"{_HighwayStorageDataUrl}/Service.asmx", "", "888888", "", "", "", "", 50, 1);
                HWSClientThread.setConfigThread(HWSConfigThread);
            }
            catch (Exception ex)
            {
                TransResultBeginInvoke(DateTime.Now, "普通业务数据上传配置失败：" + ex.Message);
                Transmission.SDK.LogHelper.WriteServiceLog("普通业务数据上传配置失败：" + ex.Message);
            }
            return true;
        }
        #endregion

        #region 方法 -> 交易业务数据上传配置
        /// <summary>
        /// 交易业务数据上传配置
        /// </summary>
        private bool HWSDConfigThreadConfigure()
        {
            string _HighwaySellDataUrl;
            try
            {
                _HighwaySellDataUrl = ConfigurationManager.AppSettings["HighwaySellDataUrl"];
            }
            catch
            {
                _HighwaySellDataUrl = "";
            }
            if (string.IsNullOrWhiteSpace(_HighwaySellDataUrl))
            {
                TransResultBeginInvoke(DateTime.Now, $"普通业务数据上传线程启动失败。原因：参数[HighwaySellDataUrl]未配置。");
                return false;
            }

            if (HWSDConfigThread == null)
            {
                HWSDConfigThread = new ConfigThread("");
            }
            HWSDClientThread.IsUpload(true, new List<string>
            {
                "T_DAILYMOBILEPAY"
            });
            HWSDClientThread.IsDownload(false);
            try
            {
                HWSDClientThread.setConfiguration($"{_HighwaySellDataUrl}/Service.asmx", "", "888888", "", "", "", "", 50, 1);
                HWSDClientThread.setConfigThread(HWSDConfigThread);
            }
            catch (Exception ex)
            {
                TransResultBeginInvoke(DateTime.Now, "交易业务数据上传配置失败：" + ex.Message);
                Transmission.SDK.LogHelper.WriteServiceLog("交易业务数据上传配置失败：" + ex.Message);
            }
            return true;
        }
        #endregion

        #region 方法 -> 移动业务数据上传配置
        /// <summary>
        /// 移动业务数据上传配置
        /// </summary>
        private bool MSPConfigThreadConfigure()
        {
            string _MobileServicePlatformDataUrl;
            try
            {
                _MobileServicePlatformDataUrl = ConfigurationManager.AppSettings["MobileServicePlatformDataUrl"];
            }
            catch
            {
                _MobileServicePlatformDataUrl = "";
            }
            if (string.IsNullOrWhiteSpace(_MobileServicePlatformDataUrl))
            {
                TransResultBeginInvoke(DateTime.Now, $"移动业务数据上传线程启动失败。原因：参数[MobileServicePlatformDataUrl]未配置。");
                return false;
            }

            if (MSPConfigThread == null)
            {
                MSPConfigThread = new ConfigThread("");
            }
            MSPClientThread.IsUpload(true, new List<string>
            {
                "T_SERVERPART",
                "T_SERVERPARTSHOP"
            });
            MSPClientThread.IsDownload(false);
            try
            {
                MSPClientThread.setConfiguration($"{_MobileServicePlatformDataUrl}/Service.asmx", "", "888888", "", "", "", "", 50, 1);
                MSPClientThread.setConfigThread(MSPConfigThread);
            }
            catch (Exception ex)
            {
                TransResultBeginInvoke(DateTime.Now, "移动业务数据上传配置失败：" + ex.Message);
                Transmission.SDK.LogHelper.WriteServiceLog("移动业务数据上传配置失败：" + ex.Message);
            }
            return true;
        }
        #endregion

        #region 方法 -> 数据版本反馈上传配置
        /// <summary>
        /// 数据版本反馈上传配置
        /// </summary>
        private bool CMFBConfigThreadConfigure()
        {
            string _GeneralFeedBackDataUrl;
            try
            {
                _GeneralFeedBackDataUrl = ConfigurationManager.AppSettings["GeneralFeedBackDataUrl"];
            }
            catch
            {
                _GeneralFeedBackDataUrl = "";
            }
            if (string.IsNullOrWhiteSpace(_GeneralFeedBackDataUrl))
            {
                TransResultBeginInvoke(DateTime.Now, $"数据版本反馈上传线程启动失败。原因：参数[GeneralFeedBackDataUrl]未配置。");
                return false;
            }

            if (CMFBConfigThread == null)
            {
                CMFBConfigThread = new ConfigThread("");
            }
            CMFBClientThread.IsUpload(true, new List<string>
            {
                "T_GENERALFEEDBACK"
            });
            CMFBClientThread.IsDownload(false);
            try
            {
                CMFBClientThread.setConfiguration($"{_GeneralFeedBackDataUrl}/Service.asmx", "", "888888", "", "", "", "", 50, 1);
                CMFBClientThread.setConfigThread(CMFBConfigThread);
            }
            catch (Exception ex)
            {
                TransResultBeginInvoke(DateTime.Now, "数据版本反馈上传配置失败：" + ex.Message);
                Transmission.SDK.LogHelper.WriteServiceLog("数据版本反馈上传配置失败：" + ex.Message);
            }
            return true;
        }
        #endregion

        #region 事件 -> 上传回调事件
        /// <summary>
        /// 上传回调事件
        /// </summary>
        /// <param name="uploadResultInfo"></param>
        /// <param name="resultString"></param>
        private void ClientThread_UploadStringEvent(UploadResultInfo uploadResultInfo, string resultString)
        {
            if (uploadResultInfo.StartToEnd)
            {
                TransResultBeginInvoke(DateTime.Now, resultString);
            }
            else
            {
                TransResultBeginInvoke(DateTime.Now, string.Format("上传完成：[{0}]\n　　　　　总数：{1}；成功：{2}；过滤：{3}；失败：{5}；耗时：{4}{6}",
                    uploadResultInfo.TableName, uploadResultInfo.TotalNumber, uploadResultInfo.SuccessNumber,
                    uploadResultInfo.FilterNumber, uploadResultInfo.Elapsed.TotalSeconds.ToString("F2") + "秒",
                    uploadResultInfo.TotalNumber - uploadResultInfo.SuccessNumber - uploadResultInfo.FilterNumber,
                   (string.IsNullOrWhiteSpace(uploadResultInfo.InterfaceError) ? "" : ("；\n　　　　　接口错误：" + uploadResultInfo.InterfaceError)) +
                   (string.IsNullOrWhiteSpace(uploadResultInfo.Error) ? "" : ("；\n　　　　　本地错误：" + uploadResultInfo.Error))));
                if (!string.IsNullOrWhiteSpace(uploadResultInfo.InterfaceError) || !string.IsNullOrWhiteSpace(uploadResultInfo.Error))
                {
                    Transmission.SDK.LogHelper.WriteServiceLog(string.Format("上传完成：[{0}]总数：{1}；成功：{2}；过滤：{3}；失败：{5}；耗时：{4}{6}",
                        uploadResultInfo.TableName, uploadResultInfo.TotalNumber, uploadResultInfo.SuccessNumber,
                        uploadResultInfo.FilterNumber, uploadResultInfo.Elapsed.TotalSeconds.ToString("F2") + "秒",
                        uploadResultInfo.TotalNumber - uploadResultInfo.SuccessNumber - uploadResultInfo.FilterNumber,
                       (string.IsNullOrWhiteSpace(uploadResultInfo.InterfaceError) ? "" : ("；接口错误：" + uploadResultInfo.InterfaceError)) +
                       (string.IsNullOrWhiteSpace(uploadResultInfo.Error) ? "" : ("；本地错误：" + uploadResultInfo.Error))));
                }
            }
        }
        #endregion

        #region 委托 -> 运行日志委托处理事件
        private delegate void DelegateTransResult(DateTime triggerTime, string resultMessage);
        private void TransResultBeginInvoke(DateTime triggerTime, string resultMessage)
        {
            Dispatcher.BeginInvoke(new DelegateTransResult(TransResult), new object[] { triggerTime, resultMessage });
        }

        /// <summary>
        /// 运行日志呈现
        /// </summary>
        /// <param name="triggerTime">日志时间</param>
        /// <param name="resultMessage">日志内容</param>
        private void TransResult(DateTime triggerTime, string resultMessage)
        {
            if (TransResultTable == null)
            {
                TransResultTable = ResultTable();
            }
            foreach (DataRow _RowTemp in TransResultTable.Select(string.Format("TransDate < '{0}'", DateTime.Now.AddHours(-1))))
            {
                TransResultTable.Rows.Remove(_RowTemp);
            }
            TransResultTable.AcceptChanges();
            DataRow _DataRow = TransResultTable.NewRow();
            _DataRow["TransDate"] = triggerTime;
            _DataRow["TransResult"] = resultMessage;
            TransResultTable.Rows.InsertAt(_DataRow, 0);
            DataTransResult.AutoGenerateColumns = false;
            DataTransResult.SelectionMode = DataGridSelectionMode.Single;
            DataTransResult.ItemsSource = TransResultTable.DefaultView;
        }

        /// <summary>
        /// 运行日志记录表结构
        /// </summary>
        /// <returns></returns>
        private DataTable ResultTable()
        {
            DataTable _DataTable = new DataTable();
            _DataTable.Columns.Add("TransDate", typeof(DateTime));
            _DataTable.Columns.Add("TransResult", typeof(string));
            return _DataTable;
        }
        #endregion
    }
}