Dynamic Threading with Start, Pause and Stop event handling

I have created sample application and implemented threading. basically aim to craete this application is i would like to

1. If any process(s) are runnig then User Interface should Notify [DONE]
2. Handle dynamically created thread with ProgressBar [DONE]
3. Provide addition functionality to Start, Pause and Stop thread from available progress list. [NEED YOUR HELP]

Note:- I don't have much knowledge about Threading and Delegates, so please let me know best solution for existing code.

Files and Controls are used:- Basically three files are used in this demo application

4. ProgressForm.cs (Window Form) which conatains Button for creating new progress and Container whic will hold all the created progressbars

5. ProgressClass.cs Which contains Dynamic Threading and Delegates to Notify UI without locking or hanging user interface

6. ProgressControl.cs (User Control)
7. Which contains
8. Progressbar (to display process done)
9. Precent Label (display percentage of completed progress)
10. Start/Pause button (for play/pause a thread)
11. Stop button (stop running thread and remove progress from list)
12. StartTime Label (display process started time)
13. EndTime label (display time of process completed)
14. MaxValue Lable (generate random number between 25 to 100)

CODE SNIPPET:- 1. ProgressForm .cs

public partial class ProgressForm : Form
    {
        Random randomMaxValue = new Random();
        public ProgressForm()
        {
            InitializeComponent();
        }

        private void btnStart_Click(object sender, EventArgs e)
        {
             ProgressClass m_clsProcess;
             ProgressControl progress = new ProgressControl();
             progress.StartedAt = DateTime.Now;
             progress.MinValue = 0;
             progress.CurrentValue = 0;
             progress.MaxValue = randomMaxValue.Next(25, 100);
             AddControl(progress);
             m_clsProcess = new ProgressClass(progress, this, new ProgressClass.NotifyProgress(DelegateProgress));
             m_clsProcess.Start();
        }
        private void DelegateProgress(int CurrentValue, ProgressControl Progress)
        {
            ProgressBar p = (ProgressBar)Progress.Controls.Find("pgbPercent", false)[0];
            p.Minimum = Progress.MinValue;
            p.Value = CurrentValue;
            p.Maximum = Progress.MaxValue;

            Label percent = (Label)Progress.Controls.Find("lblPercent", false)[0];
            percent.Text = string.Format("{0:#00} %", Convert.ToInt16((CurrentValue * 100) / Progress.MaxValue));

            Label start = (Label)Progress.Controls.Find("lblStart", false)[0];
            start.Text = string.Format("{0:HH:mm:ss}", Progress.StartedAt);

            if (CurrentValue == Progress.MaxValue)
            {
                Label complete = (Label)Progress.Controls.Find("lblComplete", false)[0];
                complete.Text = string.Format("{0:HH:mm:ss}", DateTime.Now);
                Progress.Status = ProgressControl.ProgressStatus.Completed;
            }

            Label max = (Label)Progress.Controls.Find("lblMaxValue", false)[0];
            max.Text = string.Format("{0:#00}", Progress.MaxValue);

            Button btnstartstop = (Button)Progress.Controls.Find("btnStartStop", false)[0];
            btnstartstop.Click += new EventHandler(ProgressStartStop);
        }
        private void AddControl(Control ctl)
        {
            tableLayoutPnl.RowCount += 1;
            tableLayoutPnl.RowStyles.Add(new RowStyle());
            ctl.Dock = DockStyle.Fill;
            tableLayoutPnl.Controls.Add(ctl, 0, tableLayoutPnl.RowCount - 1);
        }
        void ProgressStartStop(object sender, EventArgs e)
        {
            Button btn = sender as Button;
            //
            //Here i would like to write a code for START / PAUSE thread and update Image acording too.
            //
        }
    }

2. ProgressControl.cs

public partial class ProgressControl : UserControl
    {
        public enum ProgressStatus
        {
            Initialize,
            Running,
            Paused,
            Completed
        }

        public DateTime StartedAt { get; set; }
        public DateTime CompletedAt { get; set; }
        public int MinValue { get; set; }
        public int CurrentValue { get; set; }
        public int MaxValue { get; set; }
        public ProgressStatus Status { get; set; }

        public ProgressControl()
        {
            InitializeComponent();
            this.Status = ProgressStatus.Initialize;
        }
    }

3. ProgressClass.cs

public class ProgressClass
{
    private int ThreadWaitTime = 100;
    private ProgressControl m_progress;
    private NotifyProgress m_clsNotifyDelegate;
    private System.Threading.Thread m_clsTh开发者_如何学Pythonread;

