Is it possible to show a wait message while a semaphore is locked in C#?

Question

I'm currently making a program to simulate a set of ATMs in visual C#. It's supposed to stop somebody accessing their account if it has already been accessed from a different location. Is it possible to show a message that the account has already been accessed while a semaphore is waiting?

Here is the part of the code where the semaphore is used:

private void button1_Click(object sender, EventArgs e)
        {
            count++;
            if (count == 1)
            {
                account = findAccount();
                if (findAccount() != 5)
                {
                    textBox1.Text = "Please Enter Your Pin";

                }
                else
                {
                    textBox1.Text = "Please Enter Your Account Number";
                    count = 0;
                }
                textBox2.Clear();
            }
            if (count == 2)
            {
                if (findPin(account) == true)
                {
                    semaphore.WaitOne();
                    textBox1.Text = "1: Take Out Cash \r\n2: Balance \r\n3: Exit";
                }
                else
                {
                    semaphore.Release();
                    textBox1.Text = "Please Enter Your Account Number";
                    count = 0;
                }
                textBox2.Clear();
            }
            if (count == 3)
            {
                atm();
            }
            if (count == 4)
            {
                withdraw();
            }
            if (count == 5)
            {
                int value = Convert.ToInt32(textBox2.Text);
                customWithdrawl(value);
            }

        }

Answer 1

Consider doing two calls to WaitOne. The first call will have a timeout of zero and return a bool that will tell you whether or not you got the semaphore, or someone else still owns it. Two things can happen from there:

1) If someone else owns it, pop up a message that says "Someone else owns the semaphore" and call WaitOne again, but without a timeout (like you're doing now). After the 2nd call to WaitOne returns, close the window that you popped up a second ago..

2) If your call to waitOne with 0 timeout returns true, then you got the semaphore on the 1st try. No need to pop up a window.

Example:

if( semaphore.WaitOne(0) ) //This returns immediately
{
    //We own the semaphore now.
    DoWhateverYouNeedToDo();
}
else
{   
    //Looks like someone else already owns the semaphore.
    PopUpNotification();
    semaphore.WaitOne(); //This one will block until the semaphore is available
    DoWhateverYouNeedToDo();
    CloseNotification();
}

semaphore.Release();

Note, there are some other issues lurking here.

1. You probably want to use a try/finally block to release the semaphore to ensure that it gets released across all exception paths.
2. It's also probably a bad idea to call semaphore.WaitOne() from the GUI thread because the application will become non-responsive while it waits. In fact, you may not see the result of PopUpNotification() if you've hung the GUI thread while doing the 2nd Wait. Consider doing the long wait on a 2nd thread and raising an event back on the GUI thread once you own the semaphore

Consider the following design to resolve Issue 2:

private void button1_Click(object sender, EventArgs e)
{
    if(AcquireSemaphoreAndGenerateCallback())
    {
        //Semaphore was acquired right away.  Go ahead and do whatever we need to do
        DoWhateverYouNeedToDo();
        semaphore.Release()
    }
    else
    {
        //Semaphore was not acquired right away.  Callback will occur in a bit
        //Because we're not blocking the GUI thread, this text will appear right away
        textBox1.Text = "Waiting on the Semaphore!";

        //Notice that the method returns right here, so the GUI will be able to redraw itself
    }
}

//This method will either acquire the semaphore right away and return true, or
//have a worker thread wait on the semaphore and return false.  In the 2nd case,
//"CallbackMethod" will run on the GUI thread once the semaphore has been acquired
private void AcquireSemaphoreAndGenerateCallback()
{
    if( semaphore.WaitOne(0) ) //This returns immediately
    {
        return true; //We have the semaphore and didn't have to wait!
    }
    else
    {
        ThreadPool.QueueUserWorkItem(new WaitCallback(Waiter));
        return false; //Indicate that we didn't acquire right away
    }
}

//Wait on the semaphore and invoke "CallbackMethod" once we own it.  This method
//is meant to run on a background thread.
private void Waiter(object unused)
{
    //This is running on a separate thread
    Semaphore.WaitOne(); //Could take a while

    //Because we're running on a separate thread, we need to use "BeginInvoke" so
    //that the method we're calling runs on the GUI thread
    this.BeginInvoke(new Action(CallbackMethod));
}

private void CallbackMethod()
{
    textBox1.Text = string.Empty; //Get rid of the "Waiting For Semaphore" text.  Can't do this if we're not running on the GUI thread
    DoWhateverYouNeedToDo();
    semaphore.Release();
}

Now, this solution could also be fraught with peril. It's kind of hard to follow the execution of the program because it jumps around from method to method. If you have an exception, it could be difficult to recover from and make sure all of your program state is correct. You also have to keep track of things like the account number and the pin numbers through all of these method calls. In order to do that, Waiter and CallbackMethod should probably take some parameter that tracks this state that gets passed along to each step. There's also no way to abort waiting (a time out). It will probably work, but shouldn't make it into any production code because it would be too difficult to maintain or extend.

If you really wanted to do it right, you should consider encapsulating the ATM logic in an object that will raise events that the GUI can subscribe to. You could have a method like ATM.LogInAsync(Account,Pin) that you could call. This method would return immediately, but some time later, an event on the ATM class like "LogInComplete" would fire. This event would have a custom EventArgs object that would contain data to trace which log-in has occurred (mainly the Account number). This is called the Event-based Asynchronous Pattern

Alternatively, if you're using C# 5.0, you can use the new Async/Await syntax in the AcquireSemaphoreAndGenerateCallback() method. That's probably the easiest way because the compiler will handle most of the complexities for you

Answer 2

Yes, you may show your message/form/messagebox right before the Wait method. Then when it receives the signal to unblock, you hide your message.