Exemplo n.º 1
0
            /// <summary>
            /// Выполнить запрос
            /// </summary>
            /// <param name="query">Запрос для выполнения</param>
            public void Request(DATASET_WRITER dataSetWriter)
            {
                if (!(_cancelRequest == null))
                {
                    _cancelRequest.Cancel();
                    _cancelRequest.Dispose();
                    _cancelRequest = null;
                }
                else
                {
                    ;
                }

                // очистить очередь идентификаторов источников данных
                m_queueIdConnSett.Clear();
                // сформировать очередь с источниками данных, в ~ от его вкл./выкл. для выполнения запроса к ним
                foreach (ConnectionSettings connSett in m_listConnSett)
                {
                    if ((bool)connSett.Items[(int)ConnectionSettings.INDEX_ITEM.TURN] == true)
                    {
                        m_queueIdConnSett.Enqueue(connSett.id);
                    }
                    else
                    {
                        ;
                    }
                }

                _cancelRequest = new CancellationTokenSource();

                Task.Run(() => fThreadRequest(dataSetWriter), _cancelRequest.Token);
            }
Exemplo n.º 2
0
            /// <summary>
            /// Потоковая функция - выполнить запросы к источникам данных в ~ соответствии со сформированной очередью
            /// </summary>
            /// <param name="obj">Аргумент при вызове</param>
            private void fThreadRequest(DATASET_WRITER dataSet)
            //private void fThreadRequest_DoWork(object obj, DoWorkEventArgs ev)
            {
                INDEX_WAITHANDLE_REASON indxReasonCompleted = INDEX_WAITHANDLE_REASON.COUNT_INDEX_WAITHANDLE_REASON;
                DATASET_WRITER          dataSetWriter       = dataSet;
                string fmtMsg = @"сохранение набора для IdConnSett={0}, [{1}]";

                for (INDEX_WAITHANDLE_REASON i = INDEX_WAITHANDLE_REASON.ERROR; i < (INDEX_WAITHANDLE_REASON.ERROR + 1); i++)
                {
                    ((ManualResetEvent)m_waitHandleState[(int)i]).Reset();
                }

                Query = dataSetWriter.m_values;

                try {
                    while (m_queueIdConnSett.Count > 0)
                    {
                        ClearStates();

                        IdConnSettCurrent = m_queueIdConnSett.Dequeue();
                        // добавить необходимые состояния
                        foreach (StatesMachine state in Enum.GetValues(typeof(StatesMachine)))
                        {
                            AddState((int)state);
                        }

                        Run(string.Format(fmtMsg, IdConnSettCurrent, dataSetWriter.m_dtRecieved.ToString()));
                        // ожидать завершения обработки состояния
                        switch (WaitHandle.WaitAny(new WaitHandle[] {
                            m_waitHandleState[(int)INDEX_WAITHANDLE_REASON.BREAK] // признак успешной обработки крайнего состояния
                            , m_waitHandleState[(int)INDEX_WAITHANDLE_REASON.ERROR]
                        }))
                        {
                        case 0:
                            indxReasonCompleted = INDEX_WAITHANDLE_REASON.SUCCESS;
                            break;

                        case 1:
                        default:
                            indxReasonCompleted = INDEX_WAITHANDLE_REASON.ERROR;
                            break;
                        }

                        // зафиксировать в логе результат
                        if (indxReasonCompleted == INDEX_WAITHANDLE_REASON.SUCCESS)
                        {
                            Logging.Logg().Debug(MethodBase.GetCurrentMethod()
                                                 , string.Format(fmtMsg, IdConnSettCurrent, dataSetWriter.m_dtRecieved.ToString())
                                                 , Logging.INDEX_MESSAGE.NOT_SET);
                        }
                        else
                        {
                            // ERROR
                            Logging.Logg().Error(MethodBase.GetCurrentMethod()
                                                 , string.Format(fmtMsg, IdConnSettCurrent, dataSetWriter.m_dtRecieved.ToString())
                                                 , Logging.INDEX_MESSAGE.NOT_SET);
                        }
                        // оповестить об завершении выполнения группы запросов
                        DataAskedHost(new object[] { indxReasonCompleted, IdConnSettCurrent, dataSetWriter.m_dtRecieved });
                    } // while
                } catch (Exception e) {
                    Logging.Logg().Exception(e
                                             , string.Format(fmtMsg, IdConnSettCurrent, dataSetWriter.m_dtRecieved.ToString())
                                             , Logging.INDEX_MESSAGE.NOT_SET);
                }
            }
