Support custom row key comparers (allows for case sensitivity control, performance tuning, etc.)

Author: david-durrleman

Rhino.Etl.Core/QuackingDictionary.cs

@@ -14,6 +14,20 @@ namespace Rhino.Etl.Core
     [Serializable]
     public class QuackingDictionary : IDictionary, IQuackFu
     {
+        /// <summary>
+        /// Default value for the Comparer property.
+        /// Defines how keys are compared (case sensitivity, hashing algorithm, etc.)
+        /// </summary>
+        public static StringComparer DefaultComparer { get; set; }
+
+        /// <summary>
+        /// Initialization for static members/properties
+        /// </summary>
+        static QuackingDictionary()
+        {
+            DefaultComparer = StringComparer.InvariantCultureIgnoreCase;
+        }
+
         /// <summary>
         /// The inner items collection
         /// </summary>
@@ -26,6 +40,11 @@ public class QuackingDictionary : IDictionary, IQuackFu
 
         private bool throwOnMissing = false;
 
+        /// <summary>
+        /// Defines how keys are compared (case sensitivity, hashing algorithm, etc.)
+        /// </summary>
+        protected StringComparer Comparer { get; set; }
+
         /// <summary>
         /// Set the flag to thorw if key not found.
         /// </summary>
@@ -38,12 +57,24 @@ public void ShouldThorwIfKeyNotFound()
         /// Initializes a new instance of the <see cref="QuackingDictionary"/> class.
         /// </summary>
         /// <param name="items">The items.</param>
-        public QuackingDictionary(IDictionary items)
+        /// <param name="comparer">Defines key equality</param>
+        public QuackingDictionary(IDictionary items, StringComparer comparer)
         {
+            Comparer = comparer;
+
             if (items != null)
-                this.items = new Hashtable(items, StringComparer.InvariantCultureIgnoreCase);
+                this.items = new Hashtable(items, Comparer);
             else
-                this.items = new Hashtable(StringComparer.InvariantCultureIgnoreCase);
+                this.items = new Hashtable(Comparer);
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="QuackingDictionary"/> class.
+        /// </summary>
+        /// <param name="items">The items.</param>
+        public QuackingDictionary(IDictionary items)
+            : this(items, DefaultComparer)
+        {
         }
 
 

Rhino.Etl.Core/Row.cs

@@ -22,20 +22,30 @@ public class Row : QuackingDictionary, IEquatable<Row>
         static readonly Dictionary<Type, List<PropertyInfo>> propertiesCache = new Dictionary<Type, List<PropertyInfo>>();
         static readonly Dictionary<Type, List<FieldInfo>> fieldsCache = new Dictionary<Type, List<FieldInfo>>();
 
+        /// <summary>
+        /// Initializes a new instance of the <see cref="Row"/> class.
+        /// </summary>
+        /// <param name="comparer">Defines key equality</param>
+        public Row(StringComparer comparer)
+            : base(new Hashtable(), comparer)
+        {
+        }
+
         /// <summary>
         /// Initializes a new instance of the <see cref="Row"/> class.
         /// </summary>
         public Row()
-            : base(new Hashtable(StringComparer.InvariantCultureIgnoreCase))
+            : base(new Hashtable())
         {
         }
 
         /// <summary>
         /// Initializes a new instance of the <see cref="Row"/> class.
         /// </summary>
         /// <param name="itemsToClone">The items to clone.</param>
-        protected Row(IDictionary itemsToClone)
-            : base(new Hashtable(itemsToClone, StringComparer.InvariantCultureIgnoreCase))
+        /// <param name="comparer">Defines key equality</param>
+        protected Row(IDictionary itemsToClone, StringComparer comparer)
+            : base(itemsToClone, comparer)
         {
         }
 
@@ -46,7 +56,7 @@ protected Row(IDictionary itemsToClone)
         /// <param name="source">The source row.</param>
         public void Copy(IDictionary source)
         {
-            items = new Hashtable(source, StringComparer.InvariantCultureIgnoreCase);
+            items = new Hashtable(source, Comparer);
         }
 
         /// <summary>
@@ -72,7 +82,7 @@ public IEnumerable<string> Columns
         /// <returns></returns>
         public Row Clone()
         {
-            Row row = new Row(this);
+            Row row = new Row(this, Comparer);
             return row;
         }
 
@@ -85,7 +95,10 @@ public Row Clone()
         /// <param name="other">An object to compare with this object.</param>
         public bool Equals(Row other)
         {
-            if(Columns.SequenceEqual(other.Columns, StringComparer.InvariantCultureIgnoreCase) == false)
+            if (!Comparer.Equals(other.Comparer))
+                return false;
+
+            if(Columns.SequenceEqual(other.Columns, Comparer) == false)
                 return false;
 
             foreach (var key in items.Keys)

Rhino.Etl.Tests/RowTest.cs

@@ -45,7 +45,33 @@ public void Should_not_take_casing_into_account_in_column_names()
             Row second = new Row();
             second["a"] = 1;
 
+            Row third = second.Clone();
+            
+            Row fourth = new Row();
+            fourth.Copy(third);
+
             Assert.True(first.Equals(second));
+            Assert.True(first.Equals(third));
+            Assert.True(first.Equals(fourth));
+        }
+
+        [Fact]
+        public void Should_respect_stringcomparer_specification()
+        {
+            Row first = new Row(StringComparer.Ordinal);
+            first["A"] = 1;
+
+            Row second = new Row(StringComparer.Ordinal);
+            second["a"] = 1;
+
+            Row third = second.Clone();
+
+            Row fourth = new Row();
+            fourth.Copy(second);
+
+            Assert.False(first.Equals(second));
+            Assert.False(first.Equals(third));
+            Assert.False(first.Equals(fourth));
         }
 
         [Theory]