Fixed usage of ConcurrentDictionary<TKey, TValue> to use Lazy<T> when it matters (Fixes #114) (#117)

* ICU4N.Impl.PluralRulesLoader::GetRulesForRulesId(): Changed to use Lazy<PluralRules?> for the ConcurrentDictionary value to ensure that only the first thread can build a PluralRules instance.

* ICU4N.Util.VersionInfo::GetInstance(): Use Lazy<VersionInfo> for the cache value to ensure all threads share the same instance. They are compared using reference equality, so this is important.

* ICU4N.Text.NormalizationTransliterator: Changed SOURCE_CACHE to use Lazy<SourceTargetUtility> to match the upstream code, which held a lock to ensure the cache is populated by only one thread.

Author: NightOwl888

src/ICU4N.Transliterator/Text/NormalizationTransliterator.cs

@@ -174,7 +174,7 @@ protected override void HandleTransliterate(IReplaceable text,
             offsets.Limit = limit;
         }
 
-        internal static readonly ConcurrentDictionary<Normalizer2, SourceTargetUtility> SOURCE_CACHE = new ConcurrentDictionary<Normalizer2, SourceTargetUtility>();
+        internal static readonly ConcurrentDictionary<Normalizer2, Lazy<SourceTargetUtility>> SOURCE_CACHE = new ConcurrentDictionary<Normalizer2, Lazy<SourceTargetUtility>>();
 
         // TODO Get rid of this if Normalizer2 becomes a Transform
         internal class NormalizingTransform : ITransform<string, string>
@@ -196,7 +196,8 @@ public virtual string Transform(string source)
         public override void AddSourceTargetSet(UnicodeSet inputFilter, UnicodeSet sourceSet, UnicodeSet targetSet)
 #pragma warning restore 672
         {
-            SourceTargetUtility cache = SOURCE_CACHE.GetOrAdd(norm2, (norm2) => new SourceTargetUtility(new NormalizingTransform(norm2), norm2));
+            SourceTargetUtility cache = SOURCE_CACHE.GetOrAdd(norm2, (norm2) =>
+                new Lazy<SourceTargetUtility>(() => new SourceTargetUtility(new NormalizingTransform(norm2), norm2))).Value;
             cache.AddSourceTargetSet(this, inputFilter, sourceSet, targetSet);
         }
     }

src/ICU4N/Impl/PluralRulesLoader.cs

@@ -20,7 +20,7 @@ internal class PluralRulesLoader // ICU4N: Marked internal until implementation
         : PluralRulesFactory
 #pragma warning restore 612, 618
     {
-        private readonly ConcurrentDictionary<string, PluralRules?> rulesIdToRules = new ConcurrentDictionary<string, PluralRules?>();
+        private readonly ConcurrentDictionary<string, Lazy<PluralRules?>> rulesIdToRules = new ConcurrentDictionary<string, Lazy<PluralRules?>>();
         // lazy init, use getLocaleIdToRulesIdMap to access
         private IDictionary<string, string>? localeIdToCardinalRulesId;
         private IDictionary<string, string>? localeIdToOrdinalRulesId;
@@ -229,8 +229,8 @@ private IDictionary<string, UCultureInfo> LoadRulesIdMaps()
             if (rulesId is null)
                 throw new ArgumentNullException(nameof(rulesId));
 
-            return rulesIdToRules.GetOrAdd(rulesId, (key) => {
-
+            var rules = rulesIdToRules.GetOrAdd(rulesId, (key) => new Lazy<PluralRules?>(() =>
+            {
                 UResourceBundle setb;
                 try
                 {
@@ -245,7 +245,7 @@ private IDictionary<string, UCultureInfo> LoadRulesIdMaps()
 
                 var ruleList = new PluralRules.RuleList();
                 bool parseFailure = false;
-                for (int i = 0; i < setb.Length; ++i)
+                for (int i = 0; i < setb.Length && !parseFailure; ++i)
                 {
                     UResourceBundle b = setb.Get(i);
                     if (PluralRules.TryParseRule(b.Key, b.GetString(), out PluralRules.Rule rule))
@@ -261,7 +261,9 @@ private IDictionary<string, UCultureInfo> LoadRulesIdMaps()
                     return null; // can be null
 
                 return new PluralRules(ruleList.Finish());
-            });
+            }));
+
+            return rules.Value;
         }
 
         /// <summary>
@@ -289,11 +291,11 @@ public override PluralRules GetInstance(string localeName, PluralType type)
                 throw new ArgumentNullException(nameof(localeName));
 
             string? rulesId = GetRulesIdForLocale(localeName, type);
-            if (rulesId == null || rulesId.Trim().Length == 0)
+            if (string.IsNullOrWhiteSpace(rulesId))
             {
                 return PluralRules.Default;
             }
-            PluralRules? rules = GetRulesForRulesId(rulesId);
+            PluralRules? rules = GetRulesForRulesId(rulesId!); // [!] Checked for null above
             if (rules == null)
             {
                 rules = PluralRules.Default;

src/ICU4N/Util/VersionInfo.cs

@@ -15,7 +15,7 @@ public sealed class VersionInfo : IComparable<VersionInfo>
         /// <summary>
         /// Map of singletons
         /// </summary>
-        private static readonly ConcurrentDictionary<int, VersionInfo> MAP_ = new ConcurrentDictionary<int, VersionInfo>();
+        private static readonly ConcurrentDictionary<int, Lazy<VersionInfo>> MAP_ = new ConcurrentDictionary<int, Lazy<VersionInfo>>();
 
         // public data members -------------------------------------------------
 
@@ -333,7 +333,7 @@ public static VersionInfo GetInstance(int major, int minor, int milli,
             int key = GetInt32(major, minor, milli, micro);
             int version = key;
 
-            return MAP_.GetOrAdd(version, (version) => new VersionInfo(version));
+            return MAP_.GetOrAdd(version, (version) => new Lazy<VersionInfo>(() => new VersionInfo(version))).Value;
         }
 
         /// <summary>