Enhance identity assignment logic and update tests for duplicate handling

Author: PTKu

src/AXSharp.connectors/src/AXSharp.Connector/Identity/TwinIdentityProvider.cs

@@ -206,7 +206,7 @@ internal async Task<IEnumerable<OnlinerULInt>> ReadIdentitiesAsync()
     /// </summary>
     /// <param name="identities">Identities</param>
     /// <param name="identityProvider">Identity creator.</param>
-    /// <returns></returns>
+    /// <returns>Assigned identities.</returns>
     public IEnumerable<OnlinerULInt> AssignIdentities(IEnumerable<OnlinerULInt> identities, Func<OnlinerULInt, ulong> identityProvider = null)
     {
         // If no identity provider is given, use default one based on hash code of the symbol.
@@ -234,46 +234,88 @@ public async Task WriteIdentities(IEnumerable<OnlinerULInt> identitiesToWrite)
     }
 
     /// <summary>
-    ///     Refreshes and sorts identities.
+    ///    Constructs identities by assigning them locally and writing to PLC, then sorts them by their assigned values.
     /// </summary>
-    public async Task ConstructIdentitiesAsync(Func<OnlinerULInt, ulong> identityProvider = null)
+    /// <param name="identityProvider">Function to provide identity values.</param>
+    /// <param name="failOnDuplicate">Indicates whether to fail on duplicate identities.</param>
+    /// <returns></returns>
+    public async Task ConstructIdentitiesAsync(Func<OnlinerULInt, ulong> identityProvider = null, bool failOnDuplicate = true)
     {
-        await WriteIdentities(AssignIdentities(_identitiesTags, identityProvider));        
-        await SortIdentitiesAsync();
+        await WriteIdentities(AssignIdentities(_identitiesTags, identityProvider));
+        await SortIdentitiesAsync(failOnDuplicate);
     }
 
     /// <summary>
-    ///     Sorts identities.
+    ///     Sorts identities using the locally assigned Cyclic values, without reading back from PLC.
     /// </summary>
-    internal async Task SortIdentitiesAsync()
+    internal async Task SortIdentitiesAsync(bool failOnDuplicate = true)
     {
-        await Task.Run(async () =>
+        _connector?.Logger.Information("Sorting identities from assigned values...");
+        _sortedIdentities.Clear();
+        foreach (var identity in _identities)
         {
-            _connector?.Logger.Information("Sorting identities...");
-            if (_connector != null)
+            var key = identity.Key.Cyclic;
+            if (!_sortedIdentities.ContainsKey(key) && key != 0)
             {
-                await _connector?.ReadBatchAsync(_identities.Select(p => p.Key), eAccessPriority.High);
+                _sortedIdentities.Add(key, identity.Value);
             }
-            _sortedIdentities.Clear();
-            foreach (var identity in _identities)
+            else
             {
-                var key = identity.Key.LastValue;
-                if (!_sortedIdentities.ContainsKey(key))
-                {
-                    _sortedIdentities.Add(key, identity.Value);
-                }
-                else
+                if (failOnDuplicate)
                 {
                     throw new DuplicateIdentityException("There is a duplicate identity: " +
-                                                         $"{identity.Value.Symbol} : {key}." +
+                                                         $"'{identity.Value.Symbol} : {key}.'" +
+                                                         $" and '{_sortedIdentities[key].Symbol} : {key}.'" +
+                                                         $" share the same identity value." +
                                                          $"The algorithm for assigning identities needs to be adjusted." +
                                                          $"Use an algorithm that guarantees unique identities and is less prone to collisions.");
                 }
+                else
+                {
+                    _connector?.Logger.Warning($"Duplicate identity detected: '{identity.Value.Symbol} : {key}' and '{_sortedIdentities[key].Symbol} : {key}' share the same identity value. " +
+                                               $"This entry will be ignored."+
+                                               $"The algorithm for assigning identities needs to be adjusted." +
+                                               $"Use an algorithm that guarantees unique identities and is less prone to collisions." +
+                                               $"Ignoring this warning may lead to unexpected behavior in those parts of the system that rely on unique identities.");
+                }
             }
+        }
 
-            _connector?.Logger.Information("Sorting identities done.");
-        });
+        _connector?.Logger.Information("Sorting identities done.");
     }
+
+    // /// <summary>
+    // ///     Sorts identities by reading values from PLC.
+    // /// </summary>
+    // internal async Task SortIdentitiesAsync()
+    // {
+    //     await Task.Run(async () =>
+    //     {
+    //         _connector?.Logger.Information("Sorting identities...");
+    //         if (_connector != null)
+    //         {
+    //             await _connector?.ReadBatchAsync(_identities.Select(p => p.Key), eAccessPriority.High);
+    //         }
+    //         _sortedIdentities.Clear();
+    //         foreach (var identity in _identities)
+    //         {
+    //             var key = identity.Key.LastValue;
+    //             if (!_sortedIdentities.ContainsKey(key))
+    //             {
+    //                 _sortedIdentities.Add(key, identity.Value);
+    //             }
+    //             else
+    //             {
+    //                 throw new DuplicateIdentityException("There is a duplicate identity: " +
+    //                                                      $"{identity.Value.Symbol} : {key}." +
+    //                                                      $"The algorithm for assigning identities needs to be adjusted." +
+    //                                                      $"Use an algorithm that guarantees unique identities and is less prone to collisions.");
+    //             }
+    //         }
+
+    //         _connector?.Logger.Information("Sorting identities done.");
+    //     });
+    // }
 }
 
 /// <summary>

src/AXSharp.connectors/tests/AXSharp.ConnectorTests/AXSharp.ConnectorTests/Identity/TwinIdentityProviderTests.cs

@@ -220,16 +220,19 @@ public async void CanCallSortIdentities()
 
             var identityVar_2 = Substitute.For<OnlinerULInt, IOnline<ulong>>();
             identityVar_2.LastValue.Returns(2ul);
+            identityVar_2.Cyclic.Returns(2ul);
             var obj2 = Substitute.For<ITwinIdentity>();
             obj2.Identity.Returns(identityVar_2);
 
             var identityVar_1 = Substitute.For<OnlinerULInt, IOnline<ulong>>();
             var obj1 = Substitute.For<ITwinIdentity>();
             obj1.Identity.Returns(identityVar_1);
             identityVar_1.LastValue.Returns(1ul);
+            identityVar_1.Cyclic.Returns(1ul);
 
             var identityVar_3 = Substitute.For<OnlinerULInt, IOnline<ulong>>();
             identityVar_3.LastValue.Returns(3ul);
+            identityVar_3.Cyclic.Returns(3ul);
             var obj3 = Substitute.For<ITwinIdentity>();
             obj3.Identity.Returns(identityVar_3);