/// <summary>
            /// Конструктор основной с параметрами
            /// </summary>
            /// <param name="dtRecieved">Мктка даты/времени получения</param>
            /// <param name="xmlSource">XML-документ</param>
            public PACKAGE(DateTime dtRecieved, XmlDocument xmlSource)
            {
                m_dtRecieved = dtRecieved;
                m_dtSended   = DateTime.MinValue;

                m_state = STATE.NEW;

                m_xmlSource = UDPListener.CopyXmlDocument(xmlSource);

                m_tableParameters = new DataTable();
                m_tableParameters.Columns.AddRange(new DataColumn[] {
                    new DataColumn(@"GROUP", typeof(string))
                    , new DataColumn(@"PARAMETER", typeof(string))
                });
                m_tableValues = new DataTable();
                m_tableValues.Columns.AddRange(new DataColumn[] {
                    new DataColumn(@"GROUP", typeof(string))
                    , new DataColumn(@"PARAMETER", typeof(string))
                    , new DataColumn(@"VALUE", typeof(float))
                });

                m_listXmlTree = new FormMain.ListXmlTree();

                m_state = STATE.PARSING;

                for (int i = 0; i < m_xmlSource.ChildNodes.Count; i++)
                {
                    if (m_xmlSource.ChildNodes[i].NodeType == XmlNodeType.Element)
                    {
                        m_listXmlTree.Add(new FormMain.ListXmlTree());

                        m_listXmlTree.Tag = m_xmlSource.ChildNodes[i].Name;

                        parseNode(m_xmlSource.ChildNodes[i], m_listXmlTree[m_listXmlTree.Count - 1] as FormMain.ListXmlTree);
                    }
                    else
                    {
                        ;
                    }
                }

                m_state = STATE.PARSED; //ERROR
            }
        /// <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;
            StatesMachine state = (StatesMachine)s;
            PACKAGE       package;
            XmlDocument   xmlDocNew;
            XmlNode       nodeRec;
            string        debugMsg = string.Empty;

            error  = true;
            outobj = null;

            ItemQueue itemQueue = null;

            try {
                switch (state)
                {
                case StatesMachine.NEW:     // новый пакет
                    iRes  = 0;
                    error = false;

                    itemQueue = Peek;

                    // удалить лишние пакеты
                    removePackages();

                    xmlDocNew = (XmlDocument)itemQueue.Pars[1];

                    if (m_xmlDocRecieved == null)
                    {
                        m_xmlDocRecieved = UDPListener.CopyXmlDocument(xmlDocNew);
                    }
                    else
                    {
                        ;
                    }

                    foreach (XmlNode nodeNew in xmlDocNew.ChildNodes[1])       //[0] - header, [1] - xml
                    {
                        debugMsg += string.Format(@"{0}, ", nodeNew.Name);

                        if (_dictBuildingParameterRecieved.ContainsKey(nodeNew.Name) == false)
                        {
                            _dictBuildingParameterRecieved.Add(nodeNew.Name, new GROUP_PARAMETER(DateTime.UtcNow));
                        }
                        else
                        {
                            _dictBuildingParameterRecieved[nodeNew.Name].Update(false);

                            if (_dictBuildingParameterRecieved[nodeNew.Name].IsUpdate == true)
                            {
                                nodeRec = m_xmlDocRecieved.ChildNodes[1].SelectSingleNode(nodeNew.Name);

                                if (nodeRec == null)
                                {
                                    nodeRec          = m_xmlDocRecieved.CreateNode(XmlNodeType.Element, nodeNew.Name, nodeNew.NamespaceURI);
                                    nodeRec.InnerXml = nodeNew.InnerXml;
                                    m_xmlDocRecieved.ChildNodes[1].AppendChild(nodeRec);
                                }
                                else
                                {
                                    //m_xmlDocRecieved.ChildNodes[1].ReplaceChild(xmlNode, node);
                                    nodeRec.InnerXml = nodeNew.InnerXml;
                                }
                            }
                            else
                            {
                                ;
                            }
                        }
                    }
                    //Console.WriteLine(string.Format(@"{0} получены: {1}", DateTime.UtcNow, debugMsg));

                    lock (this) {
                        if (_dictBuildingParameterRecieved.IsUpdate == true)
                        {
                            error = (iRes = addPackage((DateTime)itemQueue.Pars[0], m_xmlDocRecieved)) < 0 ? true : false;

                            _dictBuildingParameterRecieved.Update(true);
                        }
                        else
                        {
                            error = false;
                        }
                    }
                    break;

                case StatesMachine.LIST_PACKAGE:     // список пакетов
                    iRes  = 0;
                    error = false;

                    itemQueue = Peek;

                    outobj = listViewPackageItem;
                    break;

                case StatesMachine.PACKAGE_CONTENT:     // пакет
                    iRes  = 0;
                    error = false;

                    itemQueue = Peek;

                    Console.WriteLine(string.Format(@"{0} - Запрос {1}: за [{2}], индекс={3}, состояние={4}"                                                                                               //
                                                    , DateTime.UtcNow, state.ToString(), (DateTime)itemQueue.Pars[0], (int)itemQueue.Pars[2], ((DataGridViewElementStates)itemQueue.Pars[3]).ToString())); //

                    var selectPackages = from p in _listPackage where p.m_dtRecieved == (DateTime)itemQueue.Pars[0] select p;
                    if (selectPackages.Count() == 1)
                    {
                        package = selectPackages.ElementAt(0);

                        switch ((FormMain.INDEX_CONTROL)itemQueue.Pars[1])
                        {
                        case FormMain.INDEX_CONTROL.TABPAGE_VIEW_PACKAGE_XML:
                            outobj = package.m_xmlSource;
                            break;

                        case FormMain.INDEX_CONTROL.TABPAGE_VIEW_PACKAGE_TREE:
                            outobj = package.m_listXmlTree;
                            break;

                        case FormMain.INDEX_CONTROL.TABPAGE_VIEW_PACKAGE_TABLE_VALUE:
                            outobj = package.m_tableValues;
                            break;

                        case FormMain.INDEX_CONTROL.TABPAGE_VIEW_PACKAGE_TABLE_PARAMETER:
                            outobj = package.m_tableParameters;
                            break;

                        default:         //??? - ошибка неизвестный тип вкладки просмотра XML-документа
                            break;
                        }
                    }
                    else
                    {
                        ;     //??? - ошибка пакет не найден либо пакетов много
                    }
                    break;

                case StatesMachine.STATISTIC:     // статистика
                    iRes  = 0;
                    error = false;

                    itemQueue = Peek;

                    //outobj = ??? объект статический
                    break;

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

                    itemQueue = Peek;

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

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

                case StatesMachine.TIMER_TABLERES:     // срок отправлять очередной пакет
                    iRes  = 0;
                    error = false;

                    itemQueue = Peek;
                    // отправить строго крайний, при этом XML-пакет д.б. не отправленным
                    var orderPckages = from p in _listPackage /*where p.m_dtSended == DateTime.MinValue*/ orderby p.m_dtRecieved descending select p;
                    if (orderPckages.Count() > 0)
                    {
                        package = orderPckages.ElementAt(0);

                        if (package.m_dtSended == DateTime.MinValue)
                        {
                            package.m_dtSended = DateTime.UtcNow;
                            // объект со структурой DATA_SET
                            outobj = new object[] {
                                package.m_dtSended
                                , package.m_tableValues.Copy()
                                , package.m_tableParameters.Copy()
                            };
                        }
                        else
                        {
                            // не отправлять пакет на обработку
                            outobj = false;
                        }
                    }
                    else
                    {
                        //??? - ошибка пакет не найден либо пакетов много
                        //    iRes = -1;
                        //    error = true;
                        outobj = false;
                    }

                    _dictBuildingParameterRecieved.Update(false);
                    break;

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

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

            return(iRes);
        }