Performance Optimization by lot

Author: RohitM-IN

src/Comparer/KeyEqualityComparer.cs src/Comparer/PropertyEqualityComparer.cssrc/Comparer/KeyEqualityComparer.cs renamed to src/Comparer/PropertyEqualityComparer.cs

@@ -4,39 +4,39 @@
 namespace DbSyncKit.Core.Comparer
 {
     /// <summary>
-    /// Compares instances of data contracts based on specified key Properties.
+    /// Compares instances of data contracts based on specified properties, which can be either key or comparable properties.
     /// </summary>
     /// <typeparam name="T">Type of the data contract implementing <see cref="IDataContractComparer"/>.</typeparam>
-    public class KeyEqualityComparer<T> : IEqualityComparer<T> where T : IDataContractComparer
+    public class PropertyEqualityComparer<T> : IEqualityComparer<T> where T : IDataContractComparer
     {
         /// <summary>
-        /// Gets the array of <see cref="PropertyInfo"/> objects representing key properties used for unique identification of objects.
+        /// Gets the array of <see cref="PropertyInfo"/> objects representing properties used for equality comparison.
+        /// These properties can serve as either key or comparable properties.
         /// </summary>
-        public readonly PropertyInfo[] keyProperties;
+        public readonly PropertyInfo[] properties;
 
         /// <summary>
-        /// Initializes a new instance of the <see cref="KeyEqualityComparer{T}"/> class.
+        /// Initializes a new instance of the <see cref="PropertyEqualityComparer{T}"/> class.
         /// </summary>
-        /// <param name="KeyProperties">An array of <see cref="PropertyInfo"/> objects representing key properties used for unique identification of objects.</param>
-        public KeyEqualityComparer(PropertyInfo[] CompariableProperties, PropertyInfo[] KeyProperties)
+        /// <param name="Properties">An array of <see cref="PropertyInfo"/> objects representing properties used for equality comparison. These can be either key or comparable properties.</param>
+        public PropertyEqualityComparer(PropertyInfo[] Properties)
         {
-            //compariableProperties = CompariableProperties;
-            keyProperties = KeyProperties;
+            properties = Properties;
         }
 
         /// <summary>
-        /// Determines whether two instances of the data contract are equal based on key properties.
+        /// Determines whether two instances of the data contract are equal based on the specified properties.
         /// </summary>
         /// <param name="x">The first instance to compare.</param>
         /// <param name="y">The second instance to compare.</param>
         /// <returns><c>true</c> if the instances are equal; otherwise, <c>false</c>.</returns>
         public bool Equals(T? x, T? y)
         {
-            return keyProperties.All(prop => Equals(prop.GetValue(x), prop.GetValue(y)));
+            return properties.All(prop => Equals(prop.GetValue(x), prop.GetValue(y)));
         }
 
         /// <summary>
-        /// Returns a hash code for the specified instance of the data contract based on key properties.
+        /// Returns a hash code for the specified instance of the data contract based on the specified properties.
         /// </summary>
         /// <param name="obj">The instance for which to get the hash code.</param>
         /// <returns>A hash code for the specified instance.</returns>
@@ -46,7 +46,7 @@ public int GetHashCode(T obj)
             {
                 int hash = 17;
 
-                foreach (var prop in keyProperties)
+                foreach (var prop in properties)
                 {
                     var value = prop.GetValue(obj);
                     hash = hash ^ ((value?.GetHashCode() ?? 0) + 23);

src/Helper/DataMetadataComparisonHelper.cs

@@ -21,14 +21,15 @@ public class DataMetadataComparisonHelper<T> where T : IDataContractComparer
         /// </summary>
         /// <param name="sourceList">The source set of data contracts.</param>
         /// <param name="destinationList">The destination set of data contracts.</param>
-        /// <param name="keyComparer">An instance of <see cref="KeyEqualityComparer{T}"/> used for key comparison.</param>
+        /// <param name="keyComparer">An instance of <see cref="PropertyEqualityComparer{T}"/> used for key comparison.</param>
         /// <returns>A <see cref="Result{T}"/> object containing added, deleted, and edited data contracts, as well as data counts.</returns>
-        public static Result<T> GetDifferences(HashSet<T> sourceList, HashSet<T> destinationList, KeyEqualityComparer<T> keyComparer, PropertyInfo[] CompariableProperties)
+        public static Result<T> GetDifferences(HashSet<T> sourceList, HashSet<T> destinationList, PropertyEqualityComparer<T> keyComparer, PropertyInfo[] CompariableProperties)
         {
 
             List<T> added = new List<T>();
             List<T> deleted = new List<T>();
             ConcurrentBag<(T edit, Dictionary<string, object> updatedProperties)> edited = new ConcurrentBag<(T, Dictionary<string, object>)>();
+            PropertyEqualityComparer<T> CompariablePropertyComparer = new PropertyEqualityComparer<T>(CompariableProperties);
 
             // Identify added entries
             added.AddRange(sourceList.Except(destinationList, keyComparer));
@@ -39,20 +40,20 @@ public static Result<T> GetDifferences(HashSet<T> sourceList, HashSet<T> destina
             // Identify edited entries
             var sourceKeyDictionary = sourceList
                 .Except(added)
-                .ToDictionary(row => GenerateCompositeKey(row, keyComparer.keyProperties), row => row);
+                .ToDictionary(row => GenerateCompositeKey(row, keyComparer.properties), row => row);
 
             var destinationKeyDictionary = destinationList
                 .Except(deleted)
-                .ToDictionary(row => GenerateCompositeKey(row, keyComparer.keyProperties), row => row);
+                .ToDictionary(row => GenerateCompositeKey(row, keyComparer.properties), row => row);
 
             Parallel.ForEach(sourceKeyDictionary, kvp =>
             {
                 var sourceContract = kvp.Value;
 
                 T? destinationContract;
-                if (destinationKeyDictionary.TryGetValue(GenerateCompositeKey(sourceContract, keyComparer.keyProperties), out destinationContract))
+                if (destinationKeyDictionary.TryGetValue(GenerateCompositeKey(sourceContract, keyComparer.properties), out destinationContract))
                 {
-                    var (isEdited, updatedProperties) = GetEdited(sourceContract, destinationContract, CompariableProperties);
+                    var (isEdited, updatedProperties) = GetEdited(sourceContract, destinationContract, CompariablePropertyComparer);
 
                     if (isEdited)
                     {
@@ -77,40 +78,36 @@ public static Result<T> GetDifferences(HashSet<T> sourceList, HashSet<T> destina
         #region Private Methods
 
         /// <summary>
-        /// Compares two entities of type <typeparamref name="T"/> to identify if any properties
-        /// have been edited during synchronization.
+        /// Compares two instances of the data contract and identifies the properties that have been edited.
         /// </summary>
-        /// <param name="source">The original entity before synchronization.</param>
-        /// <param name="destination">The entity in the destination after synchronization.</param>
-        /// <param name="compariableProperties">The properties to be compared for edits.</param>
+        /// <param name="source">The source instance to compare.</param>
+        /// <param name="destination">The destination instance to compare against.</param>
+        /// <param name="comparablePropertyComparer">The comparer used to determine which properties are comparable.</param>
         /// <returns>
-        /// A tuple where:
-        /// - <see cref="ValueTuple{T1,T2}.Item1"/> is a boolean indicating if any properties were edited.
-        /// - <see cref="ValueTuple{T1,T2}.Item2"/> is a dictionary of updated properties for the edited entity.
+        /// A tuple indicating whether the instances are edited and a dictionary containing the names and values of the updated properties.
+        /// If the instances are not edited, returns (false, null).
         /// </returns>
-        private static (bool isEdited, Dictionary<string, object>? updatedProperties) GetEdited(T source, T destination, PropertyInfo[] compariableProperties)
+        private static (bool isEdited, Dictionary<string, object>? updatedProperties) GetEdited(T source, T destination, PropertyEqualityComparer<T> comparablePropertyComparer)
         {
-            if (source.Equals(destination))
+            if(comparablePropertyComparer.Equals(source,destination))
             {
                 return (false, null);
             }
 
             Dictionary<string, object> updatedProperties = new();
-            bool isEdited = false;
-            foreach (PropertyInfo prop in compariableProperties)
+            foreach (PropertyInfo prop in comparablePropertyComparer.properties)
             {
                 object sourceValue = prop.GetValue(source)!;
                 object destinationValue = prop.GetValue(destination)!;
 
                 // Compare values
-                if (!EqualityComparer<object>.Default.Equals(sourceValue, destinationValue))
+                if (!System.Collections.Generic.EqualityComparer<object>.Default.Equals(sourceValue, destinationValue))
                 {
-                    isEdited = true;
                     updatedProperties[prop.Name] = sourceValue;
                 }
             }
 
-            return (isEdited, updatedProperties);
+            return (true, updatedProperties);
         }
 
         /// <summary>

src/Synchronization.cs

@@ -67,7 +67,7 @@ public Result<T> SyncData<T>(IDatabase source, IDatabase destination, Direction
             List<string> ColumnList = GetAllColumns<T>().Except(excludedProperty).ToList();
             PropertyInfo[] ComparableProperties = GetComparableProperties<T>();
             PropertyInfo[] keyProperties = GetKeyProperties<T>();
-            KeyEqualityComparer<T> keyEqualityComparer = new KeyEqualityComparer<T>(ComparableProperties, keyProperties);
+            PropertyEqualityComparer<T> keyEqualityComparer = new PropertyEqualityComparer<T>(keyProperties);
             HashSet<T> sourceList, destinationList;
 
             #endregion
@@ -89,10 +89,10 @@ public Result<T> SyncData<T>(IDatabase source, IDatabase destination, Direction
         /// <param name="destination">The destination database from which to retrieve data.</param>
         /// <param name="tableName">The name of the table for which to retrieve data.</param>
         /// <param name="ColumnList">The list of columns to retrieve from the table.</param>
-        /// <param name="keyEqualityComparer">An instance of <see cref="KeyEqualityComparer{T}"/> used for data comparison.</param>
+        /// <param name="keyEqualityComparer">An instance of <see cref="PropertyEqualityComparer{T}"/> used for data comparison.</param>
         /// <param name="sourceList">Output parameter for the retrieved data from the source database.</param>
         /// <param name="destinationList">Output parameter for the retrieved data from the destination database.</param>
-        public void RetrieveDataFromDatabases<T>(IDatabase source, IDatabase destination, string tableName, List<string> ColumnList, KeyEqualityComparer<T> keyEqualityComparer, out HashSet<T> sourceList, out HashSet<T> destinationList) where T : IDataContractComparer
+        public void RetrieveDataFromDatabases<T>(IDatabase source, IDatabase destination, string tableName, List<string> ColumnList, Comparer.PropertyEqualityComparer<T> keyEqualityComparer, out HashSet<T> sourceList, out HashSet<T> destinationList) where T : IDataContractComparer
         {
             var sourceQueryGenerationManager = new QueryGenerationManager(QueryGeneratorFactory.GetQueryGenerator(source.Provider));
             sourceList = GetDataFromDatabase<T>(tableName, source, sourceQueryGenerationManager, ColumnList, keyEqualityComparer);
@@ -120,9 +120,9 @@ public void RetrieveDataFromDatabases<T>(IDatabase source, IDatabase destination
         /// <param name="connection">The database connection from which to retrieve data.</param>
         /// <param name="manager">The query generation manager to use for generating the select query.</param>
         /// <param name="columns">The list of columns to retrieve from the table.</param>
-        /// <param name="keyEqualityComparer">An instance of <see cref="KeyEqualityComparer{T}"/> used for data comparison.</param>
+        /// <param name="keyEqualityComparer">An instance of <see cref="PropertyEqualityComparer{T}"/> used for data comparison.</param>
         /// <returns>A <see cref="HashSet{T}"/> containing the retrieved data.</returns>
-        public HashSet<T> GetDataFromDatabase<T>(string tableName, IDatabase connection, IQueryGenerator manager, List<string> columns, KeyEqualityComparer<T> keyEqualityComparer) where T : IDataContractComparer
+        public HashSet<T> GetDataFromDatabase<T>(string tableName, IDatabase connection, IQueryGenerator manager, List<string> columns, Comparer.PropertyEqualityComparer<T> keyEqualityComparer) where T : IDataContractComparer
         {
             var query = manager.GenerateSelectQuery<T>(tableName, columns, string.Empty);
 
@@ -140,9 +140,9 @@ public HashSet<T> GetDataFromDatabase<T>(string tableName, IDatabase connection,
         /// <typeparam name="T">The type of objects being compared. Must implement <see cref="IDataContractComparer"/>.</typeparam>
         /// <param name="sourceList">The HashSet containing data from the source.</param>
         /// <param name="destinationList">The HashSet containing data from the destination.</param>
-        /// <param name="keyEqualityComparer">An instance of <see cref="KeyEqualityComparer{T}"/> used for key comparison.</param>
+        /// <param name="keyEqualityComparer">An instance of <see cref="PropertyEqualityComparer{T}"/> used for key comparison.</param>
         /// <returns>A <see cref="Result{T}"/> containing the differences between the source and destination data.</returns>
-        public Result<T> GetDifferences<T>(HashSet<T> sourceList, HashSet<T> destinationList, KeyEqualityComparer<T> keyEqualityComparer, PropertyInfo[] ComparableProperties) where T : IDataContractComparer
+        public Result<T> GetDifferences<T>(HashSet<T> sourceList, HashSet<T> destinationList, Comparer.PropertyEqualityComparer<T> keyEqualityComparer, PropertyInfo[] ComparableProperties) where T : IDataContractComparer
         {
             return DataMetadataComparisonHelper<T>.GetDifferences(sourceList, destinationList, keyEqualityComparer, ComparableProperties);
         }