Question

I’m going to provide a simple example of what I’m trying to do — hopefully it is possible?

I basically have a class that does a whole ton of formatting/analyzing to the data. As a result, there a lot of things that can go wrong with this. The problem I have is handling the class when things go wrong. I want all execution of this class to stop once an error has occurred.

This class (AnalyzingStuff) is called from a parent form that does various things based on the result of this classes execution.

Ideally, I would fire an event named say “ABORT”.

So in this code here I do the following:

Class AnalyzingStuff{

public event EventHandler ABORT;

public AnalyzingStuff(){

    for(int i = 0; i < 999999; i ++){
        AnalyzeSomeStuff();
        AnalyzerSomeOtherStuff();
    }
    MoreStuff();
    OtherStuff();
}

private void AnalyzeSomeStuff(){
   if(someconditionNotMet){
        //EXIT OUT OF THIS CLASS, STOP EXECUTION!!!
        this.ABORT.Invoke(this, null);
   }
}
}

Calling this ‘ABORT’ event, I would stop the execution of this class (stop the loop and not do anything else). I could also catch this event handler in some other parent form. Unfortunately, I can’t find any way of stopping the execution of this class.

Ideas so far:

1. The obvious answer is to simply set a flag and constantly check this flag over and over in multiple places, but I really don’t like this approach (my current implementation). Having to check this after every single method call (there are MANY) is ugly codewise.

2. I thought maybe a background worker or something where you could cancel the execution of the DoWork?

3. Use a form as a base class for the AnalyzingStuff so I can simply call “this.Close();”.

What do you think is the best approach to this situation? Are these the best solutions? Are there any other elegant solutions to what I want here or am I going completely in the wrong direction?

EDIT: I have a series of try/catch blocks used throughout this code that is used to handle different errors that can occur. Unfortunately, not all of them call for an Abort to occur so they need to be caught immediately. Therefore, try/catch not the most ideal approach.. or is it?

Answer 1

Don’t do analysys in the constructor. Do it in a main Analyze() method.

Use exceptions. If you want to abort because of a fatal error, throw a fatal exception. That is, throw an exception that you don’t catch within the scope of the main analysis method.

class Analyzer
{
    public Analyzer()
    {
        // initialize things                
    }

    public void Analyze()
    {
        // never catch a fatal exception here
        try
        {
            AnalyzeStuff();
            ... optionally call more methods here ...
        }
        catch (NonFatalException e)
        {
            // handle non fatal exception
        }

        ... optionally call more methods (wrapped in try..catch) here ...
    }

    private void AnalyzeStuff()
    {
        // do stuff
        if (something nonfatal happens)
            throw new NonFatalException();

        if (something fatal happens)
            throw new FatalException();
    }
}

outside:

{
    var analyzer = new Analyzer();
    try
    {
        analyzer.Analyze();
    }
    catch (FatalException)
    {
        Console.WriteLine("Analysis failed");
    }
}

If you don’t like using exception this way, you can accomplish the same thing by having every analysis method return a bool:

if (!AnalyzeStuff())
    return false;
if (!AnalyzeMoreStuff())
    return false;
...
return true;

But you end up with a lot of return statements or a lot of braces. It’s a matter of style and preference.