Enhance WebApiConnector and TwinIdentityProvider logic

Updated WebApiConnector to include logging for connection attempts and introduced a new HTTP client.
Refactored TwinIdentityProvider to implement flexible identity assignment with new methods for assigning and writing identities.
Added DuplicateIdentityException for improved error handling during identity sorting.

Author: PTKu

src/AXSharp.connectors/src/AXSharp.Connector.S71500.WebAPI/WebApiConnector.cs

@@ -51,6 +51,8 @@ public WebApiConnector(string ipAddress, string userName, string password,
         int maxConcurrentRequest = 4,
         int concurrentRequestDelay = 0)
     {
+        Logger?.Information($"Attempting to connect to '{ipAddress}'");
+
         IPAddress = ipAddress;
         DBName = dbName;
         TargetPlatform = platform;
@@ -96,6 +98,8 @@ public WebApiConnector(string ipAddress, string userName, string password, bool
         int maxConcurrentRequest = 4,
         int concurrentRequestDelay = 0)
     {
+        Logger?.Information($"Attempting to connect to '{ipAddress}'");
+
         IPAddress = ipAddress;
         DBName = dbName;
         TargetPlatform = platform;
@@ -110,6 +114,7 @@ public WebApiConnector(string ipAddress, string userName, string password, bool
                 (sender, cert, chain, sslPolicyErrors) => true;
 
         var serviceFactory = new ApiStandardServiceFactory();
+       
         Client = serviceFactory.GetHttpClient(ipAddress, UserName, UserPassword ?? string.Empty);
 
         var splitter = new ApiRequestSplitterByBytes();

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

@@ -193,40 +193,52 @@ internal async Task<IEnumerable<OnlinerULInt>> ReadIdentitiesAsync()
         {
             _connector.Logger.Information("Reading identities...");
             await _connector.ReadBatchAsync(_identitiesTags);
-            var lastIdentity = 0ul;
-            if (_identitiesTags.Count > 0)
-            {
-                lastIdentity = _identitiesTags.Max(p => p.LastValue);
-            }
-
-            List<ITwinPrimitive> IdentitiesToWrite = new();
-
-            _connector.Logger.Information("Assigning missing identities...");
-            foreach (var it in _identitiesTags)
-            {
-                if (it.LastValue == 0)
-                {
-                    it.Cyclic = ++lastIdentity;
-                    IdentitiesToWrite.Add(it);  
-                }
-               
-            }
-            await _connector.WriteBatchAsync(IdentitiesToWrite);
-
-            _connector.Logger.Information("Reading identities done.");
             _connector.Logger.Information(
                 $"Number of identities: {_identitiesTags.Count} | Unique :{_identities.Count}");
         }
 
         return _identitiesTags;
     }
 
+
+    /// <summary>
+    /// Assigns identities to all elements.
+    /// </summary>
+    /// <param name="identities">Identities</param>
+    /// <param name="identityProvider">Identity creator.</param>
+    /// <returns></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.
+        identityProvider ??= (x) => x.Cyclic = (ulong)x.Symbol.GetHashCode();
+
+        _connector.Logger.Information("Assigning missing identities...");
+        foreach (var it in identities)
+        {
+            it.Cyclic = identityProvider(it);
+        }
+
+        return identities;
+    }
+
+    /// <summary>
+    /// Writes identities to the PLC.
+    /// </summary>
+    /// <param name="identitiesToWrite">List of identities to be written.</param>
+    /// <returns></returns>
+    public async Task WriteIdentities(IEnumerable<OnlinerULInt> identitiesToWrite)
+    {
+        if(_connector == null) return;
+        await _connector.WriteBatchAsync(identitiesToWrite);
+        _connector.Logger.Information("Identities have been written.");
+    }
+
     /// <summary>
     ///     Refreshes and sorts identities.
     /// </summary>
-    public async Task ConstructIdentitiesAsync()
+    public async Task ConstructIdentitiesAsync(Func<OnlinerULInt, ulong> identityProvider = null)
     {
-        await ReadIdentitiesAsync();
+        await WriteIdentities(AssignIdentities(await ReadIdentitiesAsync(), identityProvider));
         await SortIdentitiesAsync();
     }
 
@@ -243,10 +255,29 @@ await Task.Run(() =>
             {
                 var key = identity.Key.LastValue == 0 ? identity.Key.GetAsync().Result : 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>
+/// Exception thrown when a duplicate identity is detected.
+/// </summary>
+public class DuplicateIdentityException : Exception
+{
+    public DuplicateIdentityException(string message) : base(message)
+    {
+    }
 }