Added a new shuffle method for lists

OmegaLeo.HelperLib.ConsoleApp/Program.cs

@@ -3,6 +3,7 @@
 // /media/omegaleo/Development/Library Dev/HelperLib
 
 using GameDevLibrary.Extensions;
+using GameDevLibrary.Helpers;
 using LibGit2Sharp;
 using OmegaLeo.HelperLib.Git;
 using OmegaLeo.HelperLib.Git.Models;
@@ -17,6 +18,8 @@ if (repo.IsNullOrEmpty())
 
 var git = new GitClient(repo);
 
+var result = BenchmarkUtility.Record(() =>
+{
     var changes = git.GetChanges();
 
     if (changes.FolderName.IsNotNullOrEmpty())
@@ -42,7 +45,8 @@ if (changes.FolderName.IsNotNullOrEmpty())
                             msg = Console.ReadLine();
                         }
 
-                    var signature = new Signature("Nuno 'Omega Leo' Diogo", "nunodiogo@omegaleo.pt", DateTimeOffset.Now);
+                        var signature = new Signature("Nuno 'Omega Leo' Diogo", "nunodiogo@omegaleo.pt",
+                            DateTimeOffset.Now);
                         git.Commit(msg, signature);
 
                         break;
@@ -62,6 +66,9 @@ else
     {
         Console.WriteLine("No changes found in specified repository");
     }
+});
+
+Console.WriteLine($"Time for checking for changes: {result} ms");
 
 Console.ReadLine();
 

OmegaLeo.HelperLib/Extensions/IListExtensions.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Security.Cryptography;
 
 namespace GameDevLibrary.Extensions
 {
@@ -117,5 +118,28 @@ namespace GameDevLibrary.Extensions
         {
             return array[currentIndex++ % array.Count];
         }
+        
+        /// <summary>
+        /// Shuffle around items in a list.
+        /// Code obtained from https://stackoverflow.com/a/1262619
+        /// </summary>
+        /// <param name="list"></param>
+        /// <typeparam name="T"></typeparam>
+        public static void Shuffle<T>(this IList<T> list)
+        {
+            RNGCryptoServiceProvider provider = new RNGCryptoServiceProvider();
+            int n = list.Count;
+            while (n > 1)
+            {
+                byte[] box = new byte[1];
+                do provider.GetBytes(box);
+                while (!(box[0] < n * (Byte.MaxValue / n)));
+                int k = (box[0] % n);
+                n--;
+                (list[k], list[n]) = (list[n], list[k]);
+            }
+        }
+
+        
     }
 }

OmegaLeo.HelperLib/Helpers/BenchmarkUtility.cs

@@ -0,0 +1,89 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+
+namespace GameDevLibrary.Helpers
+{
+    public class BenchmarkUtility
+    {
+        private static Dictionary<string, List<long>> _benchmarks = new Dictionary<string, List<long>>();
+        private static Dictionary<string, Stopwatch> _stopwatches = new Dictionary<string, Stopwatch>();
+
+        private static Stopwatch GetStopwatch(string key)
+        {
+            Stopwatch stopwatch = new Stopwatch();
+            
+            if (_stopwatches.TryGetValue(key, out stopwatch))
+            {
+            }
+            else
+            {
+                stopwatch = new Stopwatch();
+                _stopwatches.Add(key, stopwatch);
+            }
+            
+            return stopwatch;
+        }
+
+        public static long Record(Action actionToRecord)
+        {
+            var stopwatch = new Stopwatch();
+            stopwatch.Start();
+
+            actionToRecord.Invoke();
+            
+            stopwatch.Stop();
+            return stopwatch.ElapsedMilliseconds;
+        }
+        
+        public static long RecordAndSaveToResults(string key, Action actionToRecord)
+        {
+            var stopwatch = new Stopwatch();
+            stopwatch.Start();
+
+            actionToRecord.Invoke();
+            
+            stopwatch.Stop();
+            
+            if (!_benchmarks.ContainsKey(key))
+            {
+                _benchmarks[key] = new List<long>();
+            }
+            
+            _benchmarks[key].Add(stopwatch.ElapsedMilliseconds);
+            
+            return stopwatch.ElapsedMilliseconds;
+        }
+        
+        public static void Start(string key)
+        {
+            GetStopwatch(key).Restart();
+        }
+
+        public static void Stop(string key)
+        {
+            if (!_benchmarks.ContainsKey(key))
+            {
+                _benchmarks[key] = new List<long>();
+            }
+
+            GetStopwatch(key).Stop();
+            _benchmarks[key].Add(GetStopwatch(key).ElapsedMilliseconds);
+        }
+
+        public static List<long> GetResults(string key)
+        {
+            return _benchmarks.ContainsKey(key) ? _benchmarks[key] : new List<long>();
+        }
+
+        public static void ClearResults()
+        {
+            _benchmarks.Clear();
+        }
+
+        public static Dictionary<string, List<long>> GetAllResults()
+        {
+            return new Dictionary<string, List<long>>(_benchmarks);
+        }
+    }
+}

OmegaLeo.HelperLib/Models/InstancedObject.cs

@@ -0,0 +1,31 @@
+using System;
+
+namespace GameDevLibrary.Models
+{
+    public abstract class InstancedObject<T> where T : class
+    {
+        public static T Instance { get; private set; }
+
+        protected InstancedObject()
+        {
+            if (Instance != null)
+            {
+                throw new InvalidOperationException($"An instance of {typeof(T).Name} already exists.");
+            }
+
+            Instance = this as T;
+            if (Instance == null)
+            {
+                throw new InvalidOperationException($"Failed to cast {GetType().Name} to {typeof(T).Name}.");
+            }
+        }
+
+        ~InstancedObject()
+        {
+            if (Instance == this)
+            {
+                Instance = null;
+            }
+        }
+    }
+}

OmegaLeo.HelperLib/Models/NeoDictionary.cs

@@ -82,6 +82,12 @@ namespace GameDevLibrary.Models
         public NeoDictionaryItem<TKey, TValue>? LastOrDefault(Func<NeoDictionaryItem<TKey, TValue>, bool> predicate) =>
             Items.LastOrDefault(predicate);
         
+        public IEnumerable<NeoDictionaryItem<TKey, TValue>> Select(Func<NeoDictionaryItem<TKey, TValue>, NeoDictionaryItem<TKey, TValue>> selector) =>
+            Items.Select(selector);
+        
+        public int IndexOf(NeoDictionaryItem<TKey, TValue> selector) =>
+            Items.IndexOf(selector);
+
         public void Remove(TKey key)
         {
             var index = Items.FindIndex(x => x.Key.Equals(key));