A bunch of general cleanup

Author: TheNathannator

Program/LogUtils.cs Program/Logging.csProgram/LogUtils.cs renamed to Program/Logging.cs

@@ -2,7 +2,6 @@
 using System.Diagnostics;
 using System.Globalization;
 using System.IO;
-using System.Text;
 
 namespace RB4InstrumentMapper
 {

Program/MainWindow/FixedSizeConcurrentQueue.cs

@@ -1,50 +1,39 @@
-using System;
-using System.Collections.Concurrent;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
+using System.Collections.Concurrent;
 
 namespace RB4InstrumentMapper
 {
     /// <summary>
-    /// Implementation of a fixed-size concurrent queue.
+    /// A concurrent queue with a size limit.
     /// </summary>
-    /// <typeparam name="T"></typeparam>
     public class FixedSizeConcurrentQueue<T> : ConcurrentQueue<T>
     {
-        /// <summary>
-        /// Sync root of the queue for locking.
-        /// </summary>
-        private readonly object privateLockObject = new object();
+        private readonly object queueLock = new object();
 
         /// <summary>
         /// Size of the queue.
         /// </summary>
-        public int Size { get; private set; }
+        public int MaxSize { get; private set; }
 
         /// <summary>
-        /// Create a new instance of the FixedSizeConcurrentQueue.
+        /// Creates a new queue with the given max size.
         /// </summary>
-        /// <param name="size">Size of the queue.</param>
+
         public FixedSizeConcurrentQueue(int size)
         {
-            Size = size;
+            MaxSize = size;
         }
 
         /// <summary>
-        /// Enqueue an object into the queue. Maintains size limit of queue.
+        /// Enqueues an object into the queue, discarding any items at the end of the queue which exceed the max count.
         /// </summary>
-        /// <param name="obj">Object to enqueue</param>
         public new void Enqueue(T obj)
         {
             base.Enqueue(obj);
-            lock (privateLockObject)
+            lock (queueLock)
             {
-                while (base.Count > Size)
+                while (Count > MaxSize)
                 {
-                    T outObj;
-                    base.TryDequeue(out outObj);
+                    TryDequeue(out _);
                 }
             }
         }