Use separate hashtables for collectible types to support assembly unloadability for the TypeDescriptor class

Author: alexey-zakharov

src/libraries/System.ComponentModel.TypeConverter/System.ComponentModel.TypeConverter.slnx

@@ -263,6 +263,9 @@
       <Build Solution="Checked|x64" Project="false" />
       <Build Solution="Checked|x86" Project="false" />
     </Project>
+    <Project Path="tests/UnloadableTestTypes/UnloadableTestTypes.csproj">
+      <BuildType Solution="Checked|*" Project="Release" />
+    </Project>
   </Folder>
   <Folder Name="/tools/" />
   <Folder Name="/tools/gen/">

src/libraries/System.ComponentModel.TypeConverter/src/System.ComponentModel.TypeConverter.csproj

@@ -15,6 +15,7 @@
     <Compile Include="System\ComponentModel\ByteConverter.cs" />
     <Compile Include="System\ComponentModel\CharConverter.cs" />
     <Compile Include="System\ComponentModel\CollectionConverter.cs" />
+    <Compile Include="System\ComponentModel\ContextAwareConcurrentHashtable.cs" />
     <Compile Include="System\ComponentModel\DateOnlyConverter.cs" />
     <Compile Include="System\ComponentModel\DateTimeConverter.cs" />
     <Compile Include="System\ComponentModel\DateTimeOffsetConverter.cs" />
@@ -44,6 +45,7 @@
     <Compile Include="System\ComponentModel\UInt64Converter.cs" />
     <Compile Include="System\ComponentModel\UriTypeConverter.cs" />
     <Compile Include="System\ComponentModel\VersionConverter.cs" />
+    <Compile Include="System\ComponentModel\ContextAwareHashtable.cs" />
     <Compile Include="System\Timers\ElapsedEventArgs.cs" />
     <Compile Include="System\Timers\ElapsedEventHandler.cs" />
     <Compile Include="System\Timers\Timer.cs">

src/libraries/System.ComponentModel.TypeConverter/src/System/ComponentModel/ContextAwareConcurrentHashtable.cs

