Stop execution of a method c#

Question

How can I able to stop the execution of my method when I click a button?

  public void ForEach()
    {
        CreateFolders();

        //For each process get the equivalent processcode
        foreach (string item in Processes)
        {
            ItemValue = item;
            //Get process code for the process under the selected source
            GetActiveProcess();

            #region Switch
            switch (ProcessCode)
            {
                #region DownloadFile
                case "Download File":
                    ForDownloadFile();
                    break;
                #endregion

                #region UnzipFile
                case "Unzip File":
                    ForUnzipFile();

                    break;
                #endregion

                #region RenameFile
                case "Rename File":
                    ForRenameFile();
                    break;
                #endregion

                #region MergeFile
                case "Merge File":
                    ForMergeFile();
                    break;
                #endregion

                #region ZipFile
                case "Zip File":
                    ForZipFile();
                    break;
                #endregion

                #region UploadFile
                case "Upload File":
                    ForUploadFile();
                    break;
                #endregion
            }
            #endregion

        }


    }

How can I end my public void foreach when I click the stop button. I would like to stop the downloading, or extracting of file etc when ever I click on stop without closing my application.

I've tried using return but it continues to execute (Download/ extract etc).

@Dan Puzey, I've tried using return but It continues executing. It continues downloading, or extracting etc — , Aug 06 '14 at 09:38
How have you "tried using return?" If it continues processing then I suspect that the implementation of your methods (`ForZipFile`, `ForMergeFile`, etc) are the culprit, in which case you'd need to share that code too. — Dan Puzey, Aug 06 '14 at 13:12
@DanPuzey, so you mean I should stop each method in switch (ForZipFile,ForMergeFile etc.)? — , Aug 07 '14 at 02:04
@DanPuzey, I've solved it by assigning a boolean cancel once it became true then it will return. I put it in all my methods (ForZipFile,ForMergeFile, etc.) — , Aug 07 '14 at 03:35
@MisakiSuzuhara Then use CancelAsync() method and check for CancellationPending worker's property to exit — Blau, Aug 07 '14 at 10:48
@Blau, I've used it but it didn't stop all my methods in executing. — , Aug 08 '14 at 00:22
@MisakiSuzuhara Using worker in your methods lets you check cancellation, but also notify progress too in a safer way, without needing extra properties. ;) — Blau, Aug 08 '14 at 01:29

score 2 · Answer 1 · edited May 23 '17 at 10:33

2

you cant stop execution of a single method. you can use it by using threads . Use a new thread to run the method and on button click signal the thread to stop . look at this thread - C# Threading - How to start and stop a thread http://msdn.microsoft.com/en-us/library/7a2f3ay4(v=vs.90).aspx

edited May 23 '17 at 10:33

Community

1
1

answered Aug 06 '14 at 09:42

Rabi

2,210
17
18

score 0 · Answer 2 · answered Aug 06 '14 at 09:55

Stopping your ForEach() should be easy, but stopping each method you have defined per Case depends on what you're doing in that case.

// Defined somewhere which is available to you ForEach() and your Stop button.
// In the stop button set the KeepProcessing to false.
bool KeepProcessing = true;   

foreach (string item in Processes)
{
    if(!KeepProcessing)
         return;

    switch(.....
}

score 0 · Accepted Answer · answered Aug 06 '14 at 10:02

The quick and dirty solution could be to introduce a test for a variable, and set this variable by pressing the stop button. Please note that this will only work for a WinForm application, for a WPF application, you would need to import system.windows.forms.dll - effectively making it non-wpf.

For example:

bool stop = false;

foreach (string item in Processes)
{
    if (stop)
        break;

    //do-your-stuff

    Application.DoEvents(); //this will force the winform app to handle events from the GUI
}

//Add an eventhandler to your stop-button
private void stopButton_Click(System.Object sender, System.EventArgs e)
{
    stop = true;
}

But, as suggested by Rabi, it would be much better to introduce some threading to your application. For WPF, a Dispatcher would do wonders. Please see http://msdn.microsoft.com/en-us/magazine/cc163328.aspx.

Thanks for the Idea. I've solved my problem by using a boolean cancel wherein when it became true then it will return. I've use if(cancel == true) return; in every method insde my foreach() method. When I click stop button it will make my cancel true. Thanks. — , Aug 07 '14 at 06:24
simply use if (cancelled) . if (cancel == true) looks like crummy coding practice :) — Rabi, Aug 07 '14 at 06:50

score 0 · Answer 4 · answered Aug 06 '14 at 10:14

The most canonical technique for cancelling execution of a worker thread is a pattern called Cooperative Cancellation. MSDN has a nice article on it. Note that this relates to using Task based asynchronous programming.

The gist is similar to this:

public void DoWork(IEnumerable<Work> workItems, ref bool cancel)
{
    foreach(thing in workItems)
    {
        //poll to see if you need to abandon the work.
        if(cancel)
            throw new WorkCancelledException(); //or whatever exception you want to use. MSDN shows you a built in one.

        ProcessThing(thing); //process the item. An item is just a unit of work. You dont have to use a collection of work items.
    }
}

When your cancel button is pressed, set the cancel boolean. The MSDN example uses a CancellationToken and i would recommend it. It is not limited to Task implementations.

Why is it cooperative? Both the consuming code and the executing code have to agree on the method of cancellation and agree to cancel the operation when the cancel is true.

score 0 · Answer 5 · edited May 23 '17 at 12:18

I'm not used to Wpf, but I think that using a BackGroundWorker is a right solution if you need to use a thread.

https://stackoverflow.com/a/5483644/906404

private readonly BackgroundWorker worker = new BackgroundWorker();

// Initialization code
worker.DoWork += worker_DoWork;
worker.WorkerSupportsCancellation = true;
worker.RunWorkerAsync();          // Runs your code in a background thread

private void worker_DoWork(object sender, DoWorkEventArgs e)  
{
    CreateFolders();

    //For each process get the equivalent processcode
    foreach (string item in Processes)
    {

   -->> if (worker.CancellationPending) break;

        ItemValue = item;
        //Get process code for the process under the selected source
        GetActiveProcess();


        ... your code... 

    }
}

void OnClickStopButton(args) {
   worker.CancelAsync();
}

Stop execution of a method c#

5 Answers5