示例#1
0
        void AingangDatai(
            byte[] DataiInhaltSictListeOktet,
            string AusgangDataiPfaad)
        {
            if (null == DataiInhaltSictListeOktet)
            {
                return;
            }

            var SerializeSettings = new JsonSerializerSettings();

            SerializeSettings.DefaultValueHandling  = DefaultValueHandling.IgnoreAndPopulate;
            SerializeSettings.TypeNameHandling      = TypeNameHandling.Auto;
            SerializeSettings.ReferenceLoopHandling = ReferenceLoopHandling.Serialize;

            /*
             * 2014.04.05
             *
             * Cannot preserve reference to array or readonly list, or list created from a non-default constructor: Optimat.SictWertMitZait`1[Optimat.Anwendung.RefNezDiferenz.SictRefNezDiferenzScritSictJson][]. Path 'MengeAutomaatZuusctandDiferenzScritMitZait.$values', line 1, position 78.
             *
             * SerializeSettings.PreserveReferencesHandling = PreserveReferencesHandling.All;
             * */

            var AusgangVerzaicnisPfaad = System.IO.Path.GetDirectoryName(AusgangDataiPfaad);

            var AusgangVerzaicnis = new DirectoryInfo(AusgangVerzaicnisPfaad);

            if (!AusgangVerzaicnis.Exists)
            {
                AusgangVerzaicnis.Create();
            }

            var AusgangDataiStream = new MemoryStream();

            using (var AusgangZipArchive = new System.IO.Compression.ZipArchive(AusgangDataiStream, System.IO.Compression.ZipArchiveMode.Create, true))
            {
                using (var AingangZipArchive = new System.IO.Compression.ZipArchive(new MemoryStream(DataiInhaltSictListeOktet), System.IO.Compression.ZipArchiveMode.Read))
                {
                    var AingangMengeEntry = AingangZipArchive.Entries;

                    if (null != AingangMengeEntry)
                    {
                        foreach (var AingangEntry in AingangMengeEntry)
                        {
                            var MengeAutomaatZuusctandMitZait = new List <WertZuZaitpunktStruct <Bib3.RefNezDiferenz.SictZuNezSictDiferenzScritAbbild> >();

                            using (var EntryStream = AingangEntry.Open())
                            {
                                var EntryInhalt = Optimat.Glob.AusStreamLeese(EntryStream, null, 0x400000);

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

                                var EntrySictSctrukt = JsonConvert.DeserializeObject <SictVonAnwendungBerict>(EntrySictUTF8);

                                var MengeAutomaatZuusctandDiferenzScritMitZait = EntrySictSctrukt.MengeAutomaatZuusctandDiferenzScritMitZait;

                                if (null != MengeAutomaatZuusctandDiferenzScritMitZait)
                                {
                                    foreach (var AutomaatZuusctandDiferenzScritMitZait in MengeAutomaatZuusctandDiferenzScritMitZait)
                                    {
                                        var AutomaatZuusctandDiferenzScrit = AutomaatZuusctandDiferenzScritMitZait.Wert;

                                        if (null == AutomaatZuusctandDiferenzScrit)
                                        {
                                            continue;
                                        }

                                        var AutomaatZuusctandDiferenzScritIndex = AutomaatZuusctandDiferenzScrit.ScritIndex;

                                        if (!AutomaatZuusctandDiferenzScritIndex.HasValue)
                                        {
                                            continue;
                                        }

                                        var ErwartetScritIndex = (DiferenzScritScnapscusBerecnetLezteIndex + 1) ?? 0;

                                        if (!(AutomaatZuusctandDiferenzScritIndex == ErwartetScritIndex))
                                        {
                                            continue;
                                        }

                                        DiferenzScritScnapscusBerecnetLezteIndex = AutomaatZuusctandDiferenzScritIndex;

                                        var ScnapscusListeObjektUndErfolg = SictSume.ScnapscusBerecne(AutomaatZuusctandDiferenzScrit);

                                        if (!ScnapscusListeObjektUndErfolg.Value)
                                        {
                                        }

                                        var ScnapscusListeObjekt = ScnapscusListeObjektUndErfolg.Key;

                                        if (null == ScnapscusListeObjekt)
                                        {
                                            continue;
                                        }

                                        var ScnapscusObjekt = ScnapscusListeObjekt.FirstOrDefault();

                                        if (null == ScnapscusObjekt)
                                        {
                                            continue;
                                        }

                                        var ScnapscusAutomaatZuusctand = ScnapscusObjekt as Optimat.ScpezEveOnln.SictAutomatZuusctand;

                                        if (null == ScnapscusAutomaatZuusctand)
                                        {
                                            continue;
                                        }

                                        var ScnapscusAutomaatZuusctandSictSeriel =
                                            //	Bib3.RefNezDiferenz.SictRefNezDiferenzScritSictJson.SerialisiireObjekt(
                                            Bib3.RefNezDiferenz.Extension.WurzelSerialisiire(
                                                ScnapscusAutomaatZuusctand,
                                                Optimat.ScpezEveOnln.SictAutomat.ZuusctandSictDiferenzSictParam.TypeBehandlungRictliinieMitScatescpaicer);

                                        MengeAutomaatZuusctandMitZait.Add(
                                            new WertZuZaitpunktStruct <Bib3.RefNezDiferenz.SictZuNezSictDiferenzScritAbbild>(
                                                ScnapscusAutomaatZuusctandSictSeriel,
                                                AutomaatZuusctandDiferenzScritMitZait.Zait));
                                    }
                                }
                            }

                            var AusgangEntryScnapscus = new SictVonAnwendungBerict()
                            {
                                MengeAutomaatZuusctandDiferenzScritMitZait = MengeAutomaatZuusctandMitZait?.ToArray(),
                            };

                            var AusgangEntryScnapscusSictString = JsonConvert.SerializeObject(AusgangEntryScnapscus, SerializeSettings);

                            var AusgangEntryListeOktet = Encoding.UTF8.GetBytes(AusgangEntryScnapscusSictString);

                            var AusgangEntry = AusgangZipArchive.CreateEntry(AingangEntry.Name, System.IO.Compression.CompressionLevel.Optimal);

                            var AusgangEntryStream = AusgangEntry.Open();

                            AusgangEntryStream.Write(AusgangEntryListeOktet, 0, AusgangEntryListeOktet.Length);

                            AusgangEntryStream.Close();
                        }
                    }
                }
            }

            AusgangDataiStream.Seek(0, SeekOrigin.Begin);

            var AusgangZipArchiveListeSegment = Optimat.Glob.VonStreamLeeseNaacListeArray(AusgangDataiStream, 0x10000);

            AusgangDataiStream.Dispose();

            Bib3.Glob.ScraibeInhaltNaacDataiPfaad(AusgangDataiPfaad, Bib3.Glob.ArrayAusListeListeGeflact(AusgangZipArchiveListeSegment));
        }
