Example #1
0
        static public UINodeInfoInTree SictAuswert(
            this GbsAstInfo gbsBaum)
        {
            if (null == gbsBaum)
            {
                return(null);
            }

            var GbsBaumScpez =
                SictRefNezKopii.ObjektKopiiErsctele(
                    gbsBaum,
                    null,
                    new Bib3.RefBaumKopii.Param(null, KonvertGbsAstInfoRictliinieMitScatescpaicer),
                    null,
                    null)
                as UINodeInfoInTree;

            if (null == GbsBaumScpez)
            {
                return(null);
            }

            int InBaumAstIndexZääler = 0;

            GbsBaumScpez.AbgelaiteteAigescafteBerecne(ref InBaumAstIndexZääler);

            return(GbsBaumScpez);
        }
Example #2
0
        static public VonSensorikMesung SensorikScnapscusKonstrukt(
            this    Optimat.EveOnline.GbsAstInfo GbsBaum)
        {
            if (null == GbsBaum)
            {
                return(null);
            }

            /*
             * 2015.03.13
             *
             * var GbsBaumScpez = GbsBaum.TypeKonvertNewtonsoftJson<SictGbsAstInfoSictAuswert>();
             * */
            var GbsBaumScpez =
                SictRefNezKopii.ObjektKopiiErsctele(
                    GbsBaum,
                    null,
                    new SictRefBaumKopiiParam(null, KonvertGbsAstInfoRictliinieMitScatescpaicer),
                    null,
                    null)
                as SictGbsAstInfoSictAuswert;

            if (null == GbsBaumScpez)
            {
                return(null);
            }

            int InBaumAstIndexZääler = 0;

            GbsBaumScpez.AbgelaiteteAigescafteBerecne(ref InBaumAstIndexZääler);

            var Auswert = new SictAuswertGbsAgr(GbsBaumScpez);

            Auswert.Berecne();

            return(Auswert.AuswertErgeebnis);
        }
        public void Berecne(
            Func <Int64, SictBerictDataiIdentInDsInfo> FunkZuBerictScritIndexDataiIdent,
            Func <string, byte[]> FunkZuDataiPfaadDataiInhalt,
            //	Func<Int64, SictWertMitZait<Optimat.Anwendung.RefNezDiferenz.SictRefNezDiferenzScritSictJson>> FunkZuBerictScritIndexBerictScritBerecne,
            Int64 BerecnungEndeAnwendungZaitMili)
        {
            while (true)
            {
                var ScritLezteAutomaatZuusctand = InternListeZuZaitAutomaatZuusctand.LastOrDefault().Wert;

                if (null != ScritLezteAutomaatZuusctand)
                {
                    if (BerecnungEndeAnwendungZaitMili <= ScritLezteAutomaatZuusctand.NuzerZaitMili)
                    {
                        break;
                    }
                }

                if (null == FunkZuBerictScritIndexDataiIdent)
                {
                    return;
                }

                if (null == FunkZuDataiPfaadDataiInhalt)
                {
                    return;
                }

                var ScritIndex = (ScritVerwertetLezteIndex + 1) ?? BeginBerictScritIndex;

                var BerictScritDataiIdent = FunkZuBerictScritIndexDataiIdent(ScritIndex);

                if (null == BerictScritDataiIdent.DataiPfaad)
                {
                    return;
                }

                var DataiInhalt = FunkZuDataiPfaadDataiInhalt(BerictScritDataiIdent.DataiPfaad);

                using (var ZipArchive = new System.IO.Compression.ZipArchive(new MemoryStream(DataiInhalt), System.IO.Compression.ZipArchiveMode.Read))
                {
                    var MengeEntry = ZipArchive.Entries;

                    if (null != MengeEntry)
                    {
                        foreach (var Entry in MengeEntry)
                        {
                            using (var EntryStream = Entry.Open())
                            {
                                var EntryInhalt = Optimat.Glob.AusStreamLeese(EntryStream);

                                var EntrySictUTF8 = Encoding.UTF8.GetString(EntryInhalt);

                                var EntrySictSctrukt = SictBerictAusDsAuswert.AusStringVonAnwendungBerictBerecne(EntrySictUTF8);

                                //	!!!! Hiir werd davon ausgegange das MengeAutomaatZuusctandSictSeriel jewails komplete Zuusctand (Diferenz von 0) enthalte.

                                var MengeAutomaatZuusctandSictSeriel =
                                    EntrySictSctrukt.MengeAutomaatZuusctandMitZait ??
                                    EntrySictSctrukt.MengeAutomaatZuusctandDiferenzScritMitZait;

                                if (null != MengeAutomaatZuusctandSictSeriel)
                                {
                                    foreach (var AutomaatZuusctandSictSerielMitZait in MengeAutomaatZuusctandSictSeriel)
                                    {
                                        var AutomaatZuusctandSictSeriel = AutomaatZuusctandSictSerielMitZait.Wert;

                                        var ScritIndexNulbar = AutomaatZuusctandSictSeriel.ScritIndex;

                                        if (!ScritIndexNulbar.HasValue)
                                        {
                                            continue;
                                        }

                                        if (ScritVerwertetLezteIndex.HasValue)
                                        {
                                            var AutomaatZuusctandBerictScritErwartetIndex = (ScritVerwertetLezteIndex + 1) ?? 0;

                                            if (!(AutomaatZuusctandBerictScritErwartetIndex == ScritIndexNulbar))
                                            {
                                                continue;
                                            }
                                        }

                                        ScritVerwertetLezteIndex = ScritIndexNulbar;

                                        Optimat.ScpezEveOnln.SictAutomatZuusctand AutomaatZuusctandKopii = null;

                                        try
                                        {
                                            var AutomaatZuusctandBerictScritDiferenz = AutomaatZuusctandSictSeriel;

                                            var ScritSume =
                                                BerictSictSume.BerecneScritSumeListeWurzelRefClrUndErfolg(
                                                    AutomaatZuusctandBerictScritDiferenz,
                                                    ZiilMemberExistentNictIgnoriire);

                                            if (null == ScritSume)
                                            {
                                                continue;
                                            }

                                            if (!ScritSume.Volsctändig)
                                            {
                                                continue;
                                            }

                                            var ScritSumeListeObjektReferenzClr = ScritSume.ListeWurzelRefClr;

                                            if (null == ScritSumeListeObjektReferenzClr)
                                            {
                                                continue;
                                            }

                                            var AutomaatZuusctand =
                                                (Optimat.ScpezEveOnln.SictAutomatZuusctand)
                                                ScritSumeListeObjektReferenzClr.FirstOrDefault();

                                            if (null == AutomaatZuusctand)
                                            {
                                                continue;
                                            }

                                            /*
                                             * 2015.00.04
                                             *
                                             * Kopii nit meer durc SictRefNezKopii mööglic da Dictionary<,> verwendet werd.
                                             *
                                             * AutomaatZuusctandKopii = SictRefNezKopii.ObjektKopiiErsctele(AutomaatZuusctand, null, null);
                                             * */

                                            /*
                                             * 2015.00.06
                                             *
                                             * Kopii wiider durc SictRefNezKopii mööglic da SictRefNezKopii naacgerüsct wurd um Verhalte von TypeBehandlungRictliinie RefNezDif zu verwende.
                                             *
                                             * AutomaatZuusctandKopii = RefNezDiferenz.SictRefNezSume.ObjektKopiiBerecne(AutomaatZuusctand,
                                             *      RefNezDiferenz.NewtonsoftJson.SictMengeTypeBehandlungRictliinieNewtonsoftJson.KonstruktSictParam());
                                             * */

                                            AutomaatZuusctandKopii = SictRefNezKopii.ObjektKopiiErsctele(AutomaatZuusctand, null, null);
                                        }
                                        finally
                                        {
                                            InternListeZuZaitAutomaatZuusctand.Add(
                                                new SictWertMitZait <Optimat.ScpezEveOnln.SictAutomatZuusctand>(
                                                    AutomaatZuusctandSictSerielMitZait.Zait, AutomaatZuusctandKopii));
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
        public void Berecne(
            out System.Exception LaadeDataiException,
            int?VerwertungMengeDataiAnzaalScranke)
        {
            LaadeDataiException = null;

            var BerictVerzaicnisPfaad = this.BerictHauptVerzaicnisPfaad;
            var BerictWindowClientRasterVerzaicnisPfaad = this.BerictWindowClientRasterVerzaicnisPfaad;

            var MengeAutomaatZuusctandScnapscusAngefordertZaitMili = this.MengeAutomaatZuusctandScnapscusAngefordertZaitMili;

            var MengeAutomaatZuusctandScnapscusAngefordertAuswert = this.MengeAutomaatZuusctandScnapscusAngefordertAuswert;

            var WorkaroundAusBerictBeginListeScritAnzaalUnvolsctändigAnzaal = this.WorkaroundAusBerictBeginListeScritAnzaalUnvolsctändigAnzaal;

            var BerecneLezteListeAutomaatZuusctand = new List <KeyValuePair <Int64, Optimat.ScpezEveOnln.SictAutomatZuusctand> >();

            try
            {
                if (null != MengeAutomaatZuusctandScnapscusAngefordertZaitMili)
                {
                    var MengeAutomaatZuusctandScnapscusVorhandeZaitMili = DictVonAutomaatZaitMiliAutomaatZuusctand.MengeKeyBerecne();

                    var MengeAutomaatZuusctandScnapscusNocZuLaadeZaitMili =
                        MengeAutomaatZuusctandScnapscusAngefordertZaitMili
                        .Where((KandidaatNocZuLaade) => !MengeAutomaatZuusctandScnapscusVorhandeZaitMili.Contains(KandidaatNocZuLaade)).ToArray();

                    if (0 < MengeAutomaatZuusctandScnapscusNocZuLaadeZaitMili.Length)
                    {
                        var AutomaatZuusctandScnapscusNocZuLaadeZaitMili = MengeAutomaatZuusctandScnapscusNocZuLaadeZaitMili.OrderBy((t) => t).FirstOrDefault();

                        var BeginBerictScritIndex =
                            Math.Max(0,
                                     DictVonAnwendungBerictScritIndexPfaadZuAutomaatZuusctandInfo
                                     .LastOrDefault((Kandidaat) => Kandidaat.Value.Zait <= AutomaatZuusctandScnapscusNocZuLaadeZaitMili).Key -
                                     WorkaroundAusBerictBeginListeScritAnzaalUnvolsctändigAnzaal - 4);

                        var AuswertErhalte = false;

                        if (null != MengeAutomaatZuusctandScnapscusAngefordertAuswert)
                        {
                            var BeginScritDistanzVonBisherAuswert = BeginBerictScritIndex - MengeAutomaatZuusctandScnapscusAngefordertAuswert.ScritVerwertetLezteIndex;

                            if (MengeAutomaatZuusctandScnapscusAngefordertAuswert.ListeZuZaitAutomaatZuusctand.LastOrDefault().Zait < AutomaatZuusctandScnapscusNocZuLaadeZaitMili &&
                                BeginScritDistanzVonBisherAuswert < 10)
                            {
                                AuswertErhalte = true;
                            }
                        }

                        if (!AuswertErhalte)
                        {
                            this.MengeAutomaatZuusctandScnapscusAngefordertAuswert = MengeAutomaatZuusctandScnapscusAngefordertAuswert =
                                new SictBerictListeScritDiferenzAuswert(BeginBerictScritIndex, ZiilMemberExistentNictIgnoriire);
                        }

                        MengeAutomaatZuusctandScnapscusAngefordertAuswert.Berecne(
                            (ScritIndex) => Optimat.Glob.TAD(this.DictVonAnwendungBerictScritIndexPfaadZuAutomaatZuusctandInfo, ScritIndex).Wert,
                            InhaltAusDataiMitPfaad,
                            AutomaatZuusctandScnapscusNocZuLaadeZaitMili);
                    }
                }

                if (null != MengeAutomaatZuusctandScnapscusAngefordertAuswert)
                {
                    var ListeZuZaitAutomaatZuusctand = MengeAutomaatZuusctandScnapscusAngefordertAuswert.ListeZuZaitAutomaatZuusctand;

                    if (null != ListeZuZaitAutomaatZuusctand)
                    {
                        var ListeZuZaitAutomaatZuusctandVermuutungVolsctändig = ListeZuZaitAutomaatZuusctand;

                        if (0 < MengeAutomaatZuusctandScnapscusAngefordertAuswert.BeginBerictScritIndex)
                        {
                            ListeZuZaitAutomaatZuusctandVermuutungVolsctändig =
                                ListeZuZaitAutomaatZuusctand.Skip(WorkaroundAusBerictBeginListeScritAnzaalUnvolsctändigAnzaal);
                        }

                        foreach (var ZuZaitAutomaatZuusctand in ListeZuZaitAutomaatZuusctandVermuutungVolsctändig)
                        {
                            if (null != ZuZaitAutomaatZuusctand.Wert)
                            {
                                var AutomaatScritIdentZaitMili = (Int64?)ZuZaitAutomaatZuusctand.Wert.NuzerZaitMili;

                                if (!AutomaatScritIdentZaitMili.HasValue)
                                {
                                    continue;
                                }

                                DictVonAutomaatZaitMiliAutomaatZuusctand.AintraagErsctele(AutomaatScritIdentZaitMili.Value, ZuZaitAutomaatZuusctand.Wert);
                            }
                        }
                    }
                }

                try
                {
                    if (!(VerwertungMengeDataiAnzaalScranke <= 0) &&
                        null != BerictVerzaicnisPfaad)
                    {
                        /*
                         * Ermitelt ob noie Dataie vorhande und verwertet diise gegeebenenfals.
                         * */

                        var BerictVerzaicnis = new DirectoryInfo(BerictVerzaicnisPfaad);

                        var MengeFile = BerictVerzaicnis.GetFiles();

                        var ListeFile =
                            MengeFile
                            .OrderBy((KandidaatFile) => KandidaatFile.Name)
                            .ToArray();

                        int VerwertungMengeDataiAnzaalBisher = 0;

                        foreach (var File in ListeFile)
                        {
                            if (VerwertungMengeDataiAnzaalScranke <= VerwertungMengeDataiAnzaalBisher)
                            {
                                break;
                            }

                            var DataiPfaad = File.FullName;

                            var DataiBeraitsVerwertet = Optimat.Glob.TAD(DictZuDataiPfaadDataiVerwertungErfolg, DataiPfaad);

                            if (DataiBeraitsVerwertet)
                            {
                                continue;
                            }

                            int DataiVerwertungVersuucAnzaal = 0;

                            DictZuDataiPfaadDataiVerwertungVersuucAnzaal.TryGetValue(DataiPfaad, out DataiVerwertungVersuucAnzaal);

                            if (3 < DataiVerwertungVersuucAnzaal)
                            {
                                continue;
                            }

                            DictZuDataiPfaadDataiVerwertungVersuucAnzaal[DataiPfaad] = 1 + DataiVerwertungVersuucAnzaal;

                            var DataiInhalt = InhaltAusDataiMitPfaad(DataiPfaad);

                            if (null == DataiInhalt)
                            {
                                continue;
                            }

                            using (var ZipArchive = new System.IO.Compression.ZipArchive(new MemoryStream(DataiInhalt), System.IO.Compression.ZipArchiveMode.Read))
                            {
                                var MengeEntry = ZipArchive.Entries;

                                if (null != MengeEntry)
                                {
                                    foreach (var Entry in MengeEntry)
                                    {
                                        var EntryIdent = new SictBerictDataiIdentInDsInfo(DataiPfaad, Entry.FullName);

                                        using (var EntryStream = Entry.Open())
                                        {
                                            var EntryInhalt = Optimat.Glob.AusStreamLeese(EntryStream);

                                            var EntrySictUTF8 = Encoding.UTF8.GetString(EntryInhalt);

                                            var EntrySictSctrukt = AusStringVonAnwendungBerictBerecne(EntrySictUTF8);

                                            //	!!!! Hiir werd davon ausgegange das MengeAutomaatZuusctandSictSeriel jewails komplete Zuusctand (Diferenz von 0) enthalte.

                                            var MengeAutomaatZuusctandSictSeriel =
                                                EntrySictSctrukt.MengeAutomaatZuusctandMitZait ??
                                                EntrySictSctrukt.MengeAutomaatZuusctandDiferenzScritMitZait;

                                            if (null != MengeAutomaatZuusctandSictSeriel)
                                            {
                                                foreach (var AutomaatZuusctandSictSeriel in MengeAutomaatZuusctandSictSeriel)
                                                {
                                                    var ScritIndexNulbar = AutomaatZuusctandSictSeriel.Wert.ScritIndex;

                                                    if (!ScritIndexNulbar.HasValue)
                                                    {
                                                        continue;
                                                    }

                                                    var ScritIndex = ScritIndexNulbar.Value;

                                                    var AutomaatZuusctandBerictScritErwartetIndex = (AutomaatZuusctandBerictScritLezteIndex + 1) ?? 0;

                                                    if (!(AutomaatZuusctandBerictScritErwartetIndex == ScritIndex))
                                                    {
                                                        continue;
                                                    }

                                                    AutomaatZuusctandBerictScritLezteIndex = ScritIndex;

                                                    var AutomaatZuusctandBerictScritDiferenz = AutomaatZuusctandSictSeriel;

                                                    var ScritSume =
                                                        AutomaatZuusctandBerictSictSume.BerecneScritSumeListeWurzelRefClrUndErfolg(
                                                            AutomaatZuusctandBerictScritDiferenz.Wert,
                                                            ZiilMemberExistentNictIgnoriire);

                                                    if (null == ScritSume)
                                                    {
                                                        continue;
                                                    }

                                                    var ScritSumeListeObjekt = ScritSume.ListeWurzelRefClr;

                                                    //	!!!!	zu erseze durc entferne taatsäclic nit meer benöötigte.
                                                    AutomaatZuusctandBerictSictSume.MengeObjektInfoEntferneÄltere(ScritIndex - 44);

                                                    if (null == ScritSumeListeObjekt)
                                                    {
                                                        continue;
                                                    }

                                                    var AutomaatZuusctand =
                                                        (Optimat.ScpezEveOnln.SictAutomatZuusctand)
                                                        ScritSumeListeObjekt.FirstOrDefault();

                                                    if (null == AutomaatZuusctand)
                                                    {
                                                        continue;
                                                    }

                                                    var AutomaatScritIdentZaitMili = (Int64?)AutomaatZuusctand.NuzerZaitMili;

                                                    if (!AutomaatScritIdentZaitMili.HasValue)
                                                    {
                                                        continue;
                                                    }

                                                    /*
                                                     * 2015.00.04
                                                     *
                                                     * Kopii nit meer durc SictRefNezKopii mööglic da Dictionary<,> verwendet werd.
                                                     *
                                                     * var AutomaatZuusctandKopii = SictRefNezKopii.ObjektKopiiErsctele(AutomaatZuusctand, null, null);
                                                     * */

                                                    /*
                                                     * 2015.00.06
                                                     *
                                                     * Kopii wiider durc SictRefNezKopii mööglic da SictRefNezKopii naacgerüsct wurd um Verhalte von TypeBehandlungRictliinie RefNezDif zu verwende.
                                                     *
                                                     *              var AutomaatZuusctandKopii = RefNezDiferenz.SictRefNezSume.ObjektKopiiBerecne(AutomaatZuusctand,
                                                     *                      RefNezDiferenz.NewtonsoftJson.SictMengeTypeBehandlungRictliinieNewtonsoftJson.KonstruktSictParam());
                                                     * */
                                                    var AutomaatZuusctandKopii = SictRefNezKopii.ObjektKopiiErsctele(AutomaatZuusctand, null, null);

                                                    BerecneLezteListeAutomaatZuusctand.Add(new KeyValuePair <Int64, Optimat.ScpezEveOnln.SictAutomatZuusctand>(
                                                                                               AutomaatScritIdentZaitMili.Value,
                                                                                               AutomaatZuusctandKopii));

                                                    DictVonAnwendungBerictScritIndexPfaadZuAutomaatZuusctandInfo[ScritIndexNulbar.Value] =
                                                        new SictWertMitZait <SictBerictDataiIdentInDsInfo>(AutomaatScritIdentZaitMili.Value, EntryIdent);

                                                    ZuAutomaatZuusctandVonZaitMiliAblaitungScpaicere(
                                                        new SictWertMitZait <Optimat.ScpezEveOnln.SictAutomatZuusctand>(
                                                            AutomaatZuusctandSictSeriel.Zait, AutomaatZuusctandKopii));

                                                    if (DictVonAutomaatZaitMiliAutomaatZuusctand.Count < ScatenscpaicerScritZuusctandAnzaalScrankeMax)
                                                    {
                                                        DictVonAutomaatZaitMiliAutomaatZuusctand.AintraagErsctele(AutomaatScritIdentZaitMili.Value, AutomaatZuusctandKopii);
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }

                            DictZuDataiPfaadDataiVerwertungErfolg[DataiPfaad] = true;

                            ++VerwertungMengeDataiAnzaalBisher;
                        }
                    }
                }
                catch (System.Exception Exception)
                {
                    LaadeDataiException = Exception;
                }

                {
                    //	Scatescpaicer Scranke apliziire.

                    DictZuDataiPfaadDataiInhalt.BescrankeEntferneLängerNitVerwendete(
                        null,
                        ScatenscpaicerBerictDataiKapazitäätScranke,
                        (DataiInhalt) => 1000 + ((null == DataiInhalt) ? 0 : DataiInhalt.LongLength));

                    DictVonAutomaatZaitMiliAutomaatZuusctand.BescrankeEntferneLängerNitVerwendete(
                        ScatenscpaicerScritZuusctandAnzaalScrankeMax);
                }

                {
                    AnwendungMengeScnapscusZaitMili =
                        DictVonAnwendungBerictScritIndexPfaadZuAutomaatZuusctandInfo
                        .Select((t) => t.Value.Zait).ToArray();

                    ListeDataiAnzaal = DictZuDataiPfaadDataiVerwertungErfolg.Count;
                }
            }
            finally
            {
                this.BerecneLezteListeAutomaatZuusctand = BerecneLezteListeAutomaatZuusctand.ToArray();
            }
        }