using iWareCc.Cache.Entity;
using iWareCc.Conveyor.Entity;
using iWareCc.DecomposeTask.Chain;
using iWareCc.DecomposeTask.Entity;
using iWareCc.DoConveyorTaskAuto.Chain;
using iWareCc.DoStackerTaskAuto.Chain;
using iWareCc.FinishConveyorTask.Chain;
using iWareCc.FinishStackerTask.Chain;
using iWareCc.HandleTask.Chain;
using iWareCc.Properties;
using iWareCc.Srm.Entity;
using iWareCc.Srm.Strategy;
using iWareCc.WCF.ControlCenter;
using iWareCommon.Common.Entity;
using iWareCommon.Common.EnumType;
using iWareCommon.Utils;
using iWareDataCore.DEV.EnumType;
using iWareDataCore.TASK.EnumType;
using iWareLog.LOG.Service;
using iWareLog.ORM;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Diagnostics;
using System.Linq;
using System.ServiceModel;
using System.ServiceProcess;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using Castle.DynamicProxy;
using iWareDataCore.ORM;
using iWareLog.LOG.Entity;
using iWareLog.LOG.Dao;
using iWareCc.Conveyor.EnumType;
using iWareCc.Conveyor.Service;
using iWareDataCore.BASE.EnumType;
using iWareCc.CreateMainTask.chain;
using iWareCc.CreateOutMainTask.chain;
using iWareCc.Srm.EnumType;

namespace iWareCc
{
    public partial class Service1 : ServiceBase
    {

        private object DecomposeLock = new object();

        /// <summary>
        /// ControlCenterWcf服务
        /// </summary>
        private ServiceHost ControlCenterWcfHost = null;

        /// <summary>
        /// 每个堆垛机获取状态的线程
        /// </summary>
        private List<Thread> GetStackerStateThreads = new List<Thread>();

        /// <summary>
        /// 每个输送机端口获取状态的线程
        /// </summary>
        // private List<Thread> GetGateStateThreads = new List<Thread>();

        /// <summary>
        /// 每个输送机端口接收到的报文信息的线程（Client）
        /// </summary>
        // private List<Thread> ClientGetGateSocketInforThreads = new List<Thread>();

        /// <summary>
        /// 每个输送机端口发送报文信息的线程（Client）
        /// </summary>
        // private List<Thread> ClientSendGateSocketInforThreads = new List<Thread>();

        /// <summary>
        /// 处理服务端每个输送机端口接收到的报文信息的线程（server）
        /// </summary>
        private List<Thread> ServerGateHandleCraneReceivedMsgThreads = new List<Thread>();

        /// <summary>
        /// 每个输送机端口发送报文信息写入本地日志的线程
        /// </summary>
        //private List<Thread> ServerGateWriteDatagamLogThreads = new List<Thread>();

        /// <summary>
        /// 开启Socket的线程
        /// </summary>
        private List<Thread> StartSocketThreads = new List<Thread>();


        /// <summary>
        /// 生成入库主任务
        /// </summary>
        private Thread CreatMainTaskInThread = null;

        /// <summary>
        /// 生成出库主任务
        /// </summary>
        private Thread CreatMainTaskOutThread = null;

        /// <summary>
        /// 分解任务的线程
        /// </summary>
        private Thread DecomposeTaskThread = null;

        /// <summary>
        /// 处理任务的线程
        /// </summary>
        private Thread HandleTaskThread = null;

        /// <summary>
        /// 自动执行输送机任务的线程
        /// </summary>
        private List<Thread> DoConveyorTaskAutoThreads = new List<Thread>();

        /// <summary>
        /// 自动执行堆垛机任务的线程
        /// </summary>
        private List<Thread> DoStackerTaskAutoThreads = new List<Thread>();



        /// <summary>
        /// 完成输送机任务的线程
        /// </summary>
        private List<Thread> FinishConveyorTaskThreads = new List<Thread>();

        /// <summary>
        /// 完成堆垛机任务的线程
        /// </summary>
        private List<Thread> FinishStackerTaskThreads = new List<Thread>();


        /// <summary>
        /// 发送堆垛机状态的线程
        /// </summary>
        // private Thread SendStackerStatusThread = null;

        /// <summary>
        /// 发送堆垛机告警状态的线程
        /// </summary>
        private List<Thread> SendStackerAlertThreads = new List<Thread>();

        /// <summary>
        /// 发送输送机告警信息的线程
        /// </summary>
        private Thread SendConveyorAlertThread = null;

        /// <summary>
        /// 增加每个堆垛机离线次数的线程
        /// </summary>
        private List<Thread> AddStackerOffLineTimesThreads = new List<Thread>();

        /// <summary>
        /// 设定每个堆垛机是否在线的线程
        /// </summary>
        private List<Thread> SetStackerIsOnlineThreads = new List<Thread>();

        /// <summary>
        /// 同步完成次数的线程
        /// </summary>
        private Thread SyncFinishTimesThread = null;

        /// <summary>
        /// 同步处理次数的线程
        /// </summary>
        private Thread SyncHandleTimesThread = null;

        /// <summary>
        /// 同步处理次数的线程
        /// </summary>
        private Thread SyncDecompositionTimesThread = null;

        /// <summary>
        /// 定时获取心跳信息的线程
        /// </summary>
        //private Thread GetHeartBeatStateThread = null;

        /// <summary>
        /// 写入堆垛机报表的线程
        /// </summary>
        private Thread WriteStackerReportThread = null;
        /// <summary>
        /// 重推的线程
        /// </summary>
        //private Thread ReSendThread = null;


        public Service1()
        {
            InitializeComponent();
        }

