Handle null case for the importedMembershipOperation and provided answer about PR's comments

Author: antoineatstariongroup

SysML2.NET/Comparer/NullableStringEqualityComparer.cs

@@ -0,0 +1,65 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="NullableStringEqualityComparer.cs" company="Starion Group S.A.">
+// 
+//   Copyright 2022-2026 Starion Group S.A.
+// 
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+// 
+//        http://www.apache.org/licenses/LICENSE-2.0
+// 
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// 
+// </copyright>
+// ------------------------------------------------------------------------------------------------
+
+namespace SysML2.NET.Comparer
+{
+    using System;
+    using System.Collections.Generic;
+
+    /// <summary>
+    /// Provides equality comparison for string, handling null case
+    /// </summary>
+    public sealed class NullSafeStringComparer : IEqualityComparer<string>
+    {
+        /// <summary>Determines whether the specified objects are equal.</summary>
+        /// <param name="x">The first object of type <paramref name="T" /> to compare.</param>
+        /// <param name="y">The second object of type <paramref name="T" /> to compare.</param>
+        /// <returns>
+        /// <see langword="true" /> if the specified objects are equal; otherwise, <see langword="false" />.</returns>
+        public bool Equals(string x, string y)
+        {
+            if (x == null && y == null)
+            {
+                return true;
+            }
+
+            if (x == null || y == null)
+            {
+                return false;
+            }
+
+            return string.Equals(x, y, StringComparison.Ordinal);
+        }
+
+        /// <summary>Returns a hash code for the specified object.</summary>
+        /// <param name="obj">The <see cref="T:System.Object" /> for which a hash code is to be returned.</param>
+        /// <returns>A hash code for the specified object.</returns>
+        /// <exception cref="T:System.ArgumentNullException">The type of <paramref name="obj" /> is a reference type and <paramref name="obj" /> is <see langword="null" />.</exception>
+        public int GetHashCode(string? obj)
+        {
+            return obj?.GetHashCode() ?? 0;
+        }
+
+        /// <summary>
+        /// Gets the instance of the <see cref="NullSafeStringComparer"/>
+        /// </summary>
+        public static readonly NullSafeStringComparer Instance = new();
+    }
+}

SysML2.NET/Extend/ElementExtensions.cs

@@ -253,7 +253,7 @@ internal static string ComputeEscapedNameOperation(this IElement elementSubject)
                 return null;
             }
 
-            return targetName.QueryIsBasicName() ? targetName : targetName.ToUnrestrictedName();
+            return targetName.QueryIsValidBasicName() ? targetName : targetName.ToUnrestrictedName();
         }
 
         /// <summary>

SysML2.NET/Extend/NamespaceExtensions.cs

@@ -25,6 +25,7 @@ namespace SysML2.NET.Core.POCO.Root.Namespaces
     using System.Collections.Generic;
     using System.Linq;
 
+    using SysML2.NET.Comparer;
     using SysML2.NET.Core.Root.Namespaces;
     using SysML2.NET.Core.POCO.Root.Annotations;
     using SysML2.NET.Core.POCO.Root.Elements;
@@ -213,18 +214,17 @@ internal static List<IMembership> ComputeImportedMembershipsOperation(this IName
 
             var ownedMembershipNames = namespaceSubject.ownedMembership
                 .Select(m => m.MemberName)
-                .Where(name => name != null)
-                .ToHashSet(StringComparer.Ordinal);
+                .ToHashSet(NullSafeStringComparer.Instance);
 
             var importedMembershipsNameFrequency = importedMemberships
-                .GroupBy(x => x.MemberName, StringComparer.Ordinal)
-                .ToFrozenDictionary(g => g.Key, g => g.Count(),  StringComparer.Ordinal);
+                .GroupBy(x => x.MemberName, NullSafeStringComparer.Instance)
+                .ToFrozenDictionary(g => g.Key, g => g.Count(), NullSafeStringComparer.Instance);
 
             var nonCollidingImportedMemberships = importedMemberships.Where(x =>
             {
                 var name = x.MemberName;
 
-                return !string.IsNullOrWhiteSpace(name) && !ownedMembershipNames.Contains(name) && (!importedMembershipsNameFrequency.TryGetValue(name, out var frequency) || frequency <= 1);
+                return !ownedMembershipNames.Contains(name) && (!importedMembershipsNameFrequency.TryGetValue(name, out var frequency) || frequency <= 1);
             }).ToList();
 
             return nonCollidingImportedMemberships;

SysML2.NET/Extensions/StringExtensions.cs

@@ -35,7 +35,7 @@ public static class StringExtensions
         /// </summary>
         /// <param name="name">The name to verifies</param>
         /// <returns><c>true</c> if the name is a basic name, <c>false</c> otherwise</returns>
-        public static bool QueryIsBasicName(this string name)
+        public static bool QueryIsValidBasicName(this string name)
         {
             return Regex.IsMatch(name, "^[a-zA-Z_][a-zA-Z0-9_]*$") && !Keywords.ReservedKeywords.Contains(name);
         }