/// <summary>Empties the work queue of any queued work items.</summary>
public void EmptyQueue()
{
lock (workerQueue)
{
try
{
// Try to dispose of all remaining state
foreach (object obj in workerQueue)
{
WorkerCallback callback = (WorkerCallback)obj;
if (callback.State is IDisposable)
{
((IDisposable)callback.State).Dispose();
}
}
}
catch
{
// Make sure an error isn't thrown.
}
// Clear all waiting items and reset the number of worker threads currently needed
// to be 0 (there is nothing for threads to do)
workerQueue.Clear();
}
}
/// <summary>A thread worker function that processes items from the work queue.</summary>
private void ProcessQueuedItems()
{
// Process indefinitely
while (true)
{
// Get the next item in the queue. If there is nothing there, go to sleep
// for a while until we're woken up when a callback is waiting.
WorkerCallback callback = null;
while (callback == null)
{
// Try to get the next callback available. We need to lock on the
// queue in order to make our count check and retrieval atomic.
lock (workerQueue)
{
if (workerQueue.Count > 0)
{
try
{
callback = (WorkerCallback)workerQueue.Dequeue();
}
catch {} // make sure not to fail here
}
}
// If we can't get one, go to sleep.
if (callback == null)
{
if (stopThreads)
{
//Return from the method which will in turn stop the thread
return;
}
lock (waitCount)
{
waitCount.Value++;
}
//Wait until there is more work to be done;
workerThreadsSemaphore.WaitOne();
}
}
// We now have a callback. Execute it. Make sure to accurately
// record how many callbacks are currently executing.
try
{
callback.Callback(callback.State);
}
catch
{
// Make sure we don't throw here. Errors are not our problem.
}
}
}
private static void StartWorkerService()
{
Task.Factory.StartNew(() =>
{
var proc = StartWorkerProcess();
var pipeName = string.Format(PIPE_NAME_FORMAT, proc.Id);
var callback = new WorkerCallback();
var instanceContext = new InstanceContext(callback);
var channelFactory = new DuplexChannelFactory <IWorkerService>(instanceContext,
new NetNamedPipeBinding
{
SendTimeout = TimeSpan.FromHours(24),
MaxReceivedMessageSize = int.MaxValue
},
new EndpointAddress(pipeName));
var channel = channelFactory.CreateChannel();
_workerQueue.Add(new WorkerContext {
Service = channel, Callback = callback, Process = proc
});
});
}
/// <summary>Queues a user work item to the thread pool.</summary>
/// <param name="callback">
/// A WaitCallback representing the delegate to invoke when the thread in the
/// thread pool picks up the work item.
/// </param>
/// <param name="state">
/// The object that is passed to the delegate when serviced from the thread pool.
/// </param>
public void QueueUserWorkItem(WaitCallback callback, object state)
{
// Create a waiting callback that contains the delegate and its state.
// Add it to the processing queue, and signal that data is waiting.
WorkerCallback waiting = new WorkerCallback(callback, state);
lock (workerQueue)
{
workerQueue.Enqueue(waiting);
}
//Interlocked does not let us read the value of an int, so instead lets
//add 0 to the value to get the actual value of waitingThreads
lock (waitCount)
{
if (waitCount.Value > 0)
{
//Only call release if we still have waiting threads, otherwise an exception will be
//thrown by the semaphore.
waitCount.Value--;
workerThreadsSemaphore.Release(1);
}
}
}
public RestoreThemeListsWorker(TmTreeNode treeNode, WorkerCallback func)
{
_node = treeNode;
_func = func;
}
public MDLCallback(WorkerCallback callback, T[] objects_array, uint size)
{
objects = objects_array;
_callback = callback;
objects_size = size;
}
public bool ExecuteUnmanaged()
{
Callback = new WorkerCallback(WorkerCallbackHandler);
return Execute(Callback, "Pass an String");
}
public static extern bool Execute(WorkerCallback callback, string name);
/// <summary>Queues a user work item to the thread pool.</summary>
/// <param name="callback">
/// A WaitCallback representing the delegate to invoke when the thread in the
/// thread pool picks up the work item.
/// </param>
/// <param name="state">
/// The object that is passed to the delegate when serviced from the thread pool.
/// </param>
public void QueueUserWorkItem(WaitCallback callback, object state)
{
// Create a waiting callback that contains the delegate and its state.
// Add it to the processing queue, and signal that data is waiting.
WorkerCallback waiting = new WorkerCallback(callback, state);
lock (workerQueue)
{
workerQueue.Enqueue(waiting);
}
//Interlocked does not let us read the value of an int, so instead lets
//add 0 to the value to get the actual value of waitingThreads
lock (waitCount)
{
if (waitCount.Value > 0)
{
//Only call release if we still have waiting threads, otherwise an exception will be
//thrown by the semaphore.
waitCount.Value--;
workerThreadsSemaphore.Release(1);
}
}
}