示例#2
0
        void ListeAutomaatZuusctandDiferenzScritScraibeNaacZipArchiveNaacVerzaicnisBerictNaacDataiMitNaame(
            IEnumerable <WertZuZaitpunktStruct <Bib3.RefNezDiferenz.SictZuNezSictDiferenzScritAbbild> > ListeAutomaatZuusctand,
            string ZiilDataiNaame)
        {
            var ZipArchiveStream = new MemoryStream();

            var SerializeSettings = new JsonSerializerSettings();

            SerializeSettings.DefaultValueHandling  = DefaultValueHandling.IgnoreAndPopulate;
            SerializeSettings.TypeNameHandling      = TypeNameHandling.Auto;
            SerializeSettings.ReferenceLoopHandling = ReferenceLoopHandling.Serialize;

            /*
             * 2014.04.05
             *
             * Cannot preserve reference to array or readonly list, or list created from a non-default constructor: Optimat.SictWertMitZait`1[Optimat.Anwendung.RefNezDiferenz.SictRefNezDiferenzScritSictJson][]. Path 'MengeAutomaatZuusctandDiferenzScritMitZait.$values', line 1, position 78.
             *
             * SerializeSettings.PreserveReferencesHandling = PreserveReferencesHandling.All;
             * */

            using (var ZipArchive = new System.IO.Compression.ZipArchive(ZipArchiveStream, System.IO.Compression.ZipArchiveMode.Create, true))
            {
                if (null != ListeAutomaatZuusctand)
                {
                    foreach (var AutomaatZuusctandZuBericte in ListeAutomaatZuusctand)
                    {
                        if (null == AutomaatZuusctandZuBericte.Wert)
                        {
                            continue;
                        }

                        var AutomaatZuusctandZuBericteZaitSictKalenderString =
                            Bib3.Glob.SictwaiseKalenderString(Bib3.Glob.SictDateTimeVonStopwatchZaitMili(AutomaatZuusctandZuBericte.Zait), ".", 3);

                        var EntryNaame = "[ZAK=" + AutomaatZuusctandZuBericteZaitSictKalenderString + "]";

                        string EntrySictString = null;

                        try
                        {
                            var EntrySctrukt = SictVonAnwendungBerict.KonstruktFürAutomaatZuusctandDiferenzScrit(
                                AutomaatZuusctandZuBericte);

                            EntrySictString = JsonConvert.SerializeObject(EntrySctrukt, Formatting.None, SerializeSettings);
                        }
                        catch (System.Exception Exception)
                        {
                            EntrySictString = Optimat.Glob.ExceptionSictString(Exception);
                        }

                        var EntrySictUTF8 = Encoding.UTF8.GetBytes(EntrySictString);

                        var Entry = ZipArchive.CreateEntry(EntryNaame);

                        var EntryStream = Entry.Open();

                        EntryStream.Write(EntrySictUTF8, 0, EntrySictUTF8.Length);

                        EntryStream.Close();
                    }
                }
            }

            ZipArchiveStream.Seek(0, SeekOrigin.Begin);

            var ZipArchiveListeSegment = Optimat.Glob.VonStreamLeeseNaacListeArray(ZipArchiveStream, 0x10000);

            ZipArchiveStream.Dispose();

            ScraibeNaacDataiInSizungBerictVerzaicnisPfaad(ZiilDataiNaame, ZipArchiveListeSegment);
        }