Exemplo n.º 3
0
        /// <summary>
        /// Реализация очереди обработки событий - получение данных
        /// </summary>
        /// <param name="s">Идентификатор события</param>
        /// <param name="error">Признак ошибки при выполнении</param>
        /// <param name="outobj">Объект с полученными данными</param>
        /// <returns>Результат выполнения метода</returns>
        protected override int StateCheckResponse(int s, out bool error, out object outobj)
        {
            int iRes = -1;

            DATASET       dataSet;
            StatesMachine state    = (StatesMachine)s;
            string        debugMsg = string.Empty;

            error  = true;
            outobj = null;

            ItemQueue itemQueue = null;

            try {
                switch (state)
                {
                case StatesMachine.NEW:     //
                    iRes  = 0;
                    error = false;

                    itemQueue = Peek;

                    error = (iRes = addDataSet(_writer.ListConnSettKey, (DateTime)itemQueue.Pars[0], itemQueue.Pars[1] as DataTable, itemQueue.Pars[2] as DataTable)) < 0 ? true : false;;

                    debugMsg = string.Format(@"Добавление нового набора [{0}]...", (DateTime)itemQueue.Pars[0]);

                    if (error == false)
                    {
                        // добавленный набор поставить в очередь на запись
                        outobj = new DATASET_WRITER()
                        {
                            m_dtRecieved = _listDataSet[_listDataSet.Count - 1].m_dtRecieved
                            , m_values   = _listDataSet[_listDataSet.Count - 1].m_values
                        };

                        Logging.Logg().Debug(MethodBase.GetCurrentMethod(), debugMsg, Logging.INDEX_MESSAGE.NOT_SET);
                    }
                    else
                    {
                        Logging.Logg().Error(MethodBase.GetCurrentMethod(), debugMsg, Logging.INDEX_MESSAGE.NOT_SET);
                    }
                    break;

                case StatesMachine.LIST_DEST:     // получен спискок объектов с парметрами соединения с БД
                    iRes  = 0;
                    error = false;

                    itemQueue = Peek;
                    // инициализация переданными значениями
                    initialize(itemQueue.Pars[0] as List <WriterHandlerQueue.ConnectionSettings>);
                    // установка соединения с источниками данных
                    _writer.StartDbInterfaces();
                    // обеспечить готовность к приему событий (TSQL-запросов для выполнения)
                    _writer.Start(); _writer.Activate(true);
                    break;

                case StatesMachine.LIST_DATASET:     // запрос на формирование актуального списка переданных для записи наборов
                    iRes  = 0;
                    error = false;

                    itemQueue = Peek;

                    if (!((int)itemQueue.Pars[0] < 0))
                    {
                        outobj = getListViewDataSetItem((int)itemQueue.Pars[0]);
                    }
                    else
                    {
                        ;
                    }
                    break;

                case StatesMachine.DATASET_CONTENT:     // запрос на передачу содержимого набора, выбранного пользователем для отображения
                    iRes  = 0;
                    error = false;

                    itemQueue = Peek;

                    var selectDataSets = from l in _listDataSet where l.m_dtRecieved == (DateTime)itemQueue.Pars[0] select l;
                    if (selectDataSets.Count() == 1)
                    {
                        dataSet = selectDataSets.ElementAt(0);

                        switch ((FormMain.INDEX_CONTROL)itemQueue.Pars[1])
                        {
                        case FormMain.INDEX_CONTROL.TABPAGE_VIEW_DATASET_TABLE_VALUE:
                            outobj = dataSet.m_tableValues;
                            break;

                        case FormMain.INDEX_CONTROL.TABPAGE_VIEW_DATASET_TABLE_PARAMETER:
                            outobj = dataSet.m_tableParameters;
                            break;

                        default:         //??? - ошибка неизвестный тип вкладки просмотра набора
                            break;
                        }
                    }
                    else
                    {
                        ;     //??? - ошибка пакет не найден либо пакетов много
                    }
                    break;
                //case StatesMachine.STATISTIC: //
                //    iRes = 0;
                //    error = false;

                //    itemQueue = Peek;
                //    break;
                case StatesMachine.CONNSET_USE_CHANGED:
                    iRes  = 0;
                    error = false;

                    itemQueue = Peek;
                    _writer.ChangeConnSettUse((int)itemQueue.Pars[0]);
                    break;

                case StatesMachine.OPTION:
                    iRes  = 0;
                    error = false;

                    itemQueue = Peek;
                    s_Option  = (OPTION)itemQueue.Pars[0];

                    //outobj = ??? только в одну сторону: форма -> handler
                    break;

                default:
                    break;
                }
            } catch (Exception e) {
                Logging.Logg().Exception(e, @"WriteHandlerQueue::StateCheckResponse (state=" + state.ToString() + @") - ...", Logging.INDEX_MESSAGE.NOT_SET);

                error = true;
                iRes  = -1 * (int)state;
            }

            return(iRes);
        }