@@ -0,0 +1,137 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Collections;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Reflection;
+using System.Runtime.CompilerServices;
+
+namespace System.ComponentModel
+{
+    /// <summary>
+    /// Concurrent dictionary that maps MemberInfo object key to an object.
+    /// Uses ConditionalWeakTable for the collectible keys (if MemberInfo.IsCollectible is true) and
+    /// ConcurrentDictionary for non-collectible keys.
+    /// </summary>
+    internal sealed class ContextAwareConcurrentHashtable<TKey, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)] TValue> : IEnumerable<KeyValuePair<TKey, TValue>>
+        where TKey : MemberInfo
+        where TValue : class?
+    {
+        private readonly ConcurrentDictionary<TKey, TValue> _defaultTable = new ConcurrentDictionary<TKey, TValue>();
+        private readonly ConditionalWeakTable<TKey, object?> _collectibleTable = new ConditionalWeakTable<TKey, object?>();
+
+        public TValue? this[TKey key]
+        {
+            get
+            {
+                return TryGetValue(key, out TValue? value) ? value : default;
+            }
+
+            set
+            {
+                if (!key.IsCollectible)
+                {
+                    _defaultTable[key] = value!;
+                }
+                else
+                {
+                    _collectibleTable.AddOrUpdate(key, value!);
+                }
+            }
+        }
+
+        public bool Contains(TKey key)
+        {
+            return !key.IsCollectible ? _defaultTable.ContainsKey(key) : _collectibleTable.TryGetValue(key, out _);
+        }
+
+        public bool TryGetValue(TKey key, [MaybeNullWhen(false)] out TValue value)
+        {
+            if (!key.IsCollectible)
+                return _defaultTable.TryGetValue(key, out value);
+
+            if (_collectibleTable.TryGetValue(key, out object? valueObj) && valueObj != null)
+            {
+                value = (TValue)valueObj;
+                return true;
+            }
+
+            value = default;
+            return false;
+        }
+
+        public bool TryAdd(TKey key, TValue value)
+        {
+            return !key.IsCollectible
+                ? _defaultTable.TryAdd(key, value)
+                : _collectibleTable.TryAdd(key, value);
+        }
+
+        public void Clear()
+        {
+            _defaultTable.Clear();
+            _collectibleTable.Clear();
+        }
+
+        public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator() =>
+            new Enumerator(_defaultTable.GetEnumerator(), ((IEnumerable<KeyValuePair<TKey, object?>>)_collectibleTable).GetEnumerator());
+
+        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+
+        private sealed class Enumerator : IEnumerator<KeyValuePair<TKey, TValue>>
+        {
+            private readonly IEnumerator<KeyValuePair<TKey, TValue>> _defaultEnumerator;
+            private readonly IEnumerator<KeyValuePair<TKey, object?>> _collectibleEnumerator;
+            private bool _enumeratingCollectibleEnumerator;
+
+            public Enumerator(IEnumerator<KeyValuePair<TKey, TValue>> defaultEnumerator, IEnumerator<KeyValuePair<TKey, object?>> collectibleEnumerator)
+            {
+                _defaultEnumerator = defaultEnumerator;
+                _collectibleEnumerator = collectibleEnumerator;
+                _enumeratingCollectibleEnumerator = false;
+            }
+
+            public KeyValuePair<TKey, TValue> Current { get; private set; }
+
+            object IEnumerator.Current => Current;
+
+            public void Dispose()
+            {
+                _defaultEnumerator.Dispose();
+                _collectibleEnumerator.Dispose();
+            }
+
+            public bool MoveNext()
+            {
+                if (!_enumeratingCollectibleEnumerator && _defaultEnumerator.MoveNext())
+                {
+                    Current = _defaultEnumerator.Current;
+                    return true;
+                }
+
+                _enumeratingCollectibleEnumerator = true;
+
+                while (_collectibleEnumerator.MoveNext())
+                {
+                    if (_collectibleEnumerator.Current.Value is TValue value)
+                    {
+                        Current = new KeyValuePair<TKey, TValue>(_collectibleEnumerator.Current.Key, value);
+                        return true;
+                    }
+                }
+
+                Current = default;
+                return false;
+            }
+
+            public void Reset()
+            {
+                _defaultEnumerator.Reset();
+                _collectibleEnumerator.Reset();
+                Current = default;
+            }
+        }
+    }
+}

src/libraries/System.ComponentModel.TypeConverter/src/System/ComponentModel/ContextAwareHashtable.cs

@@ -0,0 +1,40 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Collections;
+using System.Reflection;
+using System.Runtime.CompilerServices;
+
+namespace System.ComponentModel
+{
+    /// <summary>
+    /// Hashtable that maps MemberInfo object key to an object and
+    /// uses a WeakReference for the collectible keys (if MemberInfo.IsCollectible is true).
+    /// Uses a Hashtable for non-collectible keys and WeakHashtable for the collectible keys.
+    /// </summary>
+    internal sealed class ContextAwareHashtable
+    {
+        private readonly Hashtable _defaultTable = new Hashtable();
+        private readonly ConditionalWeakTable<object, object> _collectibleTable = new ConditionalWeakTable<object, object>();
+
+        public object? this[MemberInfo key]
+        {
+            get
+            {
+                return !key.IsCollectible ? _defaultTable[key] : (_collectibleTable.TryGetValue(key, out object? value) ? value : null);
+            }
+
+            set
+            {
+                if (!key.IsCollectible)
+                {
+                    _defaultTable[key] = value!;
+                }
+                else
+                {
+                    _collectibleTable.AddOrUpdate(key, value!);
+                }
+            }
+        }
+    }
+}

src/libraries/System.ComponentModel.TypeConverter/src/System/ComponentModel/ReflectTypeDescriptionProvider.cs

@@ -3,7 +3,6 @@
 
 using System.Collections;
 using System.Collections.Generic;
