Exemple #1
0
        //Чтение значений из рекордсета по одному блоку
        private ValuesCount ReadPartValues(IRecordRead rec)
        {
            var vc = new ValuesCount();

            while (rec.Read())
            {
                vc.ReadCount++;
                ListSourceOut ob = null;
                try
                {
                    ob = _defineObjectFun(rec);
                    if (ob != null)
                    {
                        vc.WriteCount += ob.ReadMoments(rec);
                    }
                    vc.AddStatus(VcStatus.Success);
                }
                catch (Exception ex)
                {
                    AddErrorOut(ob == null ? "" : ob.Context, "Ошибка при чтении значений из рекордсета", ex);
                    vc.AddStatus(VcStatus.NoSuccess);
                }
            }
            return(vc);
        }
Exemple #2
0
        //Чтение значений из источника, возвращает true, если прочитались все значения или частично
        //В логгере дожны быть заданы начало и конец периода через CommandProgress
        public ValuesCount GetValues()
        {
            var vc = new ValuesCount();

            if (Provider == null)
            {
                AddWarning("Источник не настроен");
                return(vc);
            }
            if (PeriodIsUndefined())
            {
                return(vc);
            }
            using (Start(0, 80))
            {
                vc += Source.ReadValues();
                if (!vc.IsFail)
                {
                    return(vc);
                }
            }

            if (!ChangeProvider())
            {
                return(vc);
            }
            using (Start(80, 100))
                return(Source.ReadValues());
        }
Exemple #3
0
        //Чтение среза
        protected internal override ValuesCount ReadCut()
        {
            var      vc = new ValuesCount();
            DateTime d  = ClonerConnect.RemoveMinultes(PeriodBegin);

            AddEvent("Чтение среза действительных значений из таблицы изменений");
            _useStrTable = false;
            _useCutTable = false;
            vc          += ReadWhole(ObjectsList, d, PeriodBegin, true);
            if (vc.IsFail)
            {
                return(vc);
            }
            AddEvent("Чтение среза действительных значений из таблицы срезов");
            _useStrTable = false;
            _useCutTable = true;
            vc          += ReadWhole(ObjectsList, d.AddSeconds(-1), PeriodBegin.AddSeconds(1), true);
            if (vc.IsFail)
            {
                return(vc);
            }
            AddEvent("Чтение среза строковых значений из таблицы изменений");
            _useStrTable = true;
            _useCutTable = false;
            vc          += ReadWhole(ObjectsList, d, PeriodBegin, true);
            if (vc.IsFail)
            {
                return(vc);
            }
            AddEvent("Чтение среза строковых значений из таблицы срезов");
            _useStrTable = true;
            _useCutTable = true;
            vc          += ReadWhole(ObjectsList, d.AddSeconds(-1), PeriodBegin.AddSeconds(1), true);
            return(vc);
        }
Exemple #4
0
        //Чтение изменений
        protected internal override ValuesCount ReadChanges(DateTime beg, DateTime en)
        {
            var vc = new ValuesCount();

            AddEvent("Чтение изменений действительных значений");
            _useStrTable = false;
            _useCutTable = false;
            vc          += ReadWhole(ObjectsList, beg, en, false);
            if (vc.IsFail)
            {
                return(vc);
            }
            AddEvent("Чтение изменений строковых значений");
            _useStrTable = true;
            _useCutTable = false;
            vc          += ReadWhole(ObjectsList, beg, en, false);
            return(vc);
        }
Exemple #5
0
        //Чтение значений из источника
        internal ValuesCount ReadValues()
        {
            var vcount = new ValuesCount();

            try
            {
                SourceConnect.ClearSignalsValues(false);
                using (Start(5, 10))
                    if (!Connect() || !Prepare())
                    {
                        return(new ValuesCount(VcStatus.Fail));
                    }

                vcount = ReadProviderValues();

                //Вычисление значений расчетных сигналов
                if (SourceConnect.CalcSignals.Count > 0)
                {
                    AddEvent("Вычисление значений расчетных сигналов");
                    int calc = 0;
                    foreach (var sig in SourceConnect.CalcSignals.Values)
                    {
                        sig.Calculate();
                        calc += sig.OutValue.Count;
                    }
                    AddEvent("Значения расчетных сигналов прочитаны", calc + " значений сформировано");
                    vcount.WriteCount += calc;
                }
                AddEvent("Значения из источника прочитаны", vcount.ToString());
            }
            catch (Exception ex)
            {
                AddError("Ошибка при чтении значений из источника", ex);
                return(vcount.AddStatus(VcStatus.Fail));
            }
            finally
            {
                AddErrorOutsWarning();
                PrevProcessEnd = PeriodEnd;
            }
            return(vcount);
        }
