SaveProgress Event

progressBar1.Value = 0;
progressBar1.Max = listbox1.Items.Count;
using (ZipFile zip = new ZipFile())
{
   // listbox1 contains a list of filenames
   zip.AddFiles(listbox1.Items);

   // do the progress bar:
   zip.SaveProgress += (sender, e) => {
      if (e.EventType == ZipProgressEventType.Saving_BeforeWriteEntry) {
         progressBar1.PerformStep();
      }
   };

   zip.Save(fs);
}

static bool justHadByteUpdate= false;
public static void SaveProgress(object sender, SaveProgressEventArgs e)
{
    if (e.EventType == ZipProgressEventType.Saving_Started)
        Console.WriteLine("Saving: {0}", e.ArchiveName);

    else if (e.EventType == ZipProgressEventType.Saving_Completed)
    {
        justHadByteUpdate= false;
        Console.WriteLine();
        Console.WriteLine("Done: {0}", e.ArchiveName);
    }

    else if (e.EventType == ZipProgressEventType.Saving_BeforeWriteEntry)
    {
        if (justHadByteUpdate)
            Console.WriteLine();
        Console.WriteLine("  Writing: {0} ({1}/{2})",
                          e.CurrentEntry.FileName, e.EntriesSaved, e.EntriesTotal);
        justHadByteUpdate= false;
    }

    else if (e.EventType == ZipProgressEventType.Saving_EntryBytesRead)
    {
        if (justHadByteUpdate)
            Console.SetCursorPosition(0, Console.CursorTop);
         Console.Write("     {0}/{1} ({2:N0}%)", e.BytesTransferred, e.TotalBytesToTransfer,
                      e.BytesTransferred / (0.01 * e.TotalBytesToTransfer ));
        justHadByteUpdate= true;
    }
}

public static ZipUp(string targetZip, string directory)
{
  using (var zip = new ZipFile()) {
    zip.SaveProgress += SaveProgress;
    zip.AddDirectory(directory);
    zip.Save(targetZip);
  }
}

Public Sub ZipUp(ByVal targetZip As String, ByVal directory As String)
    Using zip As ZipFile = New ZipFile
        AddHandler zip.SaveProgress, AddressOf MySaveProgress
        zip.AddDirectory(directory)
        zip.Save(targetZip)
    End Using
End Sub

Private Shared justHadByteUpdate As Boolean = False

Public Shared Sub MySaveProgress(ByVal sender As Object, ByVal e As SaveProgressEventArgs)
    If (e.EventType Is ZipProgressEventType.Saving_Started) Then
        Console.WriteLine("Saving: {0}", e.ArchiveName)

    ElseIf (e.EventType Is ZipProgressEventType.Saving_Completed) Then
        justHadByteUpdate = False
        Console.WriteLine
        Console.WriteLine("Done: {0}", e.ArchiveName)

    ElseIf (e.EventType Is ZipProgressEventType.Saving_BeforeWriteEntry) Then
        If justHadByteUpdate Then
            Console.WriteLine
        End If
        Console.WriteLine("  Writing: {0} ({1}/{2})", e.CurrentEntry.FileName, e.EntriesSaved, e.EntriesTotal)
        justHadByteUpdate = False

    ElseIf (e.EventType Is ZipProgressEventType.Saving_EntryBytesRead) Then
        If justHadByteUpdate Then
            Console.SetCursorPosition(0, Console.CursorTop)
        End If
        Console.Write("     {0}/{1} ({2:N0}%)", e.BytesTransferred, _
                      e.TotalBytesToTransfer, _
                      (CDbl(e.BytesTransferred) / (0.01 * e.TotalBytesToTransfer)))
        justHadByteUpdate = True
    End If
End Sub

delegate void SaveEntryProgress(SaveProgressEventArgs e);
delegate void ButtonClick(object sender, EventArgs e);

public class WorkerOptions
{
    public string ZipName;
    public string Folder;
    public string Encoding;
    public string Comment;
    public int ZipFlavor;
    public Zip64Option Zip64;
}

private int _progress2MaxFactor;
private bool _saveCanceled;
private long _totalBytesBeforeCompress;
private long _totalBytesAfterCompress;
private Thread _workerThread;


private void btnZipup_Click(object sender, EventArgs e)
{
    KickoffZipup();
}

private void btnCancel_Click(object sender, EventArgs e)
{
    if (this.lblStatus.InvokeRequired)
    {
        this.lblStatus.Invoke(new ButtonClick(this.btnCancel_Click), new object[] { sender, e });
    }
    else
    {
        _saveCanceled = true;
        lblStatus.Text = "Canceled...";
        ResetState();
    }
}

