How to suspend a thread by another thread in C#?

Question

Sorry for my bad English. Hope someone suggests me a better version of my question.

I've searched but seemed like I couldn't find the answer for my problem.

Currently, I'm writing a C# WPF app. This app will perform a heavy task in a long time. So I've decided to create another class with that heavy method and pass that method to another thread. I have to create a class to do that because the heavy method takes parameters.

I want the ability to suspend and resume that thread. I've known that I should use a ManualResetEvent object or Thread.Sleep method.

After many hours of trying and testing, getting confused why I always end up suspend the UI thread but the heavy thread is still running. What I've tried were:

1. Create a ManualResetEvent object called mre inside the HeavyClass. When user click the Pause button, the UI class will call the method heavyClass.mre.WaitOne().

   class HeavyClass
   {
       // properties
       ManualResetEvent mre = new ManualResetEvent(false);
   
       public void HeavyRun()
       {
   
           //Do something takes really long time
           //And doesn't have any loops
       }
   }
   
   class MainWindow : Window
   {
       // properties
       private HeavyClass heavyClass = new HeavyClass();
   
       private void buttonStart_Click(object sender, RoutedEventArgs e)
       {
           Thread t = new Thread(heavyClass.HeavyRun);
           t.Start();
       }
   
       private void buttonPause_Click(object sender, RoutedEventArgs e)
       {
           heavyClass.mre.WaitOne();
       }
   }
   

2. Create a method called SleepThread inside the HeavyClass. When user click the Pause button, the UI class will call the method heavyClass.SleepThread().

   class HeavyClass
   {
       //properties
       ManualResetEvent mre = new ManualResetEvent(false);
   
       public void SleepThread()
       {
           Thread.Sleep(Timeout.Infinite);
           //mre.WaitOne();
           //They are the same behavior
       }
   
       public void HeavyRun()
       {
           //Do something takes really long time
           //And doesn't have any loops
       }
   }
   
   class MainWindow : Window
   {
       // properties
       private HeavyClass heavyClass = new HeavyClass();
   
       private void buttonStart_Click(object sender, RoutedEventArgs e)
       {
           Thread t = new Thread(heavyClass.HeavyRun);
           t.Start();
       }
   
       private void buttonPause_Click(object sender, RoutedEventArgs e)
       {
           heavyClass.SleepThread();
       }
   }
   

3. Create an EventHandler<MainWindow> PauseThread inside the UI class, then write its handle inside the HeavyClass. When user click the Pause button, the UI class will trigger the event PauseThread(this, this).

   class MainWindow : Window
   {
       // properties
       private HeavyClass heavyClass = new HeavyClass();
       public event EventHandler<MainWindow> PauseThread;
   
       private void buttonStart_Click(object sender, RoutedEventArgs e)
       {
           Thread t = new Thread(heavyClass.HeavyRun);
           t.Start();
       }
   
       private void buttonPause_Click(object sender, RoutedEventArgs e)
       {
           PauseThread(this, this);
       }
   }
   
   class HeavyClass
   {
       // properties
       ManualResetEvent mre = new ManualResetEvent(false);
   
       public void HeavyRun()
       {
           MainWindow.PauseThread += (s, E) => 
           {
               Thread.Sleep(Timeout.Infinite);
               //mre.WaitOne();
               //They are the same behavior
           };
           //Do something takes really long time
           //And doesn't have any loops
       }
   }
   

As I said above, I always paused the UI thread and the heavy task is still running.

And finally in the end, I've known the essence of my problem. That is: which thread calls Thread.Sleep() or WaitOne() will be blocked. Yeah, "which thread", not "which class".

Everything makes sense for me now. But that doesn't help me to achieve my goal. And that leads me to think that I am doing the seemingly impossible thing. It's clearly that I want to pause a thread by another thread. But that another thread is the one who calls any kinds of "suspend thread", so it is the one who is suspended. I don't have any idea about how to make the heavy method to be suspended by itself. It is running, how the hell it could know when the user click the Pause button?

I am at a total loss. Someone please help me to make my app works as expected.

By the way, this impossible thing makes me think that I am doing things wrong way, is it?

UPDATE: If you like to see my heavy task, actually it is very simple

    class HeavyClass
    {
        public string filePath = "D:\\Desktop\\bigfile.iso";//This file is about 10GB

        public string HeavyRun()
        {
            string MD5Hash;
            MD5 md5 = MD5.Create();
            Stream stream = File.OpenRead(filePath);
            MD5Hash = Encoding.Default.GetString(md5.ComputeHash(stream));
            return MD5Hash;
        }
    }

Answer 1

To make a thread suspendable, the work in the thread must be separable. In your case md5.ComputeHash(stream) will do all the work, and there is not way to make sure that thread will suspend at a right(saft) point inside md5.ComputeHash(stream). So you have to rewrite HeavyClass like below. Please notice that those codes are not the best approach of handling a thread, and I just try to keep it as same as the original.

class HeavyClass
{
    MD5 _md5 = MD5.Create();
    MethodInfo _hashCoreMI = _md5.GetType().GetMethod("HashCore", BindingFlags.NonPublic | BindingFlags.Instance);
    MethodInfo _HashFinalMI = _md5.GetType().GetMethod("HashFinal", BindingFlags.NonPublic | BindingFlags.Instance);
    WaitHandle _signal;

    public void HeavyClass(WaitHandle signal)
    {
        _signal = signal;
    }

    public string HeavyRun(string filename)
    {
        byte[] buffer = new byte[4096];
        int bytesRead = 0;
        _signal.Set();

        using(FileStream fs = File.OpenRead(filename))
        {
            while(true)
            {
                bytesRead = fs.Read(buffer, 0, 4096);
                if (bytesRead > 0)
                {
                    _hashCoreMI.Invoke(_md5, new object[] { buffer, 0, bytesRead });
                }
                else
                {
                    break;
                }

                // if WaitHandle is signalled, thread will be block,
                // otherwise thread will keep running.
                _signal.WaitOne();
            }
        }

        byte[] hash = _hashFinalMI.Invoke(_md5, null);
        _md5.Initialize();

        return Encoding.ASCII.GetString(hash);;
    }
}

class MainWindow : Window
{
    private HeavyClass _heavyClass;
    private ManualResetEvent _mre;

    public MainWindow()
    {
        InitializeComponent();

        _mre = new ManualResetEvent(true);
        _heavyClass = new HeavyClass(_mer);
    }

    private void buttonStart_Click(object sender, RoutedEventArgs e)
    {
        Thread t = new Thread(heavyClass.HeavyRun("D:\\Desktop\\bigfile.iso"));
        t.Start();
    }

    private void buttonPause_Click(object sender, RoutedEventArgs e)
    {
        _mre.Reset();
    }

    private void buttonResume_Click(object sender, RoutedEventArgs e)
    {
        _mre.Set();
    }
}