    private System.ComponentModel.ISynchronizeInvoke m_clsSynchronizingObject;
    public delegate void NotifyProgress(int PercentComplete, ProgressControl Progress);

    public ProgressClass(ProgressControl Progress, System.ComponentModel.ISynchronizeInvoke SynchronizingObject, NotifyProgress NotifyDelegate)
    {
        m_progress = Progress;
        m_clsSynchronizingObject = SynchronizingObject;
        m_clsNotifyDelegate = NotifyDelegate;
    }

    public void Start()
    {
        m_clsThread = new System.Threading.Thread(DoProcess);
        m_clsThread.Name = "Background Thread";
        m_clsThread.IsBackground = true;
        m_progress.Status = ProgressControl.ProgressStatus.Running;
        m_clsThread.Start();
    }
    private void DoProcess()
    {
        for (int i = m_progress.MinValue; i <= m_progress.MaxValue; i++)
        {
            NotifyUI(i);
            Thread.Sleep(ThreadWaitTime);
        }
    }
    private void NotifyUI(int Value)
    {
        object[] args = new object[2];
        args[0] = Value;
        args[1] = m_progress;
        m_clsSynchronizingObject.Invoke(m_clsNotifyDelegate, args);
    }
}

I am not asking for write whole code instead of provide hint.

I would like to start/pause relevent thread from list, os what should i do for that? I would like hind in following function:

   void ProgressStartStop(object sender, EventArgs e)
        {
            Button btn = sender as Button;
            //Here i would like to write a code for START / PAUSE thread and update Image acording too.
        }

UPDATED:

You will want to use a ManualResetEvent or ManualResetEventSlim to create the pause and resume behavior in the thread. The idea is to check the state of the event in the worker thread at safe points. This is done via the WaitOne or Wait methods. If the event is signaled then the calls will return immediately allowing the thread to proceed. If the event is unsignaled then the calls block until the event is signaled via the Set method. So to pause the thread you would call Reset to unsignal the event and to resume the thread you would call Set.

Just remember to place calls to WaitOne or Wait at safe points in the instruction sequence of the worker thread. In other words, do not call these methods inside a lock or something like that. At the beginning or end of a loop is often a good start.

Also, it looks like you use the Invoke method for updating the UI. That is all fine and good, but for simply updating the UI with progress information there is a better option. It is better to publish the progress information to a shared data structure and then have the UI thread pick it up via a timer. For those that monitor my answers I harp about this a lot, I know. But, this strategy has a lot of advantages.

• It breaks the tight coupling between the UI and worker threads that Invoke imposes.
• It puts the responsibility of updating the UI thread on the UI thread where it should belong anyway.
• The UI thread gets to dictate when and how often the update should take place.
• There is no risk of the UI message pump being overrun as would be the case with the marshaling techniques initiated by the worker thread.
• The worker thread does not have to wait for an acknowledgement that the update was performed before proceeding with its next steps (ie. you get more throughput on both the UI and worker threads).
• It avoids the subtle race conditions that can occur when trying to gracefully end the worker thread.
• It is more efficient since Invoke is an expensive operation.

Update:

Here is the general idea regarding the changes that could be made to ProgressStartStop.

private Dictionary<int, ThreadInfo> threads = new Dictionary<int, ThreadInfo>();

void ProgressStartStop(object sender, EventArgs e)
{
  Button button = sender as Button;
  int index = GetThreadIndexFromButton(button);
  if (!threads.ContainsKey(index))
  {
    // The thread has not been started yet so do it now.
    var thread = new Thread(RunThread);
    thread.Start();
    var mres = new ManualResetEventSlim(true);
    var info = new ThreadInfo { Thread = thread, ProceedSignal = mres };
    threads.Add(index, info);
    // Change the button image here.
  }
  else
  {
    ThreadInfo info = threads[index];
    if (info.ProceedSignal.Wait(0))
    {
      // The event is signaled which means the thread is running. Pause it.
      info.ProceedSignal.Reset();
      // Change the button image here.
    }
    else
    {
      // The event is unsignaled which means the thread is paused. Resume it.
      info.ProceedSignal.Set();
      // Change the button image here.
    }
  }
}

private class ThreadInfo
{
  Thread Thread { get; set; }
  ManualResetEventSlim ProceedSignal { get; set; }
}

It is generally considered bad practice to Suspend threads (though it is possible). The right way to pause and terminate threads is through the cooperation with the job that the thread is doing. The job should check a variable in a loop, and pause or exit accordingly. The controlling program can set that variable, and if you need feedback the background thread can call a notification method before exiting or sleeping.