private void KickoffZipup()
{
    _folderName = tbDirName.Text;

    if (_folderName == null || _folderName == "") return;
    if (this.tbZipName.Text == null || this.tbZipName.Text == "") return;

    // check for existence of the zip file:
    if (System.IO.File.Exists(this.tbZipName.Text))
    {
        var dlgResult = MessageBox.Show(String.Format("The file you have specified ({0}) already exists." +
                                                      "  Do you want to overwrite this file?", this.tbZipName.Text),
                                        "Confirmation is Required", MessageBoxButtons.YesNo, MessageBoxIcon.Question);
        if (dlgResult != DialogResult.Yes) return;
        System.IO.File.Delete(this.tbZipName.Text);
    }

     _saveCanceled = false;
    _nFilesCompleted = 0;
    _totalBytesAfterCompress = 0;
    _totalBytesBeforeCompress = 0;
    this.btnOk.Enabled = false;
    this.btnOk.Text = "Zipping...";
    this.btnCancel.Enabled = true;
    lblStatus.Text = "Zipping...";

    var options = new WorkerOptions
    {
        ZipName = this.tbZipName.Text,
        Folder = _folderName,
        Encoding = "ibm437"
    };

    if (this.comboBox1.SelectedIndex != 0)
    {
        options.Encoding = this.comboBox1.SelectedItem.ToString();
    }

    if (this.radioFlavorSfxCmd.Checked)
        options.ZipFlavor = 2;
    else if (this.radioFlavorSfxGui.Checked)
        options.ZipFlavor = 1;
    else options.ZipFlavor = 0;

    if (this.radioZip64AsNecessary.Checked)
        options.Zip64 = Zip64Option.AsNecessary;
    else if (this.radioZip64Always.Checked)
        options.Zip64 = Zip64Option.Always;
    else options.Zip64 = Zip64Option.Never;

    options.Comment = String.Format("Encoding:{0} || Flavor:{1} || ZIP64:{2}\r\nCreated at {3} || {4}\r\n",
                options.Encoding,
                FlavorToString(options.ZipFlavor),
                options.Zip64.ToString(),
                System.DateTime.Now.ToString("yyyy-MMM-dd HH:mm:ss"),
                this.Text);

    if (this.tbComment.Text != TB_COMMENT_NOTE)
        options.Comment += this.tbComment.Text;

    _workerThread = new Thread(this.DoSave);
    _workerThread.Name = "Zip Saver thread";
    _workerThread.Start(options);
    this.Cursor = Cursors.WaitCursor;
 }


private void DoSave(Object p)
{
    WorkerOptions options = p as WorkerOptions;
    try
    {
        using (var zip1 = new ZipFile())
        {
            zip1.ProvisionalAlternateEncoding = System.Text.Encoding.GetEncoding(options.Encoding);
            zip1.Comment = options.Comment;
            zip1.AddDirectory(options.Folder);
            _entriesToZip = zip1.EntryFileNames.Count;
            SetProgressBars();
            zip1.SaveProgress += this.zip1_SaveProgress;

            zip1.UseZip64WhenSaving = options.Zip64;

            if (options.ZipFlavor == 1)
                zip1.SaveSelfExtractor(options.ZipName, SelfExtractorFlavor.WinFormsApplication);
            else if (options.ZipFlavor == 2)
                zip1.SaveSelfExtractor(options.ZipName, SelfExtractorFlavor.ConsoleApplication);
            else
                zip1.Save(options.ZipName);
        }
    }
    catch (System.Exception exc1)
    {
        MessageBox.Show(String.Format("Exception while zipping: {0}", exc1.Message));
        btnCancel_Click(null, null);
    }
}



void zip1_SaveProgress(object sender, SaveProgressEventArgs e)
{
    switch (e.EventType)
    {
        case ZipProgressEventType.Saving_AfterWriteEntry:
            StepArchiveProgress(e);
            break;
        case ZipProgressEventType.Saving_EntryBytesRead:
            StepEntryProgress(e);
            break;
        case ZipProgressEventType.Saving_Completed:
            SaveCompleted();
            break;
        case ZipProgressEventType.Saving_AfterSaveTempArchive:
            // this event only occurs when saving an SFX file
            TempArchiveSaved();
            break;
    }
    if (_saveCanceled)
        e.Cancel = true;
}



private void StepArchiveProgress(SaveProgressEventArgs e)
{
    if (this.progressBar1.InvokeRequired)
    {
        this.progressBar1.Invoke(new SaveEntryProgress(this.StepArchiveProgress), new object[] { e });
    }
    else
    {
        if (!_saveCanceled)
        {
            _nFilesCompleted++;
            this.progressBar1.PerformStep();
            _totalBytesAfterCompress += e.CurrentEntry.CompressedSize;
            _totalBytesBeforeCompress += e.CurrentEntry.UncompressedSize;

            // reset the progress bar for the entry:
            this.progressBar2.Value = this.progressBar2.Maximum = 1;

            this.Update();
        }
    }
}


private void StepEntryProgress(SaveProgressEventArgs e)
{
    if (this.progressBar2.InvokeRequired)
    {
        this.progressBar2.Invoke(new SaveEntryProgress(this.StepEntryProgress), new object[] { e });
    }
    else
    {
        if (!_saveCanceled)
        {
            if (this.progressBar2.Maximum == 1)
            {
                // reset
                Int64 max = e.TotalBytesToTransfer;
                _progress2MaxFactor = 0;
                while (max > System.Int32.MaxValue)
                {
                    max /= 2;
                    _progress2MaxFactor++;
                }
                this.progressBar2.Maximum = (int)max;
                lblStatus.Text = String.Format("{0} of {1} files...({2})",
                    _nFilesCompleted + 1, _entriesToZip, e.CurrentEntry.FileName);
            }

             int xferred = e.BytesTransferred >> _progress2MaxFactor;

             this.progressBar2.Value = (xferred >= this.progressBar2.Maximum)
                ? this.progressBar2.Maximum
                : xferred;

             this.Update();
        }
    }
}

private void SaveCompleted()
{
    if (this.lblStatus.InvokeRequired)
    {
        this.lblStatus.Invoke(new MethodInvoker(this.SaveCompleted));
    }
    else
    {
        lblStatus.Text = String.Format("Done, Compressed {0} files, {1:N0}% of original.",
            _nFilesCompleted, (100.00 * _totalBytesAfterCompress) / _totalBytesBeforeCompress);
         ResetState();
    }
}

private void ResetState()
{
    this.btnCancel.Enabled = false;
    this.btnOk.Enabled = true;
    this.btnOk.Text = "Zip it!";
    this.progressBar1.Value = 0;
    this.progressBar2.Value = 0;
    this.Cursor = Cursors.Default;
    if (!_workerThread.IsAlive)
        _workerThread.Join();
}