        protected override void OnStart(string[] args)
        {
            LogTextHelper.WriteLine(Resources.LogDir, "外高桥iWareCc启动了！");

            ControlCenterWcfHost = new ServiceHost(typeof(ControlCenterWcfService));
            ControlCenterWcfHost.Open();

            ////开启每个输送机端口获取状态的线程
            //CacheEntity.Conveyors.ForEach(x =>
            //{
            //    x.Gates.ForEach(y =>
            //    {
            //        var thread = new Thread(new ParameterizedThreadStart(GetGateState));
            //        thread.Name = string.Format("获取输送机端口{0}的状态", y.Place.PlaceTypeName);
            //        GetGateStateThreads.Add(thread);
            //        StartThread(thread, y);
            //    });
            //});
            //#region Client
            //开启处理输送线各端口接收到的报文信息的线程
            //CacheEntity.Conveyors.ForEach(x =>
            //{
            //    x.Gates.ForEach(y =>
            //    {
            //        var thread = new Thread(new ParameterizedThreadStart(GetGateSocketInfor));
            //        thread.Name = string.Format("获取输送机端口{0}的状态", y.Place.PlaceTypeName);
            //        ClientGetGateSocketInforThreads.Add(thread);
            //        StartThread(thread, y);
            //    });
            //});
            ////开启处理输送线各端口发送的报文信息的线程
            //CacheEntity.Conveyors.ForEach(x =>
            //{
            //    x.Gates.ForEach(y =>
            //    {
            //        var thread = new Thread(new ParameterizedThreadStart(SendGateSocketInfor));
            //        thread.Name = string.Format("获取输送机端口{0}的状态", y.Place.PlaceTypeName);
            //        ClientSendGateSocketInforThreads.Add(thread);
            //        StartThread(thread, y);
            //    });
            //}); 
            //#endregion
            #region Server
            //开启处理输送线各端口接收到的报文信息的线程
            CacheEntity.Conveyors.ForEach(x =>
            {
                x.Gates.ForEach(y =>
                {
                    var thread = new Thread(new ParameterizedThreadStart(ServerHandleGateMsg));
                    thread.Name = string.Format("处理输送机端口{0}接收或发送的报文信息", y.Place.PlaceTypeName);
                    ServerGateHandleCraneReceivedMsgThreads.Add(thread);
                    StartThread(thread, y);
                });
            });
            //开启处理输送线各端口接收到的报文信息写入本地日志
            //CacheEntity.Conveyors.ForEach(x =>
            //{
            //    x.Gates.ForEach(y =>
            //    {
            //        var thread = new Thread(new ParameterizedThreadStart(ServerGateWriteDatagamLog));
            //        thread.Name = string.Format("获输送机端口{0}接收或发送的报文信息", y.Place.PlaceTypeName);
            //        ServerGateWriteDatagamLogThreads.Add(thread);
            //        StartThread(thread, y);
            //    });
            //}); 

            #endregion

            //开启打开socket的线程
            CacheEntity.Conveyors.ForEach(x =>
            {
                x.Gates.ForEach(y =>
               {
                   var thread = new Thread(new ParameterizedThreadStart(StartSocket));
                   thread.Name = string.Format("开启输送机端口{0}的通讯", y.Place.PlaceTypeName);
                   StartSocketThreads.Add(thread);
                   StartThread(thread, y);
               });
            });

            //开启每个堆垛机获取状态的线程
            CacheEntity.Stackers.ForEach(x =>
            {
                var thread = new Thread(new ParameterizedThreadStart(GetStackerState));
                thread.Name = string.Format("获取输堆垛机{0}的状态", x.Equipment.EquipName);
                GetStackerStateThreads.Add(thread);
                StartThread(thread, x);
            });


            //生成入库主任务
            CreatMainTaskInThread = new Thread(new ThreadStart(CreateMainInTask));
            CreatMainTaskInThread.Name = "生成入库主任务";
            StartThread(CreatMainTaskInThread);

            //生成出库主任务
            CreatMainTaskOutThread = new Thread(new ThreadStart(CreateMainOutTask));
            CreatMainTaskOutThread.Name = "生成出库主任务";
            StartThread(CreatMainTaskOutThread);


            //开启分解任务的线程
            DecomposeTaskThread = new Thread(new ThreadStart(DecomposeTask));
            DecomposeTaskThread.Name = "分解任务";
            StartThread(DecomposeTaskThread);


            //开启处理任务的线程
            HandleTaskThread = new Thread(new ThreadStart(HandleTask));
            HandleTaskThread.Name = "处理任务";
            StartThread(HandleTaskThread);

            //开启自动执行输送机任务的线程
            CacheEntity.Conveyors.ForEach(x =>
            {
                var thread = new Thread(new ParameterizedThreadStart(DoConveyorTaskAuto));
                thread.Name = string.Format("自动执行输送机{0}的任务", x.Equipment.EquipName);
                DoConveyorTaskAutoThreads.Add(thread);
                StartThread(thread, x);
            });


            //开启自动执行堆垛机任务的线程
            CacheEntity.Stackers.ForEach(x =>
            {
                var thread = new Thread(new ParameterizedThreadStart(DoStackerTaskAuto));
                thread.Name = string.Format("自动执行堆垛机{0}的任务", x.Equipment.EquipName);
                DoStackerTaskAutoThreads.Add(thread);
                StartThread(thread, x);
            });

            //开启完成输送机任务的线程
            CacheEntity.Conveyors.ForEach(x =>
            {
                var thread = new Thread(new ParameterizedThreadStart(FinishConveyorTask));
                thread.Name = string.Format("完成输送机{0}的任务", x.Equipment.EquipName);
                FinishConveyorTaskThreads.Add(thread);
                StartThread(thread, x);
            });

            //开启完成堆垛机任务的线程
            CacheEntity.Stackers.ForEach(x =>
            {
                var thread = new Thread(new ParameterizedThreadStart(FinishStackerTask));
                thread.Name = string.Format("完成堆垛机{0}的任务", x.Equipment.EquipName);
                FinishStackerTaskThreads.Add(thread);
                StartThread(thread, x);
            });

            //开启推送Stacker状态的线程
            //SendStackerStatusThread = new Thread(new ThreadStart(SendStackerStatus));
            //SendStackerStatusThread.Name = "发送堆垛机状态";
            //StartThread(SendStackerStatusThread);

            //开启发送Stacker告警的线程
            CacheEntity.Stackers.ForEach(x =>
            {
                var thread = new Thread(new ParameterizedThreadStart(SendStackerAlert));
                thread.Name = string.Format("发送堆垛机{0}告警", x.Equipment.EquipName);
                SendStackerAlertThreads.Add(thread);
                StartThread(thread, x);
            });

            ////开启发送输送机告警信息的线程
            SendConveyorAlertThread = new Thread(new ThreadStart(SendConveyorAlert));
            SendConveyorAlertThread.Name = "发送输送机告警信息";
            StartThread(SendConveyorAlertThread);

            //开启增加每个堆垛机离线次数的线程
            CacheEntity.Stackers.ForEach(x =>
            {
                var thread = new Thread(new ParameterizedThreadStart(AddStackerOffLineTimes));
                thread.Name = string.Format("添加堆垛机{0}离线次数", x.Equipment.EquipName);
                AddStackerOffLineTimesThreads.Add(thread);
                StartThread(thread, x);
            });


            //开启设定每个堆垛机是否在线的线程
            CacheEntity.Stackers.ForEach(x =>
            {
                var thread = new Thread(new ParameterizedThreadStart(SetStackerIsOnline));
                thread.Name = string.Format("设定堆垛机{0}是否在线", x.Equipment.EquipName);
                SetStackerIsOnlineThreads.Add(thread);
                StartThread(thread, x);
            });

            //开启同步完成次数的线程
            SyncFinishTimesThread = new Thread(new ThreadStart(SyncFinishTimes));
            SyncFinishTimesThread.Name = "同步完成次数";
            StartThread(SyncFinishTimesThread);

            //开启同步处理次数的线程
            SyncHandleTimesThread = new Thread(new ThreadStart(SyncHandleTimes));
            SyncHandleTimesThread.Name = "同步处理次数";
            StartThread(SyncHandleTimesThread);

            //开启同步处理次数的线程
            SyncDecompositionTimesThread = new Thread(new ThreadStart(SyncDecompositionTimes));
            SyncDecompositionTimesThread.Name = "同步处理次数";
            StartThread(SyncDecompositionTimesThread);

            ////开启定时获取心跳信息的线程
            //GetHeartBeatStateThread = new Thread(new ThreadStart(GetHeartBeatState));
            //GetHeartBeatStateThread.Name = "获取心跳信息";
            //StartThread(GetHeartBeatStateThread);

            //开启推送同步立库里的物料信息的线程
            //SyncMaterialInfoThread = new Thread(new ThreadStart(SyncMaterialInfo));
            //SyncMaterialInfoThread.Name = "同步立库里的物料信息";
            // StartThread(SyncMaterialInfoThread);

            //开启写入堆垛机报表的线程
            WriteStackerReportThread = new Thread(new ThreadStart(WriteStackerReport));
            WriteStackerReportThread.Name = "写入堆垛机报表信息";
            StartThread(WriteStackerReportThread);

            // 开启重推的线程
            //ReSendThread = new Thread(new ThreadStart(ReSend));
            //ReSendThread.Name = "向WIP重新推送报文";
            //StartThread(ReSendThread);


        }