-using System.Collections.Concurrent;
 using System.ComponentModel.Design;
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
@@ -24,7 +23,7 @@ namespace System.ComponentModel
     internal sealed partial class ReflectTypeDescriptionProvider : TypeDescriptionProvider
     {
         // ReflectedTypeData contains all of the type information we have gathered for a given type.
-        private readonly ConcurrentDictionary<Type, ReflectedTypeData> _typeData = new ConcurrentDictionary<Type, ReflectedTypeData>();
+        private readonly ContextAwareConcurrentHashtable<Type, ReflectedTypeData> _typeData = new ContextAwareConcurrentHashtable<Type, ReflectedTypeData>();
 
         // This is the signature we look for when creating types that are generic, but
         // want to know what type they are dealing with. Enums are a good example of this;
@@ -49,10 +48,10 @@ internal sealed partial class ReflectTypeDescriptionProvider : TypeDescriptionPr
         // on Control, Component and object are also automatically filled
         // in. The keys to the property and event caches are types.
         // The keys to the attribute cache are either MemberInfos or types.
-        private static Hashtable? s_propertyCache;
-        private static Hashtable? s_eventCache;
-        private static Hashtable? s_attributeCache;
-        private static Hashtable? s_extendedPropertyCache;
+        private static ContextAwareHashtable? s_propertyCache;
+        private static ContextAwareHashtable? s_eventCache;
+        private static ContextAwareHashtable? s_attributeCache;
+        private static ContextAwareHashtable? s_extendedPropertyCache;
 
         // These are keys we stuff into our object cache. We use this
         // cache data to store extender provider info for an object.
@@ -193,13 +192,13 @@ private static Dictionary<object, IntrinsicTypeConverterData> IntrinsicTypeConve
             Justification = "IntrinsicTypeConverters is marked with RequiresUnreferencedCode. It is the only place that should call this.")]
         private static NullableConverter CreateNullableConverter(Type type) => new NullableConverter(type);
 
-        private static Hashtable PropertyCache => LazyInitializer.EnsureInitialized(ref s_propertyCache, () => new Hashtable());
+        private static ContextAwareHashtable PropertyCache => LazyInitializer.EnsureInitialized(ref s_propertyCache, () => new ContextAwareHashtable());
 
-        private static Hashtable EventCache => LazyInitializer.EnsureInitialized(ref s_eventCache, () => new Hashtable());
+        private static ContextAwareHashtable EventCache => LazyInitializer.EnsureInitialized(ref s_eventCache, () => new ContextAwareHashtable());
 
-        private static Hashtable AttributeCache => LazyInitializer.EnsureInitialized(ref s_attributeCache, () => new Hashtable());
+        private static ContextAwareHashtable AttributeCache => LazyInitializer.EnsureInitialized(ref s_attributeCache, () => new ContextAwareHashtable());
 
-        private static Hashtable ExtendedPropertyCache => LazyInitializer.EnsureInitialized(ref s_extendedPropertyCache, () => new Hashtable());
+        private static ContextAwareHashtable ExtendedPropertyCache => LazyInitializer.EnsureInitialized(ref s_extendedPropertyCache, () => new ContextAwareHashtable());
 
         /// <summary>Clear the global caches this maintains on top of reflection.</summary>
         internal static void ClearReflectionCaches()
