Action queue in .NET 3.5

Question

Because I needed to execute some actions one by one in seperate thread (not to block GUI) and I couldn't use Task.ContinueWith from .NET 4.0 I decided to write it by myself.

Here is how it evolved thanks to your suggestions.

public class ActionQueue
{
    private Thread _thread;
    private bool _isProcessed = false;
    private object _queueSync = new object();
    private readonly Queue<Action> _actions = new Queue<Action>();
    private SynchronizationContext _context;

    /// <summary>
    /// Occurs when one of executed action throws unhandled exception.
    /// </summary>
    public event CrossThreadExceptionEventHandler ExceptionOccured;

    /// <summary>
    /// Occurs when all actions in queue are finished.
    /// </summary>
    public event EventHandler ProcessingFinished;

    /// <summary>
    /// Gets enqueued actions.
    /// </summary>
    public IEnumerable<Action> Actions
    {
        get
        {
            lock (_queueSync)
            {
                return new ReadOnlyCollection<Action>(_actions.ToList());
            }
        }
    }

    protected virtual void Execute()
    {
        _isProcessed = true;

        try
        {
            while (true)
            {
                Action action = null;

                lock (_queueSync)
                {
                    if (_actions.Count == 0)
                        break;
                    else
                        action = _actions.Dequeue();
                }

                action.Invoke();
            }

            if (ProcessingFinished != null)
            {
                _context.Send(s => ProcessingFinished(this, EventArgs.Empty), null);
            }
        }
        catch (ThreadAbortException)
        {
            // Execution aborted
        }
        catch (Exception ex)
        {
            if (ExceptionOccured != null)
            {
                _context.Send(s => ExceptionOccured(this, new CrossThreadExceptionEventArgs(ex)), null);
            }
        }
        finally
        {
            _isProcessed = false;
        }
    }

    /// <summary>
    /// Starts processing current queue.
    /// </summary>
    /// <returns>Returns true if execution was started.</returns>
    public virtual bool Process()
    {
        if (!_isProcessed)
        {
            _context = SynchronizationContext.Current;

            _thread = new Thread(Execute);
            _thread.Start();

            return true;
        }
        else
        {
            return false;
        }
    }

    /// <summary>
    /// Enqueues action to process.
    /// </summary>
    /// <param name="action">Action to enqueue.</param>
    public void Enqueue(Action action)
    {
        lock (_queueSync)
        {
            _actions.Enqueue(action);
        }
    }

    /// <summary>
    /// Clears queue.
    /// </summary>
    public void Clear()
    {
        lock (_queueSync)
        {
            _actions.Clear();
        }
    }

    /// <summary>
    /// Aborts execution of current queue.
    /// </summary>
    /// <returns>Returns true if execution was aborted.</returns>
    public bool Abort()
    {
        if (_isProcessed)
        {
            _thread.Abort();
            return true;
        }
        else
        {
            return false;
        }
    }
}

public delegate void CrossThreadExceptionEventHandler(object sender, CrossThreadExceptionEventArgs e);

public class CrossThreadExceptionEventArgs : EventArgs
{
    public CrossThreadExceptionEventArgs(Exception exception)
    {
        this.Exception = exception;
    }

    public Exception Exception
    {
        get;
        set;
    }
}

Here is some usage example:

ActionQueue queue = new ActionQueue();

queue.Enqueue(SomeMethod);
queue.Process();

foreach(var item in collection)
{
    var itemToProcess = item;
    queue.Enqueue(() => SomeMethod(itemToProcess));
}

queue.Process();

Edits:

• Implemented observable pattern
• Synchronization context added
• IsProcessed property removed

Answer 1

Since the class itself does very little (runs a bunch of methods on a separate thread), there is little justification in using it, IMHO.

This statement would basically do the same thing (on a ThreadPool, that is):

ThreadPool.QueueUserWorkItem(s =>
{
    SomeMethod();
    DoSomething();
    AndSomeMore();
});

If it included stuff like progress updating, exception handling and finalization events, then it could make more sense to use it:

interface IActionQueue
{
    void Start();

    // if you know the list count, you can provide some progress info
    event Action<Double> ProgressChanged;

    // there is no way to catch an exception on a separate thread, so 
    // this would be neat
    event Action<Exception> ExceptionHappened;

    // this can be useful also
    event Action Finished;
}

Answer 2

Your approach is not ThreadSafe, replace the Queue with ConcurrentQueue or add locking around all the Enqueue, Dequeue, and Count members. Also, I would avoid throwing an exception if the Queue is still processing. This condition is something that is largely a private concern of your class.

Answer 3

If you are using the ActionQueue simply for invoking a collection of actions one-by-one one another thread, then there isn't really much you can say over the implementation (other than the point already made by Groo).

However, if you wish to have this ActionQueue running on another thread, while accepting requests to queue another action to execute (so you can execute actions asynchronously), then you may wish to look into using a combination of Queue<Action>, a background worker thread and AutoResetEvent. I won't write the full implementation of that here, as I don't know if that is what you want, but if you do then I would be happy to edit this answer.

Answer 4

Don't expose your concrete lists:

public class ActionQueue
{
    private readonly IList<Action> actions = new List<Action>();

    public IEnumerable<Action> Actions
    {
        get
        {
            return new ReadOnlyCollection<Action>(actions);
        }
    }

    public void Add(Action action)
    {
        this.actions.Add(action);
    }

    protected virtual void Execute()
    {
        foreach (var action in this.actions)
        {
            action.Invoke();
        }
    }

    public virtual void Start()
    {
        var thread = new Thread(Execute);

        thread.Start();
    }
}