Exemple #6
0
        //Чтение значений из провайдера
        protected override ValuesCount ReadProviderValues()
        {
            var vcount = new ValuesCount();

            AddEvent("Чтение среза значений");
            using (Start(10, PeriodBegin == PeriodEnd ? 90 : 40))
                vcount += ReadCut();
            foreach (ListSignal sig in SourceConnect.InitialSignals.Values)
            {
                vcount.WriteCount += sig.MakeBegin();
            }
            AddEvent("Срез значений получен", vcount.ToString());
            if (vcount.Status == VcStatus.Fail)
            {
                return(vcount);
            }

            //Чтение изменений
            if (PeriodBegin < PeriodEnd)
            {
                AddEvent("Чтение изменений значений");
                var ts  = PeriodEnd.Subtract(PeriodBegin).Subtract(new TimeSpan(0, 0, 0, 0, 1));
                var tts = new TimeSpan(0);
                int n   = 0;
                while (tts < ts)
                {
                    tts = tts.Add(PeriodLimit);
                    n++;
                }

                var changes = new ValuesCount();
                using (Start(40, 85))
                {
                    DateTime beg  = PeriodBegin;
                    DateTime en   = Static.MinDate;
                    double   proc = 0;
                    while (en < PeriodEnd)
                    {
                        using (Start(proc, proc += 100.0 / n))
                        {
                            en = beg.Add(PeriodLimit);
                            if (PeriodEnd < en)
                            {
                                en = PeriodEnd;
                            }
                            changes = changes + ReadChanges(beg, en);
                            beg     = en;
                        }
                    }
                }
                foreach (ListSignal sig in SourceConnect.InitialSignals.Values)
                {
                    changes.WriteCount += sig.MakeEnd();
                }
                AddEvent("Изменения значений получены", changes.ToString());
                vcount += changes;
                if (vcount.IsFail)
                {
                    return(vcount);
                }
                Procent = 90;
            }
            return(vcount);
        }