@@ -982,14 +981,14 @@ private ReflectedTypeData GetTypeDataFromRegisteredType(Type type)
         {
             Type componentType = typeof(T);
 
-            if (_typeData.ContainsKey(componentType))
+            if (_typeData.Contains(componentType))
             {
                 return;
             }
 
             lock (TypeDescriptor.s_commonSyncObject)
             {
-                if (_typeData.ContainsKey(componentType))
+                if (_typeData.Contains(componentType))
                 {
                     return;
                 }
@@ -1096,7 +1095,7 @@ internal bool IsPopulated(Type type)
         /// </summary>
         internal static Attribute[] ReflectGetAttributes(Type type)
         {
-            Hashtable attributeCache = AttributeCache;
+            ContextAwareHashtable attributeCache = AttributeCache;
             Attribute[]? attrs = (Attribute[]?)attributeCache[type];
             if (attrs != null)
             {
@@ -1124,7 +1123,7 @@ internal static Attribute[] ReflectGetAttributes(Type type)
         /// </summary>
         internal static Attribute[] ReflectGetAttributes(MemberInfo member)
         {
-            Hashtable attributeCache = AttributeCache;
+            ContextAwareHashtable attributeCache = AttributeCache;
             Attribute[]? attrs = (Attribute[]?)attributeCache[member];
             if (attrs != null)
             {
@@ -1152,7 +1151,7 @@ internal static Attribute[] ReflectGetAttributes(MemberInfo member)
         /// </summary>
         private static EventDescriptor[] ReflectGetEvents(Type type)
         {
-            Hashtable eventCache = EventCache;
+            ContextAwareHashtable eventCache = EventCache;
             EventDescriptor[]? events = (EventDescriptor[]?)eventCache[type];
             if (events != null)
             {
@@ -1252,7 +1251,7 @@ private static PropertyDescriptor[] ReflectGetExtendedProperties(IExtenderProvid
             // property store.
             //
             Type providerType = provider.GetType();
-            Hashtable extendedPropertyCache = ExtendedPropertyCache;
+            ContextAwareHashtable extendedPropertyCache = ExtendedPropertyCache;
             ReflectPropertyDescriptor[]? extendedProperties = (ReflectPropertyDescriptor[]?)extendedPropertyCache[providerType];
             if (extendedProperties == null)
             {
@@ -1337,7 +1336,7 @@ private static PropertyDescriptor[] ReflectGetPropertiesFromRegisteredType(Type
 
         private static PropertyDescriptor[] ReflectGetPropertiesImpl(Type type)
         {
-            Hashtable propertyCache = PropertyCache;
+            ContextAwareHashtable propertyCache = PropertyCache;
             PropertyDescriptor[]? properties = (PropertyDescriptor[]?)propertyCache[type];
             if (properties != null)
             {

src/libraries/System.ComponentModel.TypeConverter/src/System/ComponentModel/TypeDescriptor.cs

@@ -2,8 +2,6 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.Collections;
-using System.Collections.Concurrent;
-using System.Collections.Generic;
 using System.Collections.Specialized;
 using System.ComponentModel.Design;
 using System.Diagnostics;
@@ -67,12 +65,12 @@ public sealed class TypeDescriptor
         internal static readonly object s_commonSyncObject = new object();
 
         // A direct mapping from type to provider.
-        private static readonly ConcurrentDictionary<Type, TypeDescriptionNode> s_providerTypeTable = new ConcurrentDictionary<Type, TypeDescriptionNode>();
+        private static readonly ContextAwareConcurrentHashtable<Type, TypeDescriptionNode> s_providerTypeTable = new ContextAwareConcurrentHashtable<Type, TypeDescriptionNode>();
 
         // Tracks DefaultTypeDescriptionProviderAttributes.
         // A value of `null` indicates initialization is in progress.
         // A value of s_initializedDefaultProvider indicates the provider is initialized.
-        private static readonly ConcurrentDictionary<Type, object?> s_defaultProviderInitialized = new ConcurrentDictionary<Type, object?>();
+        private static readonly ContextAwareConcurrentHashtable<Type, object?> s_defaultProviderInitialized = new ContextAwareConcurrentHashtable<Type, object?>();
 
         private static readonly object s_initializedDefaultProvider = new object();
 
@@ -293,7 +291,7 @@ public static void AddProvider(TypeDescriptionProvider provider, object instance
                 refreshNeeded = s_providerTable.ContainsKey(instance);
                 TypeDescriptionNode node = NodeFor(instance, true);
                 var head = new TypeDescriptionNode(provider) { Next = node };
-                s_providerTable.SetWeak(instance, head);
+                s_providerTable[instance] = head;
                 s_providerTypeTable.Clear();
             }
 
@@ -363,7 +361,7 @@ private static void AddDefaultProvider(Type type)
         {
             bool providerAdded = false;
 
-            if (s_defaultProviderInitialized.ContainsKey(type))
+            if (s_defaultProviderInitialized.Contains(type))
             {
                 // Either another thread finished initializing for this type, or we are recursing on the same thread.
                 return;
@@ -433,7 +431,7 @@ public static void CreateAssociation(object primary, object secondary)
                     if (associations == null)
                     {
                         associations = new ArrayList(4);
-                        associationTable.SetWeak(primary, associations);
+                        associationTable[primary] = associations;
                     }
                 }
             }