#402 Added support for case insensitive enums of strings (#406)

* Implemented SmartEnumComparerAttribute<T> with tests

* Aligned to other files formatting

* Updated method names

* Added usage example

---------

Co-authored-by: Steve Smith <[email protected]>

Author: gigi81

README.md

@@ -29,6 +29,7 @@
   * [Json.NET support](#jsonnet-support)
   * [Dapper support](#dapper-support)
   * [DapperSmartEnum](#dappersmartenum)
+  * [Case Insensitive String Enum](#case-insensitive-string-enum)
   * [Examples in the Real World](#examples-in-the-real-world)
   * [References](#references)
 
@@ -807,6 +808,28 @@ should have their `DbType` property set to the specified value. Use `DoNotSetDbT
 `IgnoreCaseAttribute` (e.g. `[IgnoreCase]`) when inheriting from `DapperSmartEnumByName` to specify
 that database values do not need to match the case of a SmartEnum Name.
 
+### Case Insensitive String Enum
+
+When creating enums of strings, the default behaviour of SmartEnum is to compare the strings with a case sensitive comparer.
+It is possible to specify a different equality comparer for the enum values, for example a case insensitive one:
+
+```csharp
+[SmartEnumStringComparer(StringComparison.InvariantCultureIgnoreCase)]
+public class CaseInsensitiveEnum : SmartEnum<CaseInsensitiveEnum, string>
+{
+    protected CaseInsensitiveEnum(string name, string value) : base(name, value) { }
+
+    public static CaseInsensitiveEnum One = new CaseInsensitiveEnum("One", "one");
+    public static CaseInsensitiveEnum Two = new CaseInsensitiveEnum("Two", "two");
+}
+
+var e1 = CaseInsensitiveEnum.FromValue("ONE");
+var e2 = CaseInsensitiveEnum.FromValue("one");
+
+//e1 is equal to e2
+```
+
+
 ## Examples in the Real World
 
 - [Race](https://github.com/pdevito3/PeakLimsApi/blob/main/PeakLims/src/PeakLims/Domain/Races/Race.cs)

src/SmartEnum/SmartEnum.cs

@@ -52,7 +52,7 @@ public abstract class SmartEnum<TEnum, TValue> :
             new Lazy<Dictionary<TValue, TEnum>>(() =>
             {
                 // multiple enums with same value are allowed but store only one per value
-                var dictionary = new Dictionary<TValue, TEnum>();
+                var dictionary = new Dictionary<TValue, TEnum>(GetValueComparer());
                 foreach (var item in _enumOptions.Value)
                 {
                     if (item._value != null && !dictionary.ContainsKey(item._value))
@@ -72,6 +72,12 @@ private static TEnum[] GetAllOptions()
                 .ToArray();
         }
 
+        private static IEqualityComparer<TValue> GetValueComparer()
+        {
+            var comparer = typeof(TEnum).GetCustomAttribute<SmartEnumComparerAttribute<TValue>>();
+            return comparer?.Comparer;
+        }
+
         /// <summary>
         /// Gets a collection containing all the instances of <see cref="SmartEnum{TEnum, TValue}"/>.
         /// </summary>

src/SmartEnum/SmartEnumComparerAttribute.cs

@@ -0,0 +1,55 @@
+using System;
+using System.Collections.Generic;
+
+namespace Ardalis.SmartEnum
+{
+    /// <summary>
+    /// Base class for an <see cref="Attribute"/> to specify the <see cref="IEqualityComparer{T}"/> for a SmartEnum.
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
+    [AttributeUsage(AttributeTargets.Class)]
+    public class SmartEnumComparerAttribute<T> : Attribute
+    {
+        private readonly IEqualityComparer<T> _comparer;
+
+        protected SmartEnumComparerAttribute(IEqualityComparer<T> comparer)
+        {
+            _comparer = comparer;
+        }
+
+        public IEqualityComparer<T> Comparer => _comparer;
+    }
+
+    /// <summary>
+    /// Attribute to apply to <see cref="SmartEnum{TEnum, string}"/> of type <see cref="string"/> to specify how to compare
+    /// the enum values
+    /// </summary>
+    public class SmartEnumStringComparerAttribute : SmartEnumComparerAttribute<string>
+    {
+        public SmartEnumStringComparerAttribute(StringComparison comparison)
+            : base(GetComparer(comparison))
+        {
+        }
+
+        private static IEqualityComparer<string> GetComparer(StringComparison comparison)
+        {
+            switch (comparison)
+            {
+                case StringComparison.Ordinal:
+                    return StringComparer.Ordinal;
+                case StringComparison.OrdinalIgnoreCase:
+                    return StringComparer.OrdinalIgnoreCase;
+                case StringComparison.CurrentCulture:
+                    return StringComparer.CurrentCulture;
+                case StringComparison.CurrentCultureIgnoreCase:
+                    return StringComparer.CurrentCultureIgnoreCase;
+                case StringComparison.InvariantCulture:
+                    return StringComparer.InvariantCulture;
+                case StringComparison.InvariantCultureIgnoreCase:
+                    return StringComparer.InvariantCultureIgnoreCase;
+            }
+
+            throw new ArgumentException($"StringComparison {comparison} is not supported", nameof(comparison));
+        }
+    }
+}

test/SmartEnum.UnitTests/SmartEnumComparerAttribute.cs

@@ -0,0 +1,95 @@
+namespace Ardalis.SmartEnum.UnitTests
+{
+    using FluentAssertions;
+    using System;
+    using Xunit;
+
+    public class SmartEnumComparerAttribute
+    {
+        public class VanillaStringEnum : SmartEnum<VanillaStringEnum, string>
+        {
+            protected VanillaStringEnum(string name, string value) : base(name, value) { }
+
+            public static VanillaStringEnum One = new VanillaStringEnum("One", "one");
+            public static VanillaStringEnum Two = new VanillaStringEnum("Two", "two");
+        }
+
+        [SmartEnumStringComparer(StringComparison.InvariantCultureIgnoreCase)]
+        public class CaseInsensitiveEnum : SmartEnum<CaseInsensitiveEnum, string>
+        {
+            protected CaseInsensitiveEnum(string name, string value) : base(name, value) { }
+
+            public static CaseInsensitiveEnum One = new CaseInsensitiveEnum("One", "one");
+            public static CaseInsensitiveEnum Two = new CaseInsensitiveEnum("Two", "two");
+        }
+
+        [SmartEnumStringComparer(StringComparison.InvariantCulture)]
+        public class CaseSensitiveEnum : SmartEnum<CaseSensitiveEnum, string>
+        {
+            protected CaseSensitiveEnum(string name, string value) : base(name, value) { }
+
+            public static CaseSensitiveEnum One = new CaseSensitiveEnum("One", "one");
+            public static CaseSensitiveEnum Two = new CaseSensitiveEnum("Two", "two");
+        }
+
+        [Fact]
+        public void VanillaStringEnum_FromValue_WhenStringDoesNotMatchCase_Throws()
+        {
+            //act
+            Assert.Throws<SmartEnumNotFoundException>(() =>
+            {
+                var actual = VanillaStringEnum.FromValue("ONE");
+            });
+        }
+
+        [Fact]
+        public void CaseInsensitiveEnum_FromValue_WhenStringDoesNotMatchCase_ReturnsItem()
+        {
+            //act
+            var actual = CaseInsensitiveEnum.FromValue("ONE");
+
+            //assert
+            actual.Should().Be(CaseInsensitiveEnum.One);
+        }
+
+        [Fact]
+        public void CaseSensitiveEnum_FromValue_WhenStringDoesNotMatchCase_Throws()
+        {
+            //act
+            Assert.Throws<SmartEnumNotFoundException>(() =>
+            {
+                var actual = CaseSensitiveEnum.FromValue("ONE");
+            });
+        }
+
+        [Fact]
+        public void VanillaStringEnum_FromValue_WhenStringMatchesCase_ReturnsItem()
+        {
+            //act
+            var actual = VanillaStringEnum.FromValue("one");
+
+            //assert
+            actual.Should().Be(VanillaStringEnum.One);
+        }
+
+        [Fact]
+        public void CaseInsensitiveEnum_FromValue_WhenStringMatchesCase_ReturnsItem()
+        {
+            //act
+            var actual = CaseInsensitiveEnum.FromValue("one");
+
+            //assert
+            actual.Should().Be(CaseInsensitiveEnum.One);
+        }
+
+        [Fact]
+        public void CaseSensitiveEnum_FromValue_WhenStringMatchesCase_ReturnsItem()
+        {
+            //act
+            var actual = CaseSensitiveEnum.FromValue("one");
+
+            //assert
+            actual.Should().Be(CaseSensitiveEnum.One);
+        }
+    }
+}