        protected override void OnStop()
        {
            //关闭ControleCenter服务
            CloseWcf(ControlCenterWcfHost);

            //关闭每个堆垛机获取状态的线程
            GetStackerStateThreads.ForEach(x => CloseThread(x));

            //关闭每个输送机端口获取状态的线程
            // GetGateStateThreads.ForEach(x => CloseThread(x));

            //关闭每个输送机端口接收到的报文信息的线程
            // ClientGetGateSocketInforThreads.ForEach(x => CloseThread(x));

            //关闭每个输送机端口处理接收或发送报文信息的线程
            //ClientSendGateSocketInforThreads.ForEach(x => CloseThread(x));

            //关闭处理服务端每个输送机端口接收到的报文信息的线程
            ServerGateHandleCraneReceivedMsgThreads.ForEach(x => CloseThread(x));

            //关闭每个输送机端口接收或发送报文信息写入本地日志的线程
            //ServerGateWriteDatagamLogThreads.ForEach(x => CloseThread(x));

            //关闭每个输送机端口Socket通讯的线程
            StartSocketThreads.ForEach(x => CloseThread(x));

            //结束生成入库主任务的线程
            CloseThread(CreatMainTaskInThread);

              //结束生成出库主任务的线程
            CloseThread(CreatMainTaskOutThread);

            //关闭分解任务的线程
            CloseThread(DecomposeTaskThread);

            //关闭处理任务的线程
            CloseThread(HandleTaskThread);

            //关闭自动执行输送机任务的线程
            DoConveyorTaskAutoThreads.ForEach(x => CloseThread(x));

            //关闭自动执行堆垛机任务的线程
            DoStackerTaskAutoThreads.ForEach(x => CloseThread(x));

            //关闭自动执行输送机任务的线程
            FinishConveyorTaskThreads.ForEach(x => CloseThread(x));

            //关闭完成堆垛机任务的线程
            FinishStackerTaskThreads.ForEach(x => CloseThread(x));

            //关闭发送Stacker状态的线程
            // CloseThread(SendStackerStatusThread);

            //关闭发送输送机告警信息的线程
            //CloseThread(SendConveyorAlertThread);

            //关闭增加每个堆垛机离线次数的线程
            AddStackerOffLineTimesThreads.ForEach(x => CloseThread(x));

            //关闭设定每个堆垛机是否在线的线程
            SetStackerIsOnlineThreads.ForEach(x => CloseThread(x));

            //关闭发送Stacker告警的线程
            SendStackerAlertThreads.ForEach(x => CloseThread(x));


            //关闭同步完成次数的线程
            CloseThread(SyncFinishTimesThread);

            //关闭同步处理次数的线程
            CloseThread(SyncHandleTimesThread);

            //关闭同步处理次数的线程
            CloseThread(SyncDecompositionTimesThread);

            //关闭推送同步立库里的物料信息的线程
            // CloseThread(SyncMaterialInfoThread);

            ////关闭定时获取心跳信息的线程
            //CloseThread(GetHeartBeatStateThread);


            //关闭写入堆垛机报表的线程
            CloseThread(WriteStackerReportThread);

            //关闭重推的线程
            //CloseThread(ReSendThread);

            LogTextHelper.WriteLine(Resources.LogDir, "外高桥iWareCc关闭了！");
        }

