Is there a way to await a flag change in a function?

Question

I've attempted to make a simple step mode for an algorithm I'm running, and here is how it looks like:

    public async Task<bool> AStarAlgorithmAsync(PFSquare curr = null)
    {
        // some algorithm code here
        foreach(var square in Sorroundings)
        {
            if (SteppedMode)
            {
                await Task.Run(Pause);
            }
            if (await AStarAlgorithmAsync(square))
            {
                return true;
            }
        }
    }

In my application, I have a Boolean called SteppedMode that decides if the algorithm should run one iteration per click event.

Pause() looks like this:

    private void Pause()
    {
        while (!ContinueStep) { }
        ContinueStep = false;
        return;
    }

And in another part of my (GUI) application I have an event which sets the boolean ContinueStep to true which in theory should end the while loop and continue the algorithm function. Currently this bit of code locks my GUI thread up and I'm almost certain there is a better way to do this.

I'm trying to get my algorithm function to run one iteration, wait for a click from the user and only then continue running the algorithm. Is there an easier and cleaner way to do this?

(This is a GUI application, not a console application.)

Answer 1

Your property is moonlighting as a method.

It makes no sense to set a property, to then have that property revert back to its original state immediately. As a consumer, I would be majorly confused by that behavior. Think about this code:

var myObj = new MyObject();

myObj.MyBoolean = true;

Console.WriteLine(myObj.MyBoolean); // FALSE!?

It just doesn't make sense.

The only effect you want to trigger by setting this property is to execute some code. That's exactly what methods are supposed to be used for:

public void ContinueStep()
{
    Console.WriteLine("I did some work");
}

So instead of this:

myObj.ContinueStep = true;

you should be doing this:

myObject.ContinueStep();

This doesn't lock up your UI thread, while also being a lot more sensical to your consumer. The method suggests that some action will be taken (which may or may not lead to state changes in the object - that's a contextual expectation).

---

Infinite recursion

As an aside; based on your code, AStarAlgorithmAsync is a recursive function, and seemingly infinitely so. There doesn't seem to be an ending condition.
Every recursive level will interate over the first surrounding and then trigger the next level, which again will interate over the first surrounding and then trigger the next level, which again ...

That can't be right, but it's unclear to me how to fix it as the bigger picture is not explained in your question

---

A simple implementation

What I'm trying to do is get my algorithm function to run one iteration, wait for a click from the user and only then continue running the algorithm, is there an easier and cleaner way to do this?

A simple example of such a thing:

private int _index = 0;

private List<object> _myList = ...; // assume this list contains some elements

public void ProcessNextObject()
{
    if(_index < _myList.Length)
    {
        Process(_myList[_index]);
        _index++;
    }
}

private void Process(object o)
{
    Console.WriteLine("Processing this object!");
}

You can then hook up your click event to call ProcessNextObject().

Note that in this example, the list is processed once and cannot be processed again. By manipulating the index value, you can change that behavior as you like.