View difference between Paste ID: jqYbR9PS and B9DHsR02

 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Threading;
 using System.Windows.Threading;
 
 namespace TestingConsoleApplication.Tests.ThreadedQueue
 {
     class ThreadedQueueTest
     {
         public ThreadedQueueTest()
         {
             Debug.WriteLine("App Thread ID: " + System.Threading.Thread.CurrentThread.ManagedThreadId);
 
-            TaskQueue TaskQueue = new TaskQueue();
+            TaskQueue taskQueue = new TaskQueue();
-            QueueManager QueueManager = new QueueManager(TaskQueue);
+            QueueManager queueManager = new QueueManager(taskQueue);
 
             // inter thread exchanger object
-            InterThreadExchanger Exchanger = new InterThreadExchanger();
+            InterThreadExchanger exchanger = new InterThreadExchanger();
-            Exchanger.TaskQueue = TaskQueue;
+            exchanger.TaskQueue = taskQueue;
 
             // create queue listening thread
-            Thread ProcessingThread = new Thread(new Processor().ProcessingThreadBody);
+            Thread processingThread = new Thread(new Processor().ProcessingThreadBody);
-            ProcessingThread.Start(Exchanger);
+            processingThread.Start(exchanger);
 
             // Create an inferred delegate that invokes methods for the timer.
-            TimerCallback tcb = QueueManager.AddTask;
+            TimerCallback tcb = queueManager.AddTask;
 
             Timer stateTimer = new Timer(tcb, null, 1000, 1000);
             Console.ReadLine();
 
             stateTimer.Change(0, 0);
 
-            Console.WriteLine("Final task queue status: " + TaskQueue.Count.ToString());
+            Console.WriteLine("Final task queue status: " + taskQueue.Count.ToString());
             Debug.WriteLine("App Thread ID on end: " + System.Threading.Thread.CurrentThread.ManagedThreadId);
 
             Console.ReadLine();
         }
     }
 
     /// <summary>
     /// Processing thread working object
     /// </summary>
     class Processor
     {
-        private InterThreadExchanger Exchanger;
+        InterThreadExchanger exchanger;
-        private Dispatcher ProcessorDispatcher;
+        Dispatcher processorDispatcher;
 
         /// <summary>
         /// Processing thread main method
         /// </summary>
-        public void ProcessingThreadBody(object exchanger)
+        public void ProcessingThreadBody(object interThreadExchanger)
         {
-            ProcessorDispatcher = Dispatcher.CurrentDispatcher;
+            processorDispatcher = Dispatcher.CurrentDispatcher;
-            Exchanger = (InterThreadExchanger)exchanger;
+            exchanger = (InterThreadExchanger)interThreadExchanger;
-            Exchanger.TaskQueue.Filled += new TaskQueue.TaskQueueEventHandler(OnTaskQueueFilled);
+            exchanger.TaskQueue.Filled += new TaskQueue.TaskQueueFilledEventHandler(OnTaskQueueFilled);
 
             Debug.WriteLine("Processor Thread ID: " + System.Threading.Thread.CurrentThread.ManagedThreadId.ToString());
-            Debug.WriteLine("Processor Dispatcher Thread ID: " + ProcessorDispatcher.Thread.ManagedThreadId.ToString());
+            Debug.WriteLine("Processor Dispatcher Thread ID: " + processorDispatcher.Thread.ManagedThreadId.ToString());
-            Debug.Assert(ProcessorDispatcher.Thread.ManagedThreadId == System.Threading.Thread.CurrentThread.ManagedThreadId, "Processor thread ID and its dispatcher thread ID are not equal!");
+            Debug.Assert(processorDispatcher.Thread.ManagedThreadId == System.Threading.Thread.CurrentThread.ManagedThreadId, "Processor thread ID and its dispatcher thread ID are not equal!");
         }
 
         /// <summary>
         /// Queue filled event listener
         /// </summary>
         /// <param name="sender"></param>
         /// <param name="args"></param>
-        private void OnTaskQueueFilled(object sender, EventArgs args)
+        void OnTaskQueueFilled(object sender, EventArgs args)
         {
             Debug.WriteLine("Processor QueueListener caller Thread ID: " + System.Threading.Thread.CurrentThread.ManagedThreadId);
-            Debug.WriteLine("Processor Dispatcher Thread ID: " + ProcessorDispatcher.Thread.ManagedThreadId.ToString());
+            Debug.WriteLine("Processor Dispatcher Thread ID: " + processorDispatcher.Thread.ManagedThreadId.ToString());
 
-            if (ProcessorDispatcher.CheckAccess())
+            if (processorDispatcher.CheckAccess())
             {
                 Debug.WriteLine("Processor calling ProcessQueue.");
                 ProcessQueue();
             }
             else
             {
                 Debug.WriteLine("Processor invoking ProcessQueue.");
-                ProcessorDispatcher.BeginInvoke(new Action(ProcessQueue), new object[] {null});
+                processorDispatcher.BeginInvoke(new Action(ProcessQueue), new object[] {null});
                 Debug.WriteLine("Processor invoked ProcessQueue.");
             }
         }
 
-        private void ProcessQueue()
+        void ProcessQueue()
         {
             Debug.WriteLine("ProcessQueue Thread ID: " + System.Threading.Thread.CurrentThread.ManagedThreadId);
 
-            foreach (string Task in Exchanger.TaskQueue)
+            foreach (string Task in exchanger.TaskQueue)
             {
                 Console.WriteLine("Task in queue: " + Task);
 
                 // todo: process task
 
-                lock (Exchanger.TaskQueue)
+                lock (exchanger.TaskQueue)
                 {
-                    Exchanger.TaskQueue.Dequeue();
+                    exchanger.TaskQueue.Dequeue();
                 }
             }
         }
     }
 
     /// <summary>
     /// Interthread communication object
     /// </summary>
     class InterThreadExchanger
     {
-        private ConnectionStates ConnectionStateStatus = ConnectionStates.Ready;
+        ConnectionState connectionState = ConnectionState.Ready;
 
-        public enum ConnectionStates
+        public enum ConnectionState
         {
             Ready,
             Broken
         }
 
         public TaskQueue TaskQueue { get; set; }
-        public ConnectionStates ConnectionState
+        public ConnectionState DbConnectionState
         {
             get
             {
-                return ConnectionStateStatus;
+                return connectionState;
             }
             set
             {
-                if (ConnectionStateStatus != value)
+                if (connectionState != value)
                 {
-                    ConnectionStateStatus = value;
+                    connectionState = value;
                     RaiseConnectionStateChangeEvent();
                 }
             }
         }
 
         public delegate void ConnectionStateChangeEventHandler(object sender, EventArgs args);
         public event ConnectionStateChangeEventHandler ConnectionStateChange;
 
-        private void RaiseConnectionStateChangeEvent()
+        void RaiseConnectionStateChangeEvent()
         {
             if (ConnectionStateChange != null)
             {
                 ConnectionStateChange(this, new EventArgs());
             }
         }
     }
 
     class QueueManager
     {
-        private TaskQueue TaskQueue;
+        TaskQueue taskQueue;
 
         public QueueManager(TaskQueue taskQueue)
         {
-            TaskQueue = taskQueue;
+            this.taskQueue = taskQueue;
             Console.WriteLine("Thread id (StatusChecker): " + System.Threading.Thread.CurrentThread.ManagedThreadId);
         }
 
         // This method is called by the timer delegate.
         public void AddTask(Object stateInfo)
         {
             Console.WriteLine("Thread id (Timer elapsed): " + System.Threading.Thread.CurrentThread.ManagedThreadId);
 
-            lock (TaskQueue)
+            lock (taskQueue)
             {
-                TaskQueue.Enqueue("New task name");
+                taskQueue.Enqueue("New task name");
             }
 
-            Console.WriteLine("Task count: " + TaskQueue.Count.ToString());
+            Console.WriteLine("Task count: " + taskQueue.Count.ToString());
         }
     }
 
     class TaskQueue : Queue<string>
     {
-        private Object QueueLock = new Object();
+        Object queueLock = new Object();
 
         public TaskQueue()
         {
             Console.WriteLine("Thread id (TaskQueue):" + System.Threading.Thread.CurrentThread.ManagedThreadId);
         }
 
         public new void Enqueue(string item)
         {
             // if task is already queued, skip adding
             if (!Contains(item))
             {
                 Console.WriteLine("Adding taks: " + item);
-                lock (QueueLock) // thread safety
+                lock (queueLock) // thread safety
                 {
                     base.Enqueue(item);
                 }
                 RaiseEvent();
             }
             else
             {
                 Console.WriteLine("Item already queued: " + item);
             }
         }
 
-        private void RaiseEvent()
+        void RaiseEvent()
         {
             if (Filled != null)
             {
                 Filled(this, new EventArgs());
             }
         }
 
-        public delegate void TaskQueueEventHandler(object sender, EventArgs args);
+        public delegate void TaskQueueFilledEventHandler(object sender, EventArgs args);
-        public event TaskQueueEventHandler Filled;
+        public event TaskQueueFilledEventHandler Filled;
    }
 }