        /// <summary>
        /// 获取每个堆垛机状态
        /// </summary>
        /// <param name="stacker">需要获取状态的堆垛机</param>
        private void GetStackerState(object stacker)
        {

            var s = (StackerEntity)stacker;
            //LogTextHelper.WriteLine(Resources.LogDir, "获取堆垛机{0}状态线程已开启", s.Equipment.EquipName);
            var items = new string[] 
            {           
                s.OpcReadItems.SrmNo,// 1Srm编号
                s.OpcReadItems.Mode,// 2任务号 
                s.OpcReadItems.Alarm,// 3告警
                s.OpcReadItems.LiftFull, // 4载货工位是否有货
                s.OpcReadItems.PosX,// 5当前列
                s.OpcReadItems.PosY,// 6当前层
                s.OpcReadItems.PosZ,//7货叉位置
                s.OpcReadItems.PosXmm,// 8当前列坐标
                s.OpcReadItems.PosYmm,// 9当前层坐标
                s.OpcReadItems.PosZmm,// 10当前货叉标
                s.OpcReadItems.PickFinish,// 11完成取货信号
                s.OpcReadItems.DeliveryFinish,//// 12完成放货信号
                s.OpcReadItems.TaskFinish,// 13任务完成
                s.OpcReadItems.TaskNo,// 14当前任务号
                s.OpcReadItems.State,// 15当前任务执行状态
                s.OpcReadItems.ActualLane,// 16当前巷道号
                s.OpcReadItems.AlarmNumber,// 17告警代码
                s.OpcReadItems.HandShake,// 18心跳

                s.OpcWriteItems.SrmNo,// 1Srm编号
                s.OpcWriteItems.TaskNo,// 2任务号
                s.OpcWriteItems.SourcePosX,// 3源列
                s.OpcWriteItems.SourcePosY,// 4源层
                s.OpcWriteItems.SourcePosZ,//5源排
                s.OpcWriteItems.DestinationPosX,// 6宿列
                s.OpcWriteItems.DestinationPosY,// 7宿层
                s.OpcWriteItems.DestinationPosZ,// 8宿排
                s.OpcWriteItems.Command,// 9发送命令
                s.OpcWriteItems.EmergencyStop,// 10紧急停止
                s.OpcWriteItems.AlarmAck,// 11解除告警
                s.OpcWriteItems.Stb,// 12WCS通讯
                s.OpcWriteItems.Ack,// 13SRM 应答位
                s.OpcWriteItems.HandShake,// 14心跳
                s.OpcWriteItems.Lots

            };
            while (true)
            {
                try
                {
                    var opcs = CacheEntity.OpcWcfServiceClient.ReadValues(items);
                    if (opcs == null || opcs.Length <= 0)
                    {
                        LogTextHelper.WriteLine(Resources.LogDir, "获取堆状态读取失败");
                        Thread.Sleep(1000);
                        continue;
                    }
                    var i = 0;
                    s.SrmNo = int.Parse(opcs[i++].ToString());
                    s.Mode = int.Parse(opcs[i++].ToString());
                    s.Alarm = int.Parse(opcs[i++].ToString());
                    s.LiftFull = int.Parse(opcs[i++].ToString());
                    s.PosX = int.Parse(opcs[i++].ToString());
                    s.PosY = int.Parse(opcs[i++].ToString());
                    s.PosZ = int.Parse(opcs[i++].ToString());
                    s.PosXmm = int.Parse(opcs[i++].ToString());
                    s.PosYmm = int.Parse(opcs[i++].ToString());
                    s.PosZmm = int.Parse(opcs[i++].ToString());
                    s.PickFinish = int.Parse(opcs[i++].ToString());
                    s.DeliveryFinish = int.Parse(opcs[i++].ToString());
                    s.TaskFinish = int.Parse(opcs[i++].ToString());
                    s.TaskNo = int.Parse(opcs[i++].ToString());
                    s.State = int.Parse(opcs[i++].ToString());
                    s.ActualLane = int.Parse(opcs[i++].ToString());
                    s.AlarmNumber = int.Parse(opcs[i++].ToString());
                    s.HandShake = int.Parse(opcs[i++].ToString());

                    s.WSrmNo = int.Parse(opcs[i++].ToString());
                    s.WTaskNo = int.Parse(opcs[i++].ToString());
                    s.WSourcePosX = int.Parse(opcs[i++].ToString());
                    s.WSourcePosY = int.Parse(opcs[i++].ToString());
                    s.WSourcePosZ = int.Parse(opcs[i++].ToString());
                    s.WDestinationPosX = int.Parse(opcs[i++].ToString());
                    s.WDestinationPosY = int.Parse(opcs[i++].ToString());
                    s.WDestinationPosZ = int.Parse(opcs[i++].ToString());
                    s.WCommand = int.Parse(opcs[i++].ToString());
                    s.WEmergencyStop = int.Parse(opcs[i++].ToString());
                    s.WAlarmAck = int.Parse(opcs[i++].ToString());
                    s.WStb = int.Parse(opcs[i++].ToString());
                    s.WAck = int.Parse(opcs[i++].ToString());
                    s.WHandShake = int.Parse(opcs[i++].ToString());
                    s.WLots = int.Parse(opcs[i++].ToString());

                }
                catch (Exception ex)
                {
                    LogTextHelper.WriteLine(Resources.LogDir, "堆垛机{0}读取状态失败:{1}", s.Equipment.EquipName, ex.Message);
                }
                Thread.Sleep(1000);
            }
        }

        /// <summary>
        /// 获取输送机端口状态的函数
        /// </summary>
        /// <param name="gate">输送机</param>
        private void GetGateState(object gate)
        {

            var g = (GateEntity)gate;

            //LogTextHelper.WriteLine(Resources.LogDir, "获取输送机端口{0}状态线程已开启", g.Place.Name);

            var items = new List<string>();
            //////Read
            //1
            if (!string.IsNullOrEmpty(g.OpcReadItems.RTaskId))
            {
                items.Add(g.OpcReadItems.RTaskId);
            }
            //2
            if (!string.IsNullOrEmpty(g.OpcReadItems.ROccupied))
            {
                items.Add(g.OpcReadItems.ROccupied);
            }
            //3
            if (!string.IsNullOrEmpty(g.OpcReadItems.RIsEmpty))
            {
                items.Add(g.OpcReadItems.RIsEmpty);
            }
            //4
            if (!string.IsNullOrEmpty(g.OpcReadItems.RCheckResult))
            {
                items.Add(g.OpcReadItems.RCheckResult);
            }
            //////Write
            //1
            if (!string.IsNullOrEmpty(g.OpcWriteItems.WTaskId))
            {
                items.Add(g.OpcWriteItems.WTaskId);
            }
            //2
            if (!string.IsNullOrEmpty(g.OpcWriteItems.WStartRotation))
            {
                items.Add(g.OpcWriteItems.WStartRotation);
            }
            //3
            if (!string.IsNullOrEmpty(g.OpcWriteItems.WPickFinishSymbol))
            {
                items.Add(g.OpcWriteItems.WPickFinishSymbol);
            }
            //4
            if (!string.IsNullOrEmpty(g.OpcWriteItems.WPutFinishSymbol))
            {
                items.Add(g.OpcWriteItems.WPutFinishSymbol);
            }
            //5
            if (!string.IsNullOrEmpty(g.OpcWriteItems.WIsInStorage))
            {
                items.Add(g.OpcWriteItems.WIsInStorage);
            }
            while (true)
            {
                try
                {

                    var opcs = CacheEntity.OpcWcfServiceClient.ReadValues(items.ToArray());

                    if (opcs == null || opcs.Length <= 0)
                    {
                        Thread.Sleep(1000);
                        continue;
                    }
                    var i = 0;

                    //1
                    if (!string.IsNullOrEmpty(g.OpcReadItems.RTaskId))
                    {
                        var value = opcs[i++];

                        g.TaskId = value == null ? "" : value.ToString();
                    }

                    //2
                    if (!string.IsNullOrEmpty(g.OpcReadItems.ROccupied))
                    {
                        var value = opcs[i++];

                        g.ROccupied = value == null ? false : bool.Parse(value.ToString());
                    }

                    //3
                    if (!string.IsNullOrEmpty(g.OpcReadItems.RIsEmpty))
                    {
                        var value = opcs[i++];


                        g.RIsEmpty = value == null ? false : bool.Parse(value.ToString());
                    }

                    //4
                    if (!string.IsNullOrEmpty(g.OpcReadItems.RCheckResult))
                    {
                        var value = opcs[i++];
                        g.RCheckMaterialCode = value == null ? "" : value.ToString();
                    }

                    //1
                    if (!string.IsNullOrEmpty(g.OpcWriteItems.WTaskId))
                    {
                        var value = opcs[i++];
                        g.TaskId = value == null ? "" : value.ToString();
                    }

                    //2
                    if (!string.IsNullOrEmpty(g.OpcWriteItems.WPutFinishSymbol))
                    {
                        var value = opcs[i++];
                        g.WPutFinishSymbol = value == null ? false : bool.Parse(value.ToString());
                    }

                    //3
                    if (!string.IsNullOrEmpty(g.OpcWriteItems.WPickFinishSymbol))
                    {
                        var value = opcs[i++];
                        g.WPickFinishSymbol = value == null ? false : bool.Parse(value.ToString());
                    }

                    //4
                    if (!string.IsNullOrEmpty(g.OpcWriteItems.WStartRotation))
                    {
                        var value = opcs[i++];
                        g.WStartRotation = value == null ? false : bool.Parse(value.ToString());
                    }

                    //5
                    if (!string.IsNullOrEmpty(g.OpcWriteItems.WIsInStorage))
                    {
                        var value = opcs[i++];
                        g.WIsInStorage = value == null ? false : bool.Parse(value.ToString());
                    }


                }
                catch (Exception ex)
                {
                    LogTextHelper.WriteLine(Resources.LogDir, "端口{0}读取状态失败:{1}", g.Place.PlaceTypeName, ex.Message);
                }


                Thread.Sleep(1000);
            }
        }