Exemple #7
0
        //Чтение значений по блокам объектов
        protected ValuesCount ReadByParts(IEnumerable <ListSourceOut> objects,                                            //список объектов
                                          int partSize,                                                                   //Размер одного блока
                                          DateTime beg, DateTime en,                                                      //Период считывания
                                          bool isCut,                                                                     //Считывается срез
                                          Func <List <ListSourceOut>, DateTime, DateTime, bool, ValuesCount> readPartFun, //Функция чтения значений по одному блоку
                                          string msg = null)                                                              //Сообщение для истории о запуске чтения данных
        {
            var valuesCount = new ValuesCount();

            try
            {
                int n;
                var parts = MakeParts(objects, partSize, isCut, out n);
                if (n == 0)
                {
                    AddEvent("Пустой список объектов для считывания" + (isCut ? " среза" : ""), beg + " - " + en);
                    return(valuesCount);
                }
                if (!Connect())
                {
                    return(valuesCount.AddStatus(VcStatus.Fail));
                }
                AddEvent(msg ?? "Чтение " + (isCut ? "среза" : "изменений") + " значений сигналов", n + " объектов, " + beg + " - " + en);

                var    success = new bool[parts.Count];
                int    errCount = 0, consErrCount = 0;
                double d = 70.0 / parts.Count;
                for (int i = 0; i < parts.Count; i++)
                {
                    string text = "Чтение блока значений, " + parts[i][0].Context + (parts[i].Count == 0 ? "" : " и др.");
                    using (StartIndicatorText(Procent, Procent + d, text))
                        using (StartKeep(0, 100))
                        {
                            var vc = new ValuesCount();
                            try
                            {
                                vc += readPartFun(parts[i], beg, en, isCut);
                            }
                            catch (Exception ex)
                            {
                                vc.AddStatus(VcStatus.NoSuccess);
                                AddWarning("Ошибка при чтении блока значений", ex);
                            }
                            success[i]   = vc.Status == VcStatus.Success || vc.Status == VcStatus.Undefined;
                            valuesCount += vc;
                            if (vc.Status != VcStatus.Fail && vc.Status != VcStatus.NoSuccess)
                            {
                                AddEvent("Значения блока объектов прочитаны", vc.ToString());
                                consErrCount = 0;
                            }
                            else
                            {
                                errCount++;
                                consErrCount++;
                                AddWarning("Значения блока объектов не были прочитаны", null, vc.ToString());
                                if (consErrCount == 1 && !Reconnect())
                                {
                                    return(valuesCount.AddStatus(VcStatus.Fail));
                                }
                                if (consErrCount > 2)
                                {
                                    AddError("Значения с источника не были прочитаны", null, valuesCount.ToString());
                                    return(valuesCount.AddStatus(VcStatus.Fail));
                                }
                            }
                        }
                }
                if (errCount == 0)
                {
                    AddEvent("Значения с источника прочитаны", valuesCount.ToString());
                    return(valuesCount);
                }

                AddEvent("Рекурсивное чтение значений по блокам объектов");
                valuesCount.Status = VcStatus.Undefined;
                d = 30.0 / parts.Count;
                for (int i = 0; i < parts.Count; i++)
                {
                    using (Start(Procent, Procent + d))
                        if (!success[i])
                        {
                            valuesCount += ReadPartRecursive(parts[i], beg, en, isCut, readPartFun);
                        }
                }
            }
            catch (Exception ex)
            {
                AddError("Ошибка при получении данных", ex);
                return(valuesCount.AddStatus(VcStatus.Fail));
            }
            return(valuesCount);
        }
Exemple #8
0
        //Рекурсивное чтение значений по блоку
        private ValuesCount ReadPartRecursive(List <ListSourceOut> part,                                                      //Блок сигналов
                                              DateTime beg, DateTime en,                                                      //Период считывания
                                              bool isCut,                                                                     //Считывается срез
                                              Func <List <ListSourceOut>, DateTime, DateTime, bool, ValuesCount> readPartFun) //Функция чтения значений по одному блоку
        {
            int n           = 0;
            int errCount    = 0;
            var valuesCount = new ValuesCount();
            var queue       = new Queue <List <ListSourceOut> >();

            queue.Enqueue(part);
            while (queue.Count > 0)
            {
                string text = "Рекурсивное чтение блока значений, " + part[0].Context + (part.Count == 0 ? "" : " и др.");
                using (StartIndicatorText(n < 10 ? 10 * n : 90, n < 9 ? 10 * (n + 1) : 90, text))
                    using (StartKeep(0, 100))
                    {
                        var p = queue.Dequeue();
                        n++;
                        Procent = n < 10 ? 10 * n : 90;
                        if (n == 8 && errCount == 7)
                        {
                            AddWarning("Значения по блоку объектов не прочитаны");
                            return(valuesCount);
                        }
                        AddEvent("Чтение " + (isCut ? "среза" : "изменений") + " значений сигналов", p.Count + " выходов");
                        var vc = new ValuesCount();
                        try
                        {
                            vc = readPartFun(p, beg, en, isCut);
                        }
                        catch (Exception ex)
                        {
                            vc.AddStatus(VcStatus.NoSuccess);
                            AddWarning("Ошибка при чтении блока значений", ex);
                        }

                        valuesCount += vc;
                        if (!vc.IsFail)
                        {
                            AddEvent("Значения прочитаны", vc.ToString());
                        }
                        else
                        {
                            AddWarning("Значения не прочитаны");
                            errCount++;
                            if (p.Count > 1)
                            {
                                if (errCount == 1 && !Reconnect())
                                {
                                    return(valuesCount.AddStatus(VcStatus.Fail));
                                }
                                int m = p.Count / 2;
                                queue.Enqueue(p.GetRange(0, m));
                                queue.Enqueue(p.GetRange(m, part.Count - m));
                            }
                            else
                            {
                                AddErrorOut(p[0].Context, KeepedError);
                            }
                        }
                    }
            }
            return(valuesCount);
        }