Changed Cache behaviour

Items can be added to the cache dynamically at any point in time. Also the method can be invoked multiple times. Fixed a bug which would occur if a child library would also use this library.  Also updated BidirectionalDict.

src/StringyEnums/StringyEnums.Benchmarks/Benchmarks/CommonEnumStringValuesExtensionBenchmark.cs

@@ -1,11 +1,9 @@
 using BenchmarkDotNet.Attributes;
-using BenchmarkDotNet.Configs;
-using BenchmarkDotNet.Validators;
 using Common.EnumStringValues;
 
 namespace StringyEnums.Benchmarks
 {
-	[MemoryDiagnoser]
+    [MemoryDiagnoser]
 	[Config(typeof(NoOptimizationConfig))]
 	public class CommonEnumStringValuesExtensionBenchmark
 	{

src/StringyEnums/StringyEnums.Benchmarks/NoOptimizationConfig.cs

@@ -1,13 +1,10 @@
 using BenchmarkDotNet.Configs;
 using BenchmarkDotNet.Validators;
-using System;
-using System.Collections.Generic;
-using System.Text;
 
 namespace StringyEnums.Benchmarks
 {
 
-	public class NoOptimizationConfig : ManualConfig
+    public class NoOptimizationConfig : ManualConfig
 	{
 		public NoOptimizationConfig()
 		{

src/StringyEnums/StringyEnums.Benchmarks/StringyEnums.Benchmarks.csproj

@@ -10,10 +10,7 @@
 
   <ItemGroup>
     <PackageReference Include="BenchmarkDotNet" Version="0.12.0" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <ProjectReference Include="..\StringyEnums\StringyEnums.csproj" />
+    <PackageReference Include="BidirectionalDict" Version="1.2.0" />
   </ItemGroup>
 
   <ItemGroup>

src/StringyEnums/StringyEnums.Tests/EnumCoreExtensions.cs

@@ -0,0 +1,10 @@
+using System.Reflection;
+
+namespace StringyEnums.Tests
+{
+    public static class EnumCoreExtensions
+    {
+        public static void ClearCache()
+            => ((dynamic)typeof(EnumCore).GetProperty("RepresentationCache", BindingFlags.NonPublic | BindingFlags.Static).GetValue(null)).Clear();
+    }
+}

src/StringyEnums/StringyEnums.Tests/EnumCoreTests.cs

@@ -0,0 +1,36 @@
+using StringyEnums.Shared.Models;
+using Xunit;
+
+namespace StringyEnums.Tests
+{
+    public class EnumCoreTests
+    {
+        [Fact]
+        public void IsEnumToRepresenationEqual()
+        {
+            EnumCoreExtensions.ClearCache();
+
+            EnumCore.Init(cache => cache.InitWith<TestEnum>());
+
+            Assert.Equal("Enum 4", TestEnum.EnumFour.GetRepresentation());
+
+            EnumCore.Init(cache => cache.InitWith<TestUShortEnum>());
+
+            Assert.Equal("Enum 4", TestUShortEnum.EnumFour.GetRepresentation());
+        }
+
+        [Fact]
+        public void IsRepresenationToEnumEqual()
+        {
+            EnumCoreExtensions.ClearCache();
+
+            EnumCore.Init(cache => cache.InitWith<TestEnum>());
+
+            Assert.Equal(TestEnum.EnumFour, "Enum 4".GetEnumFromRepresentation<TestEnum>());
+
+            EnumCore.Init(cache => cache.InitWith<TestUShortEnum>());
+
+            Assert.Equal(TestUShortEnum.EnumFour, "Enum 4".GetEnumFromRepresentation<TestUShortEnum>());
+        }
+    }
+}

src/StringyEnums/StringyEnums.Test/EnumExtensionTests.cs → src/StringyEnums/StringyEnums.Tests/EnumExtensionTests.cs

@@ -1,12 +1,11 @@
-using BidirectionalDict;
 using StringyEnums.Shared.Models;
 using Xunit;
 
-namespace StringyEnums.Test
+namespace StringyEnums.Tests
 {
 	public class EnumExtensionTests
 	{
-		public EnumExtensionTests()
+		static EnumExtensionTests()
 		{
 			EnumCore.Init(init =>
 			{

src/StringyEnums/StringyEnums.sln

@@ -5,7 +5,7 @@ VisualStudioVersion = 16.0.29521.150
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "StringyEnums", "StringyEnums\StringyEnums.csproj", "{EE98D267-C0D4-43E0-BCCA-609D3B7B56B9}"
 EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "StringyEnums.Tests", "StringyEnums.Test\StringyEnums.Tests.csproj", "{5FB57ACD-DE3E-49DC-8121-442EF7E38B9F}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "StringyEnums.Tests", "StringyEnums.Tests\StringyEnums.Tests.csproj", "{5FB57ACD-DE3E-49DC-8121-442EF7E38B9F}"
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "StringyEnums.Benchmarks", "StringyEnums.Benchmarks\StringyEnums.Benchmarks.csproj", "{D4CE5820-15CC-4D36-86B2-F858588A16ED}"
 EndProject

src/StringyEnums/StringyEnums/CacheInitializer.cs

@@ -1,94 +1,98 @@
 using BidirectionalDict;
 using System;
 using System.Collections.Generic;
-using System.Collections.ObjectModel;
 using System.Linq;
 using System.Reflection;
 
 namespace StringyEnums
 {
-	/// <summary>
-	/// Handles the initializing of a Cache
-	/// </summary>
-	public class CacheInitializer
-	{
-		private readonly Dictionary<Type, IReadOnlyBiDictionary<uint, string>> _tempCache;
-
-		internal CacheInitializer()
-		{
-			_tempCache = new Dictionary<Type, IReadOnlyBiDictionary<uint, string>>();
-		}
-
-		/// <summary>
-		/// Initializes the cache a given set of assemblies.
-		/// </summary>
-		/// <param name="assemblies">Assemblies which contain enums which get added to the cache.</param>
-		public CacheInitializer InitWith(params Assembly[] assemblies)
-		{
-			foreach (var assembly in assemblies)
-			{
-				var enumTypes = assembly.GetTypes().Where(x => x.IsEnum);
-
-				foreach (var enumType in enumTypes)
-				{
-					InitWith(enumType);
-				}
-			}
-
-			return this;
-		}
-
-		/// <summary>
-		/// Initializes the cache with a given enum.
-		/// </summary>
-		/// <typeparam name="TEnum">The enum which should be added to the cache.</typeparam>
-		public CacheInitializer InitWith<TEnum>() where TEnum : struct, Enum
-		{
-			InitWith(typeof(TEnum));
-
-			return this;
-		}
-
-		/// <summary>
-		/// Initializes the cache with a set of given enums.
-		/// </summary>
-		/// <param name="enums">The enums which should be added to the cache.</param>
-		public CacheInitializer InitWith(params Enum[] enums)
-		{
-			foreach (var enumVal in enums)
-			{
-				InitWith(enumVal);
-			}
-
-			return this;
-		}
-
-		private void InitWith(Type enumType)
-		{
-			if (!enumType.IsEnum)
-				throw new ArgumentException("The type provided is not of type enum", nameof(enumType));
-
-			var fields = enumType.GetFields();
-
-			var temptDict = new BiDictionary<uint, string>();
-
-			foreach (var field in fields.Where(x => x.IsStatic))
-			{
-				var attr = field.GetCustomAttribute<StringRepresentationAttribute>();
-
-				if (attr is { })
-				{
-					temptDict.TryAdd(Convert.ToUInt32(field.GetValue(enumType))!, attr.StringRepresentation);
-				}
-			}
-
-			if (temptDict.Count > 0)
-			{
-				_tempCache.Add(enumType, temptDict);
-			}
-		}
-
-		internal IReadOnlyDictionary<Type, IReadOnlyBiDictionary<uint, string>> CustructCache()
-			=> new ReadOnlyDictionary<Type, IReadOnlyBiDictionary<uint, string>>(_tempCache.ToDictionary(k => k.Key, v => (IReadOnlyBiDictionary<uint, string>)new ReadOnlyBiDictionary<uint, string>(v.Value)));
-	}
+    /// <summary>
+    /// Handles the initializing of a Cache
+    /// </summary>
+    public class CacheInitializer
+    {
+        private readonly Dictionary<Type, IReadOnlyBiDictionary<uint, string>> _tempCache;
+
+        internal CacheInitializer()
+        {
+            _tempCache = new Dictionary<Type, IReadOnlyBiDictionary<uint, string>>();
+        }
+
+        /// <summary>
+        /// Initializes the cache a given set of assemblies.
+        /// </summary>
+        /// <param name="assemblies">Assemblies which contain enums which get added to the cache.</param>
+        public CacheInitializer InitWith(params Assembly[] assemblies)
+        {
+            foreach (var assembly in assemblies)
+            {
+                var enumTypes = assembly.GetTypes().Where(x => x.IsEnum);
+
+                foreach (var enumType in enumTypes)
+                {
+                    InitWith(enumType);
+                }
+            }
+
+            return this;
+        }
+
+        /// <summary>
+        /// Initializes the cache with a given enum.
+        /// </summary>
+        /// <typeparam name="TEnum">The enum which should be added to the cache.</typeparam>
+        public CacheInitializer InitWith<TEnum>() where TEnum : struct, Enum
+        {
+            InitWith(typeof(TEnum));
+
+            return this;
+        }
+
+        /// <summary>
+        /// Initializes the cache with a set of given enums.
+        /// </summary>
+        /// <param name="enums">The enums which should be added to the cache.</param>
+        public CacheInitializer InitWith(params Enum[] enums)
+        {
+            foreach (var enumVal in enums)
+            {
+                InitWith(enumVal);
+            }
+
+            return this;
+        }
+
+        private void InitWith(Type enumType)
+        {
+            if (!enumType.IsEnum)
+                throw new ArgumentException("The type provided is not of type enum", nameof(enumType));
+
+            var fields = enumType.GetFields();
+
+            var temptDict = new BiDictionary<uint, string>();
+
+            foreach (var field in fields.Where(x => x.IsStatic))
+            {
+                var attr = field.GetCustomAttribute<StringRepresentationAttribute>();
+
+                if (attr is { })
+                {
+                    temptDict.TryAdd(Convert.ToUInt32(field.GetValue(enumType))!, attr.StringRepresentation);
+                }
+            }
+
+            if (temptDict.Count > 0)
+            {
+                _tempCache.Add(enumType, temptDict);
+            }
+        }
+
+        internal IEnumerable<KeyValuePair<Type, IReadOnlyBiDictionary<uint, string>>> CustructCache()
+        {
+            foreach (var cacheItem in _tempCache)
+            {
+                yield return new KeyValuePair<Type, IReadOnlyBiDictionary<uint, string>>(cacheItem.Key, new ReadOnlyBiDictionary<uint, string>(cacheItem.Value));
+            }
+        }
+    }
 }

src/StringyEnums/StringyEnums/EnumCore.cs

@@ -5,42 +5,47 @@
 
 namespace StringyEnums
 {
-	/// <summary>
-	/// Handles caching of enums which have the <see cref="StringRepresentationAttribute"/>.
-	/// </summary>
-	public static class EnumCore
-	{
-		private static IReadOnlyDictionary<Type, IReadOnlyBiDictionary<uint, string>>? _representationCache;
-
-		internal static IReadOnlyDictionary<Type, IReadOnlyBiDictionary<uint, string>> RepresentationCache
-		{
-			get => _representationCache ?? throw new NotInitializedException("Please call the EnumCore.Initialize method at application startup.");
-			private set => _representationCache = value;
-		}
-
-		/// <summary>
-		/// Initializes the <see cref="EnumCore"/> with the enums contained in the calling assembly.
-		/// </summary>
-		public static void Init()
-		{
-			RepresentationCache = new CacheInitializer().InitWith(Assembly.GetCallingAssembly()).CustructCache();
-		}
-
-		/// <summary>
-		/// Initializes the <see cref="EnumCore"/> with the enums provided by the <paramref name="initializer"/>.
-		/// </summary>
-		/// <param name="initializer">Provides a <see cref="CacheInitializer"/> instance where assemblies with enums can be added.</param>
-		/// <param name="includeCallingAssembly">Indicates whether the calling assembly should be searched for enums or not.</param>
-		public static void Init(Action<CacheInitializer> initializer, bool includeCallingAssembly = true)
-		{
-			var cacheInit = new CacheInitializer();
-
-			if (includeCallingAssembly)
-				cacheInit.InitWith(Assembly.GetCallingAssembly());
-
-			initializer?.Invoke(cacheInit);
-
-			RepresentationCache = cacheInit.CustructCache();
-		}
-	}
+    /// <summary>
+    /// Handles caching of enums which have the <see cref="StringRepresentationAttribute"/>.
+    /// </summary>
+    public static class EnumCore
+    {
+        internal static IDictionary<Type, IReadOnlyBiDictionary<uint, string>> RepresentationCache { get; }
+
+        static EnumCore()
+        {
+            RepresentationCache = new Dictionary<Type, IReadOnlyBiDictionary<uint, string>>();
+        }
+
+        /// <summary>
+        /// Initializes the <see cref="EnumCore"/> with the enums contained in the calling assembly.
+        /// </summary>
+        public static void Init()
+            => InitFromCache(new CacheInitializer().InitWith(Assembly.GetCallingAssembly()));
+
+        /// <summary>
+        /// Initializes the <see cref="EnumCore"/> with the enums provided by the <paramref name="initializer"/>.
+        /// </summary>
+        /// <param name="initializer">Provides a <see cref="CacheInitializer"/> instance where assemblies with enums can be added.</param>
+        /// <param name="includeCallingAssembly">Indicates whether the calling assembly should be searched for enums or not.</param>
+        public static void Init(Action<CacheInitializer> initializer, bool includeCallingAssembly = true)
+        {
+            var cacheInit = new CacheInitializer();
+
+            if (includeCallingAssembly)
+                cacheInit.InitWith(Assembly.GetCallingAssembly());
+
+            initializer?.Invoke(cacheInit);
+
+            InitFromCache(cacheInit);
+        }
+
+        private static void InitFromCache(CacheInitializer cache)
+        {
+            foreach (var cacheItem in cache.CustructCache())
+            {
+                RepresentationCache.Add(cacheItem);
+            }
+        }
+    }
 }