        #region Client
        /// <summary>
        /// 获取输送机端口报文的函数
        /// </summary>
        /// <param name="gate">输送机</param>
        //private void GetGateSocketInfor(object gate)
        //{
        //    var g = (GateEntity)gate;
        //    while (true)
        //    {
        //        try
        //        {
        //            var gateService = new GateService(g);
        //            gateService.HandleMsg(gateService.ReadFromDatagramReceivePool());
        //        }
        //        catch (Exception ex)
        //        {
        //            LogTextHelper.WriteLine(Resources.LogDir, "端口{0}读取状态失败:{1}", g.Place.PlaceTypeName, ex.Message);
        //        }


        //        Thread.Sleep(1000);
        //    }
        //}

        /// <summary>
        /// 发送输送机端口报文的函数
        /// </summary>
        /// <param name="gate">输送机</param>
        private void SendGateSocketInfor(object gate)
        {
            var g = (GateEntity)gate;
            while (true)
            {
                try
                {
                    if (!g.SendFlag)
                    {
                        continue;
                    }
                    string msg = new GateService(g).ReadFromDatagramSendPool();
                    if (!string.IsNullOrEmpty(msg))
                    {

                        if (!g.Socket.Send(ASCIIEncoding.UTF8.GetBytes(msg)))
                        {
                            //过滤心跳和读取状态
                            if (!msg.StartsWith(EGateCommandWordUtil.EGateCommandWord2String(EGateCommandWord.心跳)))
                            {
                                LogTextHelper.WriteLine(Resources.LogDir, "在类{0}中执行方法{1}时出现异常：{2}", this.ToString(), "SendGateSocketInfor", "发送报文异常");
                            }
                        }
                        else
                        {
                            if (!msg.StartsWith(EGateCommandWordUtil.EGateCommandWord2String(EGateCommandWord.心跳)) &&
                                !msg.StartsWith(EGateCommandWordUtil.EGateCommandWord2String(EGateCommandWord.开始滚动)) &&
                                !msg.StartsWith(EGateCommandWordUtil.EGateCommandWord2String(EGateCommandWord.停止滚动))
                                )
                            {
                                if (g.ClientSendLogger.Count >= 20)
                                {
                                    g.ClientSendLogger.RemoveAt(0);
                                }
                                g.ClientSendLogger.Add(msg);
                            }
                        }
                    }
                }
                catch (Exception ex)
                {
                    LogTextHelper.WriteLine(Resources.LogDir, "端口{0}发送报文失败:{1}", g.Place.PlaceTypeName, ex.Message);
                }
                Thread.Sleep(1000);
            }
        }
        #endregion

        #region Server
        /// <summary>
        /// 处理从输送机端口获取的报文信息的函数
        /// </summary>
        /// <param name="gate">输送机</param>
        private void ServerHandleGateMsg(object gate)
        {
            var g = (GateEntity)gate;
            while (true)
            {
                try
                {
                    var gateService = new GateService(g);
                    gateService.HandleMsgSend(gateService.ReadFromDatagramPoolSend());
                    if (g.Place.PlaceTypeName == "sc")
                    {
                        gateService.HandleMsgSCReceive(gateService.ReadFromDatagramPoolSCReceive());
                    }
                    else 
                    {
                        gateService.HandleMsgReceive(gateService.ReadFromDatagramPoolReceive());
                        gateService.HandleMsgAlarmReceive(gateService.ReadFromDatagramPoolAlarmReceive());
                    }
                }
                catch (Exception ex)
                {
                    LogTextHelper.WriteLine(Resources.LogDir, "端口{0}信息读取失败:{1}", g.Place.PlaceTypeName, ex.Message);
                }


                Thread.Sleep(2000);
            }
        }

        /// <summary>
        /// 将从输送机端口获取的报文写入日志
        /// </summary>
        /// <param name="gate"></param>
        //private void ServerGateWriteDatagamLog(object gate)
        //{
        //    var g = (GateEntity)gate;
        //    while (true)
        //    {
        //        try
        //        {
        //            LogTextHelper.WriteLine(Resources.LogDir, "端口{0}读取接收的报文:{1}", g.Place.PlaceTypeName, g.DatagramReceivePool);
        //            LogTextHelper.WriteLine(Resources.LogDir, "端口{0}读取发送的报文:{1}", g.Place.PlaceTypeName, g.DatagramSendPool);
        //        }
        //        catch (Exception ex)
        //        {
        //            LogTextHelper.WriteLine(Resources.LogDir, "端口{0}读取状态失败:{1}", g.Place.PlaceTypeName, ex.Message);
        //        }
        //        Thread.Sleep(60000);
        //    }
        //} 

        #endregion

