/// <summary>
        /// 构造函数 -- 封装数据
        /// </summary>
        /// <param name="eCategory"></param>
        /// <param name="eService"></param>
        /// <param name="pSocketData"></param>
        public SocketPacket(TaskService eService, CustomDataCollection pSocketData)
        {
            this._eService    = eService;
            this._pSocketData = pSocketData;

            this.eCategory  = DefineUtilities.ToTaskCategory(eService);
            this.strMessage = string.Empty;
        }
Beispiel #2
0
        static void RealtimeWarning(object source, System.Timers.ElapsedEventArgs e)
        {
            System.Timers.Timer pp = (System.Timers.Timer)source;
            pp.Enabled = false;

            MSSQLOperate pRealtimeCheck = new MSSQLOperate(strAccess);//(strAccess);

            pRealtimeCheck.Connect(false);
            pRealtimeCheck.ExecuteQuery("EXEC SP_GET_REALTIMECONTENT");// ("EXEC SP_GET_REALTIMECONTENT");
            pRealtimeCheck.GetResult(RecordStyle.DATASET);
            DataSet pDataSet = (DataSet)pRealtimeCheck.RecordData;

            if (null != pDataSet && pDataSet.Tables[0].Rows.Count > 0)
            {
                CustomDataCollection mReturnBody = new CustomDataCollection(StructType.CUSTOMDATA);

                foreach (DataTable pDataTable in pDataSet.Tables)
                {
                    for (int i = 0; i < pDataTable.Rows.Count; i++)
                    {
                        uint usFirstTag = 0x08000001;

                        for (int j = 0; j < pDataTable.Columns.Count; j++)
                        {
                            mReturnBody.Add((DataField)usFirstTag, DefineUtilities.ToDataFormat(pDataTable.Columns[j].DataType.Name), pDataTable.Rows[i][j]);

                            usFirstTag++;
                        }
                        mReturnBody.AddRows();
                    }
                }

                SocketPacket mSocketPacket = new SocketPacket(TaskService.INSTANT_MONITOR_SEND, mReturnBody);

                byte[] pSendBuffer = mSocketPacket.CoalitionInfo();

                if (null != pServer.SocketConnected)
                {
                    pServer.SocketConnected.ServerConnection().SendTo(pSendBuffer, true);
                    pServer.SocketConnected.OnRecive();

                    //pRealtimeCheck.ExecuteQuery("EXEC SP_SET_VIEW");
                    //pRealtimeCheck.GetResult(RecordStyle.NONE);
                }
            }

            pp.Enabled = true;
        }
        private void RealTimeProcessing(object state)
        {
            if (!this.Disposed)
            {
                ISocketConnection pSendChannels   = null;
                SqlCommand        pCallBackCmd    = null;
                SqlDataReader     pCallBackReader = null;
                TaskService       pCallService    = this.eService;//TaskService.MESSAGE;

                IAsyncResult AsyncResult = (IAsyncResult)state;

                try
                {
                    byte[]               pSendBuffer;
                    SocketPacket         pSendPacket   = null;
                    CustomDataCollection pRealTimeData = null;

                    RecordDataCallback pRealTimeCallback = (RecordDataCallback)AsyncResult.AsyncState;

                    pCallService  = pRealTimeCallback.Service;
                    pSendChannels = pRealTimeCallback.Channels;
                    pCallBackCmd  = (SqlCommand)pRealTimeCallback.Command;

                    if (null != this.SocketConnection)
                    {
                        pCallBackReader = pCallBackCmd.EndExecuteReader(AsyncResult);

                        if (pCallBackReader.HasRows)
                        {
                            while (pCallBackReader.Read())
                            {
                                pRealTimeData = new CustomDataCollection(StructType.CUSTOMDATA);

                                for (int i = 0; i < pCallBackReader.FieldCount; i++)
                                {
                                    pRealTimeData.Add(DefineUtilities.ToDataField(pCallBackReader.GetName(i)), DefineUtilities.ToDataFormat(pCallBackReader.GetFieldType(i).Name), pCallBackReader[i]);
                                }

                                pRealTimeData.AddRows();

                                pSendPacket = new SocketPacket(pCallService, pRealTimeData);

                                pSendBuffer = pSendPacket.CoalitionInfo();
                                this.SocketConnection.OnSend(pSendBuffer);

                                pRealTimeData.Clear();
                                pSendPacket.Dispose();

                                pRealTimeData = null;
                                pSendBuffer   = null;
                            }
                        }
                        else
                        {
                            pRealTimeData = new CustomDataCollection(StructType.CUSTOMDATA);

                            pRealTimeData.Add("暂无数据");

                            pSendPacket = new SocketPacket(pCallService, pRealTimeData);

                            pSendBuffer = pSendPacket.CoalitionInfo();
                            this.SocketConnection.OnSend(pSendBuffer);

                            pRealTimeData.Clear();
                            pSendPacket.Dispose();

                            pRealTimeData = null;
                            pSendBuffer   = null;
                        }
                    }
                }
                catch (SqlException ex)
                {
                    this.strErrorMsg = ex.Message;
                }
                catch (Exception ex)
                {
                    this.strErrorMsg = ex.Message;
                }
                finally
                {
                    try
                    {
                        pCallBackReader.Close();

                        pCallBackReader.Dispose();
                        pCallBackCmd.Dispose();

                        pCallBackReader = null;
                        pCallBackCmd    = null;
                    }
                    catch (Exception ex)
                    {
                        this.strErrorMsg = ex.Message;

                        CustomDataCollection pRealTimeData = new CustomDataCollection(StructType.CUSTOMDATA);

                        pRealTimeData.Add(strErrorMsg);

                        SocketPacket pSendPacket = new SocketPacket(pCallService, pRealTimeData);

                        byte[] pSendBuffer = pSendPacket.CoalitionInfo();
                        this.SocketConnection.OnSend(pSendBuffer);
                    }
                }
            }
        }