How do I add an item to the front of the queue?

I'm creating a Windows service that makes use of a FileSystemWatcher to monitor a particular folder for additions of a particular file type. Due the gap between the Created event and when the file is actually ready to be manipulated, I created a Queue<T> to hold the file names that need processing. In the Created event handler, the item is added to the queue. Then using a timer, I periodically grab the first item from the queue and process it. If the processing fails, the item is added back to the queue so the service can retry processing it later.

This works fine but I've found it has one side-effect: the first processing attempt for new items does not happen until all the old retry items have been retried. Since it's possible the queue could contain many items, I'd like to force the new items to the front of the queue so they are processed first. But from the Queue<T> documentation, there is no obvious way of adding an it开发者_运维问答em to the front of the queue.

I suppose I could create a second queue for new items and process that one preferentially but having a single queue seems simpler.

So is there an easy way to add an item to the front of the queue?

---

It kind of looks like you want a LinkedList<T>, which allows you to do things like AddFirst(), AddLast(), RemoveFirst(), and RemoveLast().

---

Simply use the Peek method in your timer callback instead of Dequeue. If processing succeeds, then dequeue the item.

---

Well, I agree with CanSpice; however, you could:

var items = queue.ToArray();
queue.Clear();
queue.Enqueue(newFirstItem);
foreach(var item in items)
    queue.Enqueue(item);

Nasty hack, but it will work ;)

Rather you might think about adding a second queue instance. This one being the 'priority' queue that you check/execute first. This would be a little cleaner. You might even create your own queue class to wrap it all up nice and neat like ;)

---

Do not take from the queue until you processed it, is an alternative solution.

Use queue.Peek() to get your first item and only Dequeue() when the operation succeeds.

Use queue.Count > 0 before you Peek(), else you will get the 'queue is empty' result.

---

I would suggest using two queues: one for new items, and one for retry items. Wrap both queues in a single object that has the same semantics as a queue as far as removal goes, but allows you to flag things as going into the New queue or the Retry queue on insert. Something like:

public class DoubleQueue<T>
{
    private Queue<T> NewItems = new Queue<T>();
    private Queue<T> RetryItems = new Queue<T>();

    public Enqueue(T item, bool isNew)
    {
        if (isNew)
            NewItems.Enqueue(item);
        else
            RetryItems.Enqueue(item);
    }

    public T Dequeue()
    {
        if (NewItems.Count > 0)
            return NewItems.Dequeue();
        else
            return RetryItems.Dequeue();
    }
}

Of course, you'll need to have a Count property that returns the number of items in both queues.

If you have more than two types of items, then it's time to upgrade to a priority queue.

---

Sounds like what you're after is a Stack - This is a LIFO (Last in, first out) buffer.

---

You need a Priority Queue. Take a look at the C5 Collections Library. It's IntervalHeap implements the IPriorityQueue interface. The C5 collections library is pretty good, too.

I believe you can find implementations at http://www.codeproject.com and http://www.codeplex.com as well.