        private void StartSocket(object gate)
        {
            var g = (GateEntity)gate;
            while (true)
            {
                try
                {
                    //Socket服务端启动接收
                    if (!g.SocketServer.IsServerStarted)
                    {
                        if (!g.SocketServer.ServerStart())
                        {
                            LogTextHelper.WriteLine(Resources.LogDir, "{0}的发送服务套接字启动异常", g.Place.PlaceTypeName);
                        }
                    }
                }
                catch (Exception ex)
                {
                    LogTextHelper.WriteLine(Resources.LogDir, "端口{0}读取状态失败:{1}", g.Place.PlaceTypeName, ex.Message);
                }

                Thread.Sleep(2000);
            }
        }


        /// <summary>
        /// 生成入库主任务
        /// </summary>
        private void CreateMainInTask()
        {
               var c = (ConveyorEntity)CacheEntity.Conveyors.Find(x => x.Equipment.EquipName == "conveyor1");
               var mainTaskContainer = new MainTaskContainer();
               var 生成入库主任务 = new 根据扫码生成入库主任务(c, mainTaskContainer);
               var 保存生成的任务 = new 保存生成的入库任务(c, mainTaskContainer);
               生成入库主任务.NextHandler = 保存生成的任务;

                while (true)
                {
                    if (CacheEntity.IsAutoRun)
                    {
                        生成入库主任务.Handle();
                    }
                    Thread.Sleep(1000);
                }
        }
        /// <summary>
        /// 生成出库主任务
        /// </summary>
        private void CreateMainOutTask()
        {
            var mainTaskContainer = new MainTaskContainer();
            var 生成出库主任务 = new 生成出库主任务(mainTaskContainer);
            var 保存生成的出库任务 = new 保存生成的出库任务(mainTaskContainer);
            生成出库主任务.NextHandler = 保存生成的出库任务;

            while (true)
            {
                if (CacheEntity.IsAutoRun)
                {
                    生成出库主任务.Handle();
                }
                Thread.Sleep(2000);
            }
        }


        /// <summary>
        /// 分解任务
        /// </summary>
        private void DecomposeTask()
        {
            var mainTaskContainer = new MainTaskContainer();
            var partTaskContainer = new PartTaskContainer();
            var placeContainer = new PlaceContainer();
            var resultContainer = new ResultContainer();

            var 按策略获取一个待分解任务 = new 按策略获取一个待分解任务(mainTaskContainer);
            var 根据任务类型生成分解任务 = new 根据任务类型生成分解任务(resultContainer, mainTaskContainer, partTaskContainer, placeContainer);
            var 保存分解任务 = new 保存分解任务(mainTaskContainer, partTaskContainer, placeContainer);

            按策略获取一个待分解任务.NextHandler = 根据任务类型生成分解任务;
            根据任务类型生成分解任务.NextHandler = 保存分解任务;

            while (true)
            {
                mainTaskContainer.MainTask = null;
                partTaskContainer.PartTask = null;
                resultContainer.Msg = "";

                if (CacheEntity.IsAutoMode)
                {
                    按策略获取一个待分解任务.Handle();
                }
                Thread.Sleep(1000);
            }
        }
        /// <summary>
        /// 处理任务的线程
        /// </summary>
        private void HandleTask()
        {
            var resultContainer = new ResultContainer();
            var handleTaskContainer = new PartTaskContainer();
            var nextTaskContainer = new PartTaskContainer();

            var 获取一个已完成但未处理的分解任务 = new 获取一个已完成但未处理的分解任务(handleTaskContainer);
            var 根据任务类型获取下一阶段任务 = new 根据任务类型获取下一阶段任务(handleTaskContainer, nextTaskContainer, resultContainer);
            var 保存处理信息 = new 保存处理信息(handleTaskContainer, nextTaskContainer);

            获取一个已完成但未处理的分解任务.NextHandler = 根据任务类型获取下一阶段任务;
            根据任务类型获取下一阶段任务.NextHandler = 保存处理信息;

            while (true)
            {
                resultContainer.Msg = "";
                handleTaskContainer.PartTask = null;
                nextTaskContainer.PartTask = null;
                if (CacheEntity.IsAutoHandle)
                {
                    获取一个已完成但未处理的分解任务.Handle();
                }
                Thread.Sleep(200);
            }
        }

        /// <summary>
        /// 自动执行输送机任务
        /// </summary>
        private void DoConveyorTaskAuto(object conveyor)
        {
            var c = (ConveyorEntity)conveyor;
            var decompositionTaskContainer = new PartTaskContainer();
            var 选择一个未执行的输送机的任务 = new 选择一个未执行的输送机的任务(c, decompositionTaskContainer);
            var 发送输送机任务 = new 发送输送机任务(c, decompositionTaskContainer);

            选择一个未执行的输送机的任务.NextHandler = 发送输送机任务;

            while (true)
            {
                if (CacheEntity.IsAutoRun)
                {
                    选择一个未执行的输送机的任务.Handle();
                }
                Thread.Sleep(200);
            }
        }

        /// <summary>
        /// 自动执行堆垛机任务
        /// </summary>
        private void DoStackerTaskAuto(object stacker)
        {
            var s = (StackerEntity)stacker;
            var decompositionTaskContainer = new PartTaskContainer();

            var 选择一个未执行的堆垛机的任务 = new 选择一个未执行的堆垛机的任务(s, decompositionTaskContainer);
            var 发送堆垛机任务 = new 发送堆垛机任务(s, decompositionTaskContainer);

            选择一个未执行的堆垛机的任务.NextHandler = 发送堆垛机任务;

            while (true)
            {
                if (CacheEntity.IsAutoRun)
                {
                    选择一个未执行的堆垛机的任务.Handle();
                }
                Thread.Sleep(2000);
            }
        }


        /// <summary>
        /// 完成输送机任务
        /// </summary>
        private void FinishConveyorTask(object conveyor)
        {
            var c = (ConveyorEntity)conveyor;
            var decompositionTaskContainer = new PartTaskContainer();

            var 获取当前的任务 = new 获取当前的任务(c, decompositionTaskContainer);
            var 查看物料是否到输送机末端 = new 查看物料是否到输送机末端(c, decompositionTaskContainer);

            获取当前的任务.NextHandler = 查看物料是否到输送机末端;

            while (true)
            {
                获取当前的任务.Handle();
                Thread.Sleep(200);
            }
        }

