ICSharpCode.SharpZipLib.Zip.ZipOutputStream.PutNextEntry C# (CSharp) Méthode

        public void PutNextEntry(ZipEntry entry)
        {
            if (entry == null) {
                throw new ArgumentNullException(nameof(entry));
            }

            if (entries == null) {
                throw new InvalidOperationException("ZipOutputStream was finished");
            }

            if (curEntry != null) {
                CloseEntry();
            }

            if (entries.Count == int.MaxValue) {
                throw new ZipException("Too many entries for Zip file");
            }

            CompressionMethod method = entry.CompressionMethod;
            int compressionLevel = defaultCompressionLevel;

            // Clear flags that the library manages internally
            entry.Flags &= (int)GeneralBitFlags.UnicodeText;
            patchEntryHeader = false;

            bool headerInfoAvailable;

            // No need to compress - definitely no data.
            if (entry.Size == 0) {
                entry.CompressedSize = entry.Size;
                entry.Crc = 0;
                method = CompressionMethod.Stored;
                headerInfoAvailable = true;
            } else {
                headerInfoAvailable = (entry.Size >= 0) && entry.HasCrc && entry.CompressedSize >= 0;

                // Switch to deflation if storing isnt possible.
                if (method == CompressionMethod.Stored) {
                    if (!headerInfoAvailable) {
                        if (!CanPatchEntries) {
                            // Can't patch entries so storing is not possible.
                            method = CompressionMethod.Deflated;
                            compressionLevel = 0;
                        }
                    } else // entry.size must be > 0
                      {
                        entry.CompressedSize = entry.Size;
                        headerInfoAvailable = entry.HasCrc;
                    }
                }
            }

            if (headerInfoAvailable == false) {
                if (CanPatchEntries == false) {
                    // Only way to record size and compressed size is to append a data descriptor
                    // after compressed data.

                    // Stored entries of this form have already been converted to deflating.
                    entry.Flags |= 8;
                } else {
                    patchEntryHeader = true;
                }
            }

            if (Password != null) {
                entry.IsCrypted = true;
                if (entry.Crc < 0) {
                    // Need to append a data descriptor as the crc isnt available for use
                    // with encryption, the date is used instead.  Setting the flag
                    // indicates this to the decompressor.
                    entry.Flags |= 8;
                }
            }

            entry.Offset = offset;
            entry.CompressionMethod = (CompressionMethod)method;

            curMethod = method;
            sizePatchPos = -1;

            if ((useZip64_ == UseZip64.On) || ((entry.Size < 0) && (useZip64_ == UseZip64.Dynamic))) {
                entry.ForceZip64();
            }

            // Write the local file header
            WriteLeInt(ZipConstants.LocalHeaderSignature);

            WriteLeShort(entry.Version);
            WriteLeShort(entry.Flags);
            WriteLeShort((byte)entry.CompressionMethodForHeader);
            WriteLeInt((int)entry.DosTime);

            // TODO: Refactor header writing.  Its done in several places.
            if (headerInfoAvailable) {
                WriteLeInt((int)entry.Crc);
                if (entry.LocalHeaderRequiresZip64) {
                    WriteLeInt(-1);
                    WriteLeInt(-1);
                } else {
                    WriteLeInt(entry.IsCrypted ? (int)entry.CompressedSize + ZipConstants.CryptoHeaderSize : (int)entry.CompressedSize);
                    WriteLeInt((int)entry.Size);
                }
            } else {
                if (patchEntryHeader) {
                    crcPatchPos = baseOutputStream_.Position;
                }
                WriteLeInt(0);  // Crc

                if (patchEntryHeader) {
                    sizePatchPos = baseOutputStream_.Position;
                }

                // For local header both sizes appear in Zip64 Extended Information
                if (entry.LocalHeaderRequiresZip64 || patchEntryHeader) {
                    WriteLeInt(-1);
                    WriteLeInt(-1);
                } else {
                    WriteLeInt(0);  // Compressed size
                    WriteLeInt(0);  // Uncompressed size
                }
            }

            byte[] name = ZipConstants.ConvertToArray(entry.Flags, entry.Name);

            if (name.Length > 0xFFFF) {
                throw new ZipException("Entry name too long.");
            }

            var ed = new ZipExtraData(entry.ExtraData);

            if (entry.LocalHeaderRequiresZip64) {
                ed.StartNewEntry();
                if (headerInfoAvailable) {
                    ed.AddLeLong(entry.Size);
                    ed.AddLeLong(entry.CompressedSize);
                } else {
                    ed.AddLeLong(-1);
                    ed.AddLeLong(-1);
                }
                ed.AddNewEntry(1);

                if (!ed.Find(1)) {
                    throw new ZipException("Internal error cant find extra data");
                }

                if (patchEntryHeader) {
                    sizePatchPos = ed.CurrentReadIndex;
                }
            } else {
                ed.Delete(1);
            }

            if (entry.AESKeySize > 0) {
                AddExtraDataAES(entry, ed);
            }
            byte[] extra = ed.GetEntryData();

            WriteLeShort(name.Length);
            WriteLeShort(extra.Length);

            if (name.Length > 0) {
                baseOutputStream_.Write(name, 0, name.Length);
            }

            if (entry.LocalHeaderRequiresZip64 && patchEntryHeader) {
                sizePatchPos += baseOutputStream_.Position;
            }

            if (extra.Length > 0) {
                baseOutputStream_.Write(extra, 0, extra.Length);
            }

            offset += ZipConstants.LocalHeaderBaseSize + name.Length + extra.Length;
            // Fix offsetOfCentraldir for AES
            if (entry.AESKeySize > 0)
                offset += entry.AESOverheadSize;

            // Activate the entry.
            curEntry = entry;
            crc.Reset();
            if (method == CompressionMethod.Deflated) {
                deflater_.Reset();
                deflater_.SetLevel(compressionLevel);
            }
            size = 0;

            if (entry.IsCrypted) {
                if (entry.AESKeySize > 0) {
                    WriteAESHeader(entry);
                } else {
                    if (entry.Crc < 0) {            // so testing Zip will says its ok
                        WriteEncryptionHeader(entry.DosTime << 16);
                    } else {
                        WriteEncryptionHeader(entry.Crc);
                    }
                }
            }
        }

        private void saveFileDialog_FileOk(object sender, CancelEventArgs e)
        {
            ReportText = ReportTextBox.Text;
            ZipEntry ze;
            ZipOutputStream zip_out = new ZipOutputStream(File.Create((sender as SaveFileDialog).FileName));
            string SourceText;
            byte[] data=null;
            foreach (string FileName in FileNames)
            {
                SourceText = VEC.StandartCompiler.GetSourceFileText(FileName);
                if (SourceText != null)
                {
                    data = System.Text.Encoding.GetEncoding(1251).GetBytes(SourceText);
                    ze = new ZipEntry(System.IO.Path.GetFileName(FileName));
                    zip_out.PutNextEntry(ze);
                    zip_out.Write(data, 0, data.Length);
                }
            }
            ze = new ZipEntry("Report.txt");
            zip_out.PutNextEntry(ze);
            data = System.Text.Encoding.GetEncoding(1251).GetBytes(ReportText); 
            zip_out.Write(data, 0, data.Length);
           	zip_out.Finish();
			zip_out.Close();
        }