Question

In it’s simplicity what I am trying to do is handle “Doing Something” by firing off a process on a seperate thread to do what I need to do and waiting for an event to be raised to say “I have finished doing what I need to do”. In the EventArgs though I will have a property for any errors which may be encountered during the process. Here is a simplified example of my situation.

public class MessageHandler
{
  private AutoResetEvent MessageHasSent = new AutoResetEvent(false);
  public void SendMessage()
  {
    MessageSender ms = new MessageSender();
    ms.MessageSent += new EventHandler<MessageSentEventArgs>(MessageHandler_MessageSent);

    Thread t = new Thread(ms.Send());
    t.Start();

    MessageHasSent.WaitOne();
    //Do some check here

    //Same again but for "Message recieved"
  }
  void MessageHandler_MessageSent(object sender, MessageSentEventArgs e)
  {
    if (e.Errors.Count != 0)
    {
      //What can I do here to return to the next step after waitone?
    }
    else
      MessageHasSent.Set();
  }
}
public class MessageSender
{
  public event EventHandler<MessageSentEventArgs> MessageSent;
  public void Send()
  {
    //Do some method which could potentiallialy return a List<Error>
    MessageSent(this, new MessageSentEventArgs() { Errors = new List<Error>() });
  }
}
public class Error { }
public class MessageSentEventArgs : EventArgs
{
  public List<Error> Errors;
}

Essentially once the event has been raised from Send the code will continute, however I want some way of the event giving feedback, potentially using the MessageHasSent. I have tried different methods, I thought if I called Close instead of Set it would perhaps allow me to access something such as IsClosed. You could throw an exception or set a flag outside of the scope of the event to check but I feel like this is dirty.

Any suggestions?

Using the TPL isn’t applicable in my case as I am using .NET 3.5.

Answer 1

Since it seems that this entire section of code is already running in a background thread, and you’re doing nothing more than starting up a new thread just so that you can wait for it to finish, you’d be better off just calling Send directly, rather than asynchronously.

• You don’t need to fire off an event when you’re completed.

• You don’t need to signal the main thread when it needs to continue.

• You don’t need to log the exceptions in a List, you can just throw them and catch them in SendMessage with a try/catch block.