Question

I want my program to continuously wait for a trigger in order to perform the next task.

1. One option is pooling: using an infinite loop e.g. while(true)
2. OR, Do TCP listen on a port with a relatively higher timeout.

I would like to know which one of these two techniques would be more efficient too keep my application alive?

I feel executing while(true) would be a killer and tcp listen might be a health option since the tcp listen would use hardware interrupt ?

Also, In .net winform applications we have the Application.Run() method that keeps the application alive. If anyone one knows what this method does internally pls share.

PS: I have already considered msmq option here ( which is equivalent to tcp listen ) but I do not want a dependency on msmq.

Answer 1

Unless you’re actually waiting for something to happen on a TCP/IP port, you shouldn’t (ab)use Listen.

An efficient method isAutoResetEvent that you signal when you want to trigger the processing of a task. This will make your thread sleep until it needs to do something, without any polling.

class TaskProcessor
{
    AutoResetEvent newTaskHandle = new AutoResetEvent(false);
    Queue<Task> taskQueue = new Queue<Task>();
    object syncRoot = new object();

    public void ProcessTasks()
    {
        while (true)
        {
            newTaskHandle.WaitOne();

            Task task = null;

            lock (syncRoot)
            {
                if (taskQueue.Count > 0)
                {
                    task = taskQueue.Dequeue();
                }
            }

            // Do task
        }
    }

    public void AddTask(Task task)
    {
        lock (syncRoot)
        {
            taskQueue.Enqueue(task);
            newTaskHandle.Set();
        }
    }
}

This will probably raise the question how you can abort processing tasks. You can use more than a single WaitHandler (from which AutoResetEvent inherits) and wait for any of them to occur:

WaitHandle[] handles = new WaitHandle[] { newTaskHandle, stopHandle };

int signalledHandle = WaitHandle.WaitAny(handles);

Alternatively, you could introduce a simple boolean and reuse the same event. That might actually be preferrable if you want to make sure all tasks are processed before stopping.