Inheritance diagram for Deveel.Data.Diagnostics.ThreadedQueue< TMessage >:

Public Member Functions
void	Dispose ()

Public Attributes
const int	DefaultThreadCount = 2

Protected Member Functions
	ThreadedQueue ()

abstract void	Consume (TMessage message)

void	Enqueue (TMessage message)

virtual void	Dispose (bool disposing)

Properties
virtual int	ThreadCount `[get]`

Private Member Functions
	~ThreadedQueue ()

void	Start ()

void	Stop ()

void	RouteMessages ()

Private Attributes
readonly Queue< TMessage >	messageQueue

List< Thread >	threads

bool	started

bool	route

AutoResetEvent	reset

bool	disposed

Detailed Description

Type Constraints

TMessage

:

class

Definition at line 26 of file ThreadedQueue.cs.

Constructor & Destructor Documentation

Deveel.Data.Diagnostics.ThreadedQueue< TMessage >.ThreadedQueue ( )

inlineprotected

Definition at line 43 of file ThreadedQueue.cs.

                                   {
 #if PCL
             cancellationTokenSource = new CancellationTokenSource();
             cancellationToken = cancellationTokenSource.Token;
 #endif
 
             messageQueue = new Queue<TMessage>();
         }

Deveel.Data.Diagnostics.ThreadedQueue< TMessage >.~ThreadedQueue ( )

inlineprivate

Definition at line 52 of file ThreadedQueue.cs.

                          {
             Dispose(false);
         }

Member Function Documentation

abstract void Deveel.Data.Diagnostics.ThreadedQueue< TMessage >.Consume ( TMessage message )

protectedpure virtual

void Deveel.Data.Diagnostics.ThreadedQueue< TMessage >.Dispose ( )

inline

Definition at line 157 of file ThreadedQueue.cs.

                               {
             Dispose(true);
             GC.SuppressFinalize(this);
         }

virtual void Deveel.Data.Diagnostics.ThreadedQueue< TMessage >.Dispose ( bool disposing )

inlineprotectedvirtual

Reimplemented in Deveel.Data.Diagnostics.EventRegistry.

Definition at line 162 of file ThreadedQueue.cs.

                                                        {
             if (disposed) {
                 if (disposing) {
                     Stop();
                 }
 
 #if PCL
                 tasks = null;
 #else
                 threads = null;
 #endif
                 disposed = true;
             }
         }

void Deveel.Data.Diagnostics.ThreadedQueue< TMessage >.Enqueue ( TMessage message )

inlineprotected

Definition at line 144 of file ThreadedQueue.cs.

                                                  {
             Start();
 
             if (!route)
                 return;
 
             lock (((ICollection) messageQueue).SyncRoot) {
                 messageQueue.Enqueue(message);
             }
 
             reset.Set();
         }

void Deveel.Data.Diagnostics.ThreadedQueue< TMessage >.RouteMessages ( )

inlineprivate

Definition at line 128 of file ThreadedQueue.cs.

                                      {
             while (route) {
                 reset.WaitOne();
 
                 TMessage message;
 
                 lock (((ICollection) messageQueue).SyncRoot) {
                     message = messageQueue.Dequeue();
                 }
 
                 Consume(message);
             }
         }

void Deveel.Data.Diagnostics.ThreadedQueue< TMessage >.Start ( )

inlineprivate

Definition at line 60 of file ThreadedQueue.cs.

                              {
             if (started)
                 return;
 
 
 #if PCL
             tasks = new List<Task>();
 #else
             threads = new List<Thread>(ThreadCount);
 #endif
 
             for (int i = 0; i < ThreadCount; i++) {
 #if PCL
                 tasks.Add(new Task(RouteMessages, cancellationToken));
 #else
                 var thread = new Thread(RouteMessages) {
                     IsBackground = true,
                     Name = String.Format("{0}.QueueConsumer {1}", GetType().Name, i)
                 };
 
                 threads.Add(thread);
 #endif
             }
 
             route = true;
             reset = new AutoResetEvent(false);
 
 #if PCL
             foreach (var task in tasks) {
                 task.Start();
             }
 #else
             foreach (var thread in threads) {
                 thread.Start();
             }
 #endif
 
             started = true;
         }

void Deveel.Data.Diagnostics.ThreadedQueue< TMessage >.Stop ( )

inlineprivate

Definition at line 100 of file ThreadedQueue.cs.

                             {
             route = false;
 
             if (!started)
                 return;
 
 #if PCL
             cancellationTokenSource.Cancel(true);
 
             foreach (var task in tasks) {
                 try {
                     task.Wait(300);
                 } catch (TaskCanceledException) {
                 }
             }
 #else
             foreach (var thread in threads) {
                 try {
                     thread.Join(300);
                     thread.Interrupt();
                 } catch (ThreadInterruptedException) {
                 }
             }
 #endif
 
             started = false;
         }