* Visual Studio being silly

Author: CodeDead

MemPlus/Classes/LOG/ApplicationLog.cs

@@ -11,6 +11,7 @@ internal class ApplicationLog : Log
         /// <summary>
         /// Initialize a new ApplicationLog object
         /// </summary>
+        /// <param name="data">The data that needs to be added to the Log</param>
         internal ApplicationLog(string data)
         {
             LogType = LogType.Application;

MemPlus/Classes/LOG/ILogMethods.cs

@@ -2,10 +2,25 @@
 
 namespace MemPlus.Classes.LOG
 {
+    /// <summary>
+    /// Interface containing methods that are required for Log objects
+    /// </summary>
     internal interface ILogMethods
     {
+        /// <summary>
+        /// Add data to the Log object
+        /// </summary>
+        /// <param name="data">The data that needs to be added to the log</param>
         void AddData(string data);
+        /// <summary>
+        /// Retrieve the data from the Log object
+        /// </summary>
+        /// <returns>The data from the Log object</returns>
         string GetData();
+        /// <summary>
+        /// Retrieve the creation date of the Log object
+        /// </summary>
+        /// <returns>The creation date of the Log object</returns>
         DateTime GetDate();
     }
 }

MemPlus/Classes/LOG/Log.cs

@@ -2,27 +2,51 @@
 
 namespace MemPlus.Classes.LOG
 {
+    /// <inheritdoc />
+    /// <summary>
+    /// Abstract class containing logging information
+    /// </summary>
     public abstract class Log : ILogMethods
     {
         /// <summary>
         /// The type of log
         /// </summary>
         internal LogType LogType { get; set; }
-
+        /// <summary>
+        /// The creation date of the Log object
+        /// </summary>
         public DateTime Time { get; set; }
+        /// <summary>
+        /// The data inside the Log object
+        /// </summary>
         public string Data { get; set; }
 
+        /// <inheritdoc />
+        /// <summary>
+        /// Retrieve the data of the Log object
+        /// </summary>
+        /// <returns>The data of the Log object</returns>
         public DateTime GetDate()
         {
             return Time;
         }
 
+        /// <inheritdoc />
+        /// <summary>
+        /// Add data to the Log object
+        /// </summary>
+        /// <param name="data">The data that needs to be added to the log</param>
         public void AddData(string data)
         {
             Time = DateTime.Now;
             Data = data;
         }
 
+        /// <inheritdoc />
+        /// <summary>
+        /// Retrieve the data from the Log object
+        /// </summary>
+        /// <returns>The data from the Log object</returns>
         public string GetData()
         {
             return Data;

MemPlus/Classes/LOG/LogController.cs

@@ -3,30 +3,74 @@
 
 namespace MemPlus.Classes.LOG
 {
+    /// <summary>
+    /// Class containing methods to control logs
+    /// </summary>
     public class LogController
     {
+        /// <summary>
+        /// The list of available Log objects
+        /// </summary>
         private readonly List<Log> _logList;
+        /// <summary>
+        /// Delegate that will be called when a Log object was added
+        /// </summary>
+        /// <param name="l">The Log object that was added</param>
         internal delegate void LogAdded(Log l);
+        /// <summary>
+        /// Delegate that will be called when a Log object was removed
+        /// </summary>
+        /// <param name="l">The Log object that was deleted</param>
         internal delegate void LogDeleted(Log l);
+        /// <summary>
+        /// Delegate that will be called when all Log objects are removed
+        /// </summary>
         internal delegate void LogsCleared();
+        /// <summary>
+        /// Delegate that will be called when a list of Log objects with a specific LogType were removed
+        /// </summary>
+        /// <param name="clearedList">The list of Log objects that were removed</param>
         internal delegate void LogTypeCleared(List<Log> clearedList);
 
+        /// <summary>
+        /// Method that will be called when a Log object was added
+        /// </summary>
         internal LogAdded LogAddedEvent;
+        /// <summary>
+        /// Method that will be called when a Log object was removed
+        /// </summary>
         internal LogDeleted LogDeletedEvent;
+        /// <summary>
+        /// Method that will be called when all Log objects were removed
+        /// </summary>
         internal LogsCleared LogsClearedEvent;
+        /// <summary>
+        /// Method that will be called when a list of Log objects with a specific LogType were removed
+        /// </summary>
         internal LogTypeCleared LogTypeClearedEvent;
 
+        /// <summary>
+        /// Initialize a new LogController object
+        /// </summary>
         internal LogController()
         {
             _logList = new List<Log>();
         }
 
+        /// <summary>
+        /// Add a Log object to the list of logs
+        /// </summary>
+        /// <param name="l">The Log object that needs to be added</param>
         internal void AddLog(Log l)
         {
             _logList.Add(l);
             LogAddedEvent?.Invoke(l);
         }
 
+        /// <summary>
+        /// Remove a Log object from the list of logs
+        /// </summary>
+        /// <param name="l">The Log object that needs to be removed</param>
         internal void RemoveLog(Log l)
         {
             if (_logList.Contains(l))
@@ -40,6 +84,10 @@ internal void RemoveLog(Log l)
             }
         }
 
+        /// <summary>
+        /// Clear all Log objects that have a specific LogType
+        /// </summary>
+        /// <param name="logType">The LogType that Log objects need to contain in order to be removed</param>
         internal void ClearLogs(LogType logType)
         {
             List<Log> deleted = new List<Log>();
@@ -54,12 +102,19 @@ internal void ClearLogs(LogType logType)
             LogTypeClearedEvent?.Invoke(deleted);
         }
 
+        /// <summary>
+        /// Clear all Log objects
+        /// </summary>
         internal void ClearLogs()
         {
             _logList.Clear();
-            LogClearedEvent?.Invoke();
+            LogsClearedEvent?.Invoke();
         }
 
+        /// <summary>
+        /// Retrieve the list of currently available Log objects
+        /// </summary>
+        /// <returns>The list of currently available Log objects</returns>
         internal List<Log> GetLogs()
         {
             return _logList;

MemPlus/Classes/RAM/RamController.cs

@@ -9,23 +9,74 @@
 
 namespace MemPlus.Classes.RAM
 {
+    /// <summary>
+    /// Sealed class containing methods and interaction logic in terms of RAM
+    /// </summary>
     internal sealed class RamController
     {
+        #region Variables
+        /// <summary>
+        /// The RamOptimizer object that can be called to clear memory
+        /// </summary>
+        private readonly RamOptimizer _ramOptimizer;
+        /// <summary>
+        /// The Timer object that will periodically update RAM usage statistics
+        /// </summary>
         private readonly Timer _ramTimer;
+        /// <summary>
+        /// The LogController object that can be used to add logs
+        /// </summary>
         private readonly LogController _logController;
-
+        /// <summary>
+        /// The Dispatcher object that can be used to update GUI components
+        /// </summary>
         private readonly Dispatcher _dispatcher;
+        /// <summary>
+        /// The SfCircularGauge object that can be used to present RAM usage statistics
+        /// </summary>
         private readonly SfCircularGauge _gauge;
+        /// <summary>
+        /// The Label object that can be used to show the total physical memory
+        /// </summary>
         private readonly Label _lblTotal;
+        /// <summary>
+        /// The Label object that can be used to show the available physical memory
+        /// </summary>
         private readonly Label _lblAvailable;
-
+        /// <summary>
+        /// The ComputerInfo object that can be used to retrieve RAM usage statistics
+        /// </summary>
         private readonly ComputerInfo _info;
+        #endregion
 
+        #region Properties
+        /// <summary>
+        /// Property containing how much RAM is being used
+        /// </summary>
         internal double RamUsage { get; private set; }
+        /// <summary>
+        /// Property containing the percentage of RAM that is being used
+        /// </summary>
         internal double RamUsagePercentage { get; private set; }
+        /// <summary>
+        /// Property containing the total amount of RAM available
+        /// </summary>
         internal double RamTotal { get; private set; }
+        /// <summary>
+        /// Property containing how much RAM was saved during the last optimisation
+        /// </summary>
         internal double RamSavings { get; private set; }
-
+        #endregion
+
+        /// <summary>
+        /// Initialize a new RamController object
+        /// </summary>
+        /// <param name="dispatcher">The Dispatcher object that can be used to update GUI components</param>
+        /// <param name="gauge">The SfCircularGauge control that can be used to present RAM usage statistics</param>
+        /// <param name="lblTotal">The Label control that can be used to display the total available memory statistics</param>
+        /// <param name="lblAvailable">The Label control that can be used to display the available memory statistics</param>
+        /// <param name="timerInterval">The interval for which RAM usage statistics should be updated</param>
+        /// <param name="logController">The LogController object that can be used to add logs</param>
         internal RamController(Dispatcher dispatcher, SfCircularGauge gauge, Label lblTotal, Label lblAvailable, int timerInterval, LogController logController)
         {
             _logController = logController ?? throw new ArgumentNullException(nameof(logController));
@@ -42,44 +93,72 @@ internal RamController(Dispatcher dispatcher, SfCircularGauge gauge, Label lblTo
             _lblTotal = lblTotal ?? throw new ArgumentNullException(nameof(lblTotal));
             _lblAvailable = lblAvailable ?? throw new ArgumentNullException(nameof(lblAvailable));
 
+            _ramOptimizer = new RamOptimizer(_logController);
+
             _ramTimer = new Timer();
             _ramTimer.Elapsed += OnTimedEvent;
             _ramTimer.Interval = timerInterval;
 
             _logController.AddLog(new ApplicationLog("Done initializing RamController"));
         }
 
+        /// <summary>
+        /// Enable RAM usage monitoring
+        /// </summary>
         internal void EnableMonitor()
         {
             if (_ramTimer.Enabled) return;
             _ramTimer.Enabled = true;
-            OnTimedEvent(null, null);
+            
+            UpdateRamUsage();
+            UpdateGuiControls();
+
             _logController.AddLog(new ApplicationLog("The RAM monitor has been enabled"));
         }
 
+        /// <summary>
+        /// Disable RAM usage monitoring
+        /// </summary>
         internal void DisableMonitor()
         {
             _ramTimer.Enabled = false;
             _logController.AddLog(new ApplicationLog("The RAM monitor has been disabled"));
         }
 
-        private void OnTimedEvent(object source, ElapsedEventArgs e)
+        /// <summary>
+        /// Update the GUI controls with the available RAM usage statistics
+        /// </summary>
+        private void UpdateGuiControls()
         {
-            _logController.AddLog(new ApplicationLog("RAM monitor timer has been called"));
-
-            UpdateRamUsage();
-
             _dispatcher.Invoke(() =>
             {
                 _gauge.Scales[0].Pointers[0].Value = RamUsagePercentage;
                 _gauge.GaugeHeader = "RAM usage (" + RamUsagePercentage.ToString("F2") + "%)";
                 _lblTotal.Content = (RamTotal / 1024 / 1024 / 1024).ToString("F2") + " GB";
                 _lblAvailable.Content = (RamUsage / 1024 / 1024 / 1024).ToString("F2") + " GB";
             });
+        }
+
+        /// <summary>
+        /// Event that will be called when the timer interval was reached
+        /// </summary>
+        /// <param name="source">The calling object</param>
+        /// <param name="e">The ElapsedEventArgs</param>
+        private void OnTimedEvent(object source, ElapsedEventArgs e)
+        {
+            _logController.AddLog(new ApplicationLog("RAM monitor timer has been called"));
+
+            UpdateRamUsage();
+            UpdateGuiControls();
 
             _logController.AddLog(new ApplicationLog("Finished RAM monitor timer"));
         }
 
+        /// <summary>
+        /// Clear all non-essential RAM
+        /// </summary>
+        /// <param name="filesystemcache">A boolean to indicate whether or not to clear the FileSystem cache</param>
+        /// <returns></returns>
         internal async Task ClearMemory(bool filesystemcache)
         {
             _logController.AddLog(new ApplicationLog("Clearing RAM memory"));
@@ -90,10 +169,8 @@ await Task.Run(async () =>
 
                 double oldUsage = RamUsage;
 
-                //Clear working set of all processes that the user has access to
-                MemPlus.EmptyWorkingSetFunction();
-                //Clear file system cache
-                MemPlus.ClearFileSystemCache(filesystemcache);
+                _ramOptimizer.EmptyWorkingSetFunction();
+                _ramOptimizer.ClearFileSystemCache(filesystemcache);
 
                 await Task.Delay(10000);
 
@@ -106,6 +183,9 @@ await Task.Run(async () =>
             _logController.AddLog(new ApplicationLog("Done clearing RAM memory"));
         }
 
+        /// <summary>
+        /// Update RAM usage statistics
+        /// </summary>
         private void UpdateRamUsage()
         {
             _logController.AddLog(new ApplicationLog("Updating RAM usage"));