        /// <summary>
        /// 完成堆垛机任务
        /// </summary>
        private void FinishStackerTask(object stacker)
        {
            var s = (StackerEntity)stacker;
            var decompositionTaskContainer = new PartTaskContainer();

            var 获取当前的堆垛机任务 = new 获取当前的堆垛机任务(s, decompositionTaskContainer);
            var 等待堆垛机完成任务 = new 等待堆垛机完成任务(s, decompositionTaskContainer);
            var 将完成结果更新至数据库 = new 将完成结果更新至数据库(s, decompositionTaskContainer);
            var 保存出入库明细信息 = new 保存出入库明细信息(s, decompositionTaskContainer);

            获取当前的堆垛机任务.NextHandler = 等待堆垛机完成任务;
            等待堆垛机完成任务.NextHandler = 将完成结果更新至数据库;
            将完成结果更新至数据库.NextHandler = 保存出入库明细信息;

            while (true)
            {
                获取当前的堆垛机任务.Handle();
                Thread.Sleep(2000);
            }
        }


        /// <summary>
        /// 添加堆垛机离线次数
        /// </summary>
        private void AddStackerOffLineTimes(object stacker)
        {
            var s = (StackerEntity)stacker;
            while (true)
            {
                if (s.OffLineTimes > 5)
                {
                    s.IsOnline = false;
                }
                else
                {
                    s.OffLineTimes += 1;
                }

                Thread.Sleep(1000);
            }
        }


        //设定每个堆垛机是否在线的线程
        private void SetStackerIsOnline(object stacker)
        {
            var s = (StackerEntity)stacker;
            while (true)
            {
                if (s.HandShake != s.LastHandShake)
                {
                    s.LastHandShake = s.HandShake;
                    s.OffLineTimes = 0;
                    s.IsOnline = true;
                }

                Thread.Sleep(1000);
            }
        }




        //获取Stacker告警
        private void SendStackerAlert(object stacker)
        {

            var generator = new ProxyGenerator();
            var s = (StackerEntity)stacker;
            while (true)
            {
                using (var dbModel = new DbModelLog())
                {
                    try
                    {
                        var alertList = new List<AlertEntity>();
                        var alerts = dbModel.DEVAlerts.Where(x => x.name == s.Equipment.EquipName && x.isfinished == (int)EYesOrNo.否).ToList();
                        if (s.Alarm == (int)EYesOrNo.是)
                        {
                            string alertnumber = s.AlarmNumber.ToString();
                            var alert = alerts.FirstOrDefault(x => x.alertcode == alertnumber && x.eventcode == (int)EEventCode.警告触发);

                            if (alert == null)
                            {
                                alertList.Add(new AlertEntity()
                                {
                                    Name = s.Equipment.EquipName,
                                    CreateTime = DateTime.Now,
                                    Type = (int)EEquipmentType.堆垛机,
                                    EquipId = EEquipmentType.堆垛机.ToString(),
                                    FinishTime = DateTime.Now,
                                    IsFinished = (int)EYesOrNo.否,
                                    AlertCode = s.AlarmNumber.ToString(),
                                    EventCode = (int)EEventCode.警告触发,
                                    AlertName = ((ESrmAlarm1)s.AlarmNumber).ToString(),
                                });
                                AlertDao.GetInstance().Save(alertList, dbModel);
                            }
                        }
                        else
                        {
                            alerts.ForEach(x =>
                            {
                                x.isfinished = (int)EYesOrNo.是;
                                x.finishtime = DateTime.Now;
                                x.eventcode = (int)EEventCode.警告已修复;
                                alertList.Add(new AlertEntity(x));
                            });

                            dbModel.SaveChanges();
                        }

                    }
                    catch (Exception ex)
                    {
                        LogTextHelper.WriteLine(Resources.LogDir, "推送堆垛机告警失败：{0}", ex.Message);
                    }
                }

                Thread.Sleep(5000);
            }
        }


        ////获取输送机告警
        private void SendConveyorAlert()
        {


            while (true)
            {
                using (var dbModel = new DbModelLog())
                {
                    try
                    {
                        string conveyorCnName = Enum.GetName(typeof(EEquipmentType), EEquipmentType.输送机);
                        var alerm = CacheEntity.Conveyors.Find(x => x.Equipment.EquipName == "conveyor1").Gates.Find(x => x.Place.PlaceTypeName == "alarm");
                        var alertList = new List<AlertEntity>();
                        var alerts = dbModel.DEVAlerts.Where(x => x.name == conveyorCnName && x.isfinished == (int)EYesOrNo.否).ToList();
                        if (int.Parse(alerm.AlarmCode) != (int)EConveyorAlarm.无告警)
                        {
                            var alert = alerts.FirstOrDefault(x => x.alertcode == alerm.AlarmCode && x.eventcode == (int)EEventCode.警告触发);

                            if (alert == null)
                            {
                                alertList.Add(new AlertEntity()
                                {
                                    Name = conveyorCnName,
                                    CreateTime = DateTime.Now,
                                    Type = (int)EEquipmentType.输送机,
                                    EquipId = EEquipmentType.输送机.ToString(),
                                    FinishTime = DateTime.Now,
                                    IsFinished = (int)EYesOrNo.否,
                                    AlertCode = alerm.AlarmCode,
                                    AlertName = ((EConveyorAlarm)int.Parse(alerm.AlarmCode)).ToString(),
                                    EventCode = (int)EEventCode.警告触发
                                });
                                AlertDao.GetInstance().Save(alertList, dbModel);
                            }
                        }
                        else
                        {
                            alerts.ForEach(x =>
                            {
                                x.isfinished = (int)EYesOrNo.是;
                                x.finishtime = DateTime.Now;
                                x.eventcode = (int)EEventCode.警告已修复;
                                alertList.Add(new AlertEntity(x));
                            });

                            dbModel.SaveChanges();
                        }
                    }
                    catch (Exception ex)
                    {
                        LogTextHelper.WriteLine(Resources.LogDir, "推送获取输送机告警失败：{0}", ex.Message);
                    }
                }

                Thread.Sleep(5000);
            }
        }
        /// <summary>
        /// 写入堆垛机报表
        /// </summary>
        private void WriteStackerReport()
        {

            while (true)
            {
                using (var dbModel = new DbModelLog())
                {
                    try
                    {
                       // string stackerName = Enum.GetName(typeof(EEquipmentCnName), EEquipmentCnName.stacker1);
                        var reports = dbModel.COUNTStackerReports.Where(x => x.isfinished == (int)EYesOrNo.否).ToList();
                        var stacker = CacheEntity.Stackers.FirstOrDefault(x => x.Equipment.EquipName == "stacker1");
                        var unfinishedReport = reports.FirstOrDefault(x => x.name == stacker.Equipment.EquipName);
                        if (unfinishedReport == null)
                        {
                            dbModel.COUNTStackerReports.Add(new COUNTStackerReport
                            {
                                name = stacker.Equipment.EquipName,
                                status = stacker.State,
                                createtime = DateTime.Now,
                                isfinished = 0
                            });
                            dbModel.SaveChanges();
                        }
                        else if (unfinishedReport.status != stacker.State)
                        {
                            unfinishedReport.isfinished = (int)EYesOrNo.是;
                            unfinishedReport.finishtime = DateTime.Now;
                            dbModel.COUNTStackerReports.Add(new COUNTStackerReport
                            {
                                name = stacker.Equipment.EquipName,
                                status = stacker.State,
                                createtime = DateTime.Now,
                                isfinished = 0
                            });
                            dbModel.SaveChanges();
                        }
                    }
                    catch (Exception ex)
                    {
                        LogTextHelper.WriteLog(Resources.LogDir, this.ToString(), "WriteStackerReport", ex.Message);
                    }
                }

                Thread.Sleep(5000);
            }
        }


        //同步完成次数
        private void SyncFinishTimes()
        {
            while (true)
            {
                using (var dbModel = new DbModelCore())
                {
                    try
                    {
                        var sql = "UPDATE [dbo].[TASKPartTask] SET [finishtimes]=0 WHERE [isreleased]=1 AND [isfinished]=0";
                        dbModel.Database.ExecuteSqlCommand(sql);
                    }
                    catch (Exception ex)
                    {
                        LogTextHelper.WriteLine(Resources.LogDir, "同步完成次数失败：{0}", ex.Message);
                    }
                }

                Thread.Sleep(49000);

            }
        }

        //同步处理次数
        private void SyncHandleTimes()
        {
            while (true)
            {
                using (var dbModel = new DbModelCore())
                {
                    try
                    {
                        var sql = "UPDATE [dbo].[TASKPartTask] SET [handletimes]=0 WHERE [isfinished] = 1 AND [ishandled] = 0 ";
                        dbModel.Database.ExecuteSqlCommand(sql);
                    }
                    catch (Exception ex)
                    {
                        LogTextHelper.WriteLine(Resources.LogDir, "同步处理次数失败：{0}", ex.Message);
                    }
                }
                Thread.Sleep(23000);
            }
        }

        //同步分解次数
        private void SyncDecompositionTimes()
        {
            while (true)
            {
                using (var dbModel = new DbModelCore())
                {
                    try
                    {
                        var sql = "UPDATE [dbo].[TASKMainTask] SET [decompositiontimes]=0 WHERE [status]=0 ";
                        dbModel.Database.ExecuteSqlCommand(sql);

                    }
                    catch (Exception ex)
                    {
                        LogTextHelper.WriteLine(Resources.LogDir, "同步分解次数失败：{0}", ex.Message);
                    }
                }
                Thread.Sleep(87000);
            }
        }

        //同步立库里的物料信息
        private void SyncMaterialInfo()
        {
            var generator = new ProxyGenerator();

            while (true)
            {
                using (var dbModel = new DbModelCore())
                {
                    try
                    {
                        var wareHouseInfo = new List<object>();
                        var materialList = new List<string>();
                        var placeMaterial = dbModel.BASEPlaceMaterialViews.ToList();
                        var tasks = dbModel.TASKPartTasks.Where(x => x.type == (int)EPartTaskType.堆垛机任务 && x.isfinished == (int)EYesOrNo.否).ToList();
                        tasks.ForEach(x => materialList.Add(x.materialcode));

                        foreach (var pc in placeMaterial)
                        {
                            if (materialList.Contains(pc.materialcode))
                            {
                                continue;
                            }
                            wareHouseInfo.Add(new
                            {
                                materialcode = pc.materialcode,
                                wareHousePlaceId = pc.placecode,
                                packageNumber = "",
                                quantity = 1,
                                materialCode = pc.materialcode,
                                flag = true
                            });

                        }
                        var requestBody = new
                        {
                            sysCode = "WCS",
                            timestamp = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"),
                            wareHouseInfo = wareHouseInfo
                        };
                        // new Context(new 同步立库物料信息(requestBody)).Invoke();

                        LogTextHelper.WriteLine(Resources.LogDir, "SyncMaterialInfo：{0}", "同步物料已完成");
                    }
                    catch (Exception ex)
                    {
                        LogTextHelper.WriteLine(Resources.LogDir, "SyncMaterialInfo：{0}", ex.Message);
                    }
                }
                Thread.Sleep(2 * 3600 * 1000);
            }
        }

        /// <summary>
        /// 重推报文发送失败信息
        /// </summary>
        private void ReSend()
        {
            //LogTextHelper.WriteLine(Resources.LogDir, "重推的线程已开启");
            while (true)
            {
                using (var dbModel = new DbModelLog())
                {
                    try
                    {
                        var eMsg = dbModel.LOGERRORFailSentMessages.OrderBy(x => x.retrytimes).ThenBy(x => x.createtime).FirstOrDefault(x => x.isok == (int)EYesOrNo.否 && x.ismailed == (int)EYesOrNo.否 && x.retrytimes < 3);
                        if (eMsg != null)
                        {
                            string msg;
                            var flag = FailSentMessageService.GetInstance().ReSend(eMsg.id, out msg);
                            LogTextHelper.WriteLine(Resources.LogDir, "重推报文id={0},flag={1},msg={2}", eMsg.id, flag, msg);
                        }
                    }
                    catch (Exception ex)
                    {
                        LogTextHelper.WriteLog(Resources.LogDir, this.ToString(), "ReSend", ex.Message);
                    }
                }
                Thread.Sleep(1000);
            }
        }

        ///<summary>
        ///关闭WCF
        ///</summary>
        ///<param name="host">需要关闭的WCF</param>
        private void CloseWcf(ServiceHost host)
        {
            if (host != null)
            {
                host.Close();
            }
        }

        /// <summary>
        /// 开启线程
        /// </summary>  
        private void StartThread(Thread thread)
        {
            if (thread != null)
            {
                thread.IsBackground = true;
                thread.Start();
            }
            LogTextHelper.WriteLine(Resources.LogDir, "线程{0}已开启", thread.Name);
        }

        /// <summary>
        /// 开启带参数的线程
        /// </summary>
        private void StartThread(Thread thread, object obj)
        {
            if (thread != null)
            {
                thread.IsBackground = true;
                thread.Start(obj);
            }
            LogTextHelper.WriteLine(Resources.LogDir, "线程{0}已开启", thread.Name);
        }

        /// <summary>
        /// 关闭线程
        /// </summary>
        /// <param name="thread">需要关闭的线程</param>
        private void CloseThread(Thread thread)
        {
            if (thread != null)
            {
                thread.Abort();
            }
            LogTextHelper.WriteLine(Resources.LogDir, "线程{0}已关闭", thread.Name);
        }
    }
}