Merge commit 'a12ce66d5f84bdb07074452dca7912d04a790774'

Mirroring · Mirroring · commit b357f86ce3bc · 2024-09-10T03:11:37.000Z
diff --git a/eng/pipelines/coreclr/templates/helix-queues-setup.yml b/eng/pipelines/coreclr/templates/helix-queues-setup.yml
@@ -32,7 +32,7 @@ jobs:
 
     # Android arm64
     - ${{ if in(parameters.platform, 'Android_arm64') }}:
-      - Windows.10.Amd64.Android.Open
+      - Windows.11.Amd64.Android.Open
 
     # Android x64
     - ${{ if in(parameters.platform, 'Android_x64') }}:
diff --git a/eng/pipelines/libraries/helix-queues-setup.yml b/eng/pipelines/libraries/helix-queues-setup.yml
@@ -95,7 +95,7 @@ jobs:
     - ${{ if in(parameters.platform, 'Android_x86', 'Android_x64') }}:
       - Ubuntu.2204.Amd64.Android.29.Open
     - ${{ if in(parameters.platform, 'Android_arm', 'Android_arm64') }}:
-      - Windows.10.Amd64.Android.Open
+      - Windows.11.Amd64.Android.Open
 
     # iOS Simulator/Mac Catalyst arm64
     - ${{ if in(parameters.platform, 'MacCatalyst_arm64', 'iOSSimulator_arm64') }}:
diff --git a/src/libraries/Native/Unix/System.Security.Cryptography.Native.Apple/pal_x509_macos.c b/src/libraries/Native/Unix/System.Security.Cryptography.Native.Apple/pal_x509_macos.c
@@ -391,7 +391,7 @@ int32_t AppleCryptoNative_X509CopyWithPrivateKey(SecCertificateRef cert,
     SecKeychainItemRef itemCopy = NULL;
 
     // This only happens with an ephemeral key, so the keychain we're adding it to is temporary.
-    if (status == errSecNoSuchKeychain)
+    if (status == errSecNoSuchKeychain || status == errSecInvalidItemRef)
     {
         status = AddKeyToKeychain(privateKey, targetKeychain, NULL);
     }
diff --git a/src/libraries/System.ComponentModel.TypeConverter/src/System.ComponentModel.TypeConverter.csproj b/src/libraries/System.ComponentModel.TypeConverter/src/System.ComponentModel.TypeConverter.csproj
@@ -240,6 +240,7 @@
   </ItemGroup>
   <ItemGroup>
     <Reference Include="System.Collections" />
+    <Reference Include="System.Collections.Concurrent" />
     <Reference Include="System.Collections.NonGeneric" />
     <Reference Include="System.Collections.Specialized" />
     <Reference Include="System.ComponentModel" />
diff --git a/src/libraries/System.ComponentModel.TypeConverter/src/System/ComponentModel/PropertyDescriptor.cs b/src/libraries/System.ComponentModel.TypeConverter/src/System/ComponentModel/PropertyDescriptor.cs
@@ -2,8 +2,11 @@
 // 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.Threading;
 
 namespace System.ComponentModel
 {
@@ -15,10 +18,11 @@ public abstract class PropertyDescriptor : MemberDescriptor
         internal const string PropertyDescriptorPropertyTypeMessage = "PropertyDescriptor's PropertyType cannot be statically discovered.";
 
         private TypeConverter? _converter;
-        private Hashtable? _valueChangedHandlers;
+        private ConcurrentDictionary<object, EventHandler?>? _valueChangedHandlers;
         private object?[]? _editors;
         private Type[]? _editorTypes;
         private int _editorCount;
+        private object? _syncObject;
 
         /// <summary>
         /// Initializes a new instance of the <see cref='System.ComponentModel.PropertyDescriptor'/> class with the specified name and
@@ -48,6 +52,8 @@ protected PropertyDescriptor(MemberDescriptor descr, Attribute[]? attrs) : base(
         {
         }
 
+        private object SyncObject => LazyInitializer.EnsureInitialized(ref _syncObject);
+
         /// <summary>
         /// When overridden in a derived class, gets the type of the
         /// component this property is bound to.
@@ -132,13 +138,11 @@ public virtual void AddValueChanged(object component, EventHandler handler)
                 throw new ArgumentNullException(nameof(handler));
             }
 
-            if (_valueChangedHandlers == null)
+            lock (SyncObject)
             {
-                _valueChangedHandlers = new Hashtable();
+                _valueChangedHandlers ??= new ConcurrentDictionary<object, EventHandler?>(concurrencyLevel: 1, capacity: 0);
+                _valueChangedHandlers.AddOrUpdate(component, handler, (k, v) => (EventHandler?)Delegate.Combine(v, handler));
             }
-
-            EventHandler? h = (EventHandler?)_valueChangedHandlers[component];
-            _valueChangedHandlers[component] = Delegate.Combine(h, handler);
         }
 
         /// <summary>
@@ -392,7 +396,7 @@ protected virtual void OnValueChanged(object? component, EventArgs e)
         {
             if (component != null)
             {
-                ((EventHandler?)_valueChangedHandlers?[component])?.Invoke(component, e);
+                _valueChangedHandlers?.GetValueOrDefault(component, defaultValue: null)?.Invoke(component, e);
             }
         }
 
@@ -412,15 +416,18 @@ public virtual void RemoveValueChanged(object component, EventHandler handler)
 
             if (_valueChangedHandlers != null)
             {
-                EventHandler? h = (EventHandler?)_valueChangedHandlers[component];
-                h = (EventHandler?)Delegate.Remove(h, handler);
-                if (h != null)
-                {
-                    _valueChangedHandlers[component] = h;
-                }
-                else
+                lock (SyncObject)
                 {
-                    _valueChangedHandlers.Remove(component);
+                    EventHandler? h = _valueChangedHandlers.GetValueOrDefault(component, defaultValue: null);
+                    h = (EventHandler?)Delegate.Remove(h, handler);
+                    if (h != null)
+                    {
+                        _valueChangedHandlers[component] = h;
+                    }
+                    else
+                    {
+                        _valueChangedHandlers.TryRemove(component, out EventHandler? _);
+                    }
                 }
             }
         }
@@ -434,7 +441,7 @@ public virtual void RemoveValueChanged(object component, EventHandler handler)
         {
             if (component != null && _valueChangedHandlers != null)
             {
-                return (EventHandler?)_valueChangedHandlers[component];
+                return _valueChangedHandlers.GetValueOrDefault(component, defaultValue: null);
             }
             else
             {
diff --git a/src/libraries/System.ComponentModel.TypeConverter/src/System/ComponentModel/ReflectTypeDescriptionProvider.cs b/src/libraries/System.ComponentModel.TypeConverter/src/System/ComponentModel/ReflectTypeDescriptionProvider.cs
@@ -3,6 +3,7 @@
 
 using System.Collections;
 using System.Collections.Generic;
+using System.Collections.Concurrent;
 using System.ComponentModel.Design;
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
@@ -23,10 +24,8 @@ namespace System.ComponentModel
     /// </summary>
     internal sealed partial class ReflectTypeDescriptionProvider : TypeDescriptionProvider
     {
-        // Hastable of Type -> ReflectedTypeData. ReflectedTypeData contains all
-        // of the type information we have gathered for a given type.
-        //
-        private Hashtable? _typeData;
+        // ReflectedTypeData contains all of the type information we have gathered for a given type.
+        private readonly ConcurrentDictionary<Type, ReflectedTypeData> _typeData = new ConcurrentDictionary<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;
@@ -81,8 +80,6 @@ internal sealed partial class ReflectTypeDescriptionProvider : TypeDescriptionPr
 
         internal static Guid ExtenderProviderKey { get; } = Guid.NewGuid();
 
-
-        private static readonly object s_internalSyncObject = new object();
         /// <summary>
         /// Creates a new ReflectTypeDescriptionProvider. The type is the
         /// type we will obtain type information for.
@@ -234,7 +231,7 @@ internal static void AddEditorTable(Type editorBaseType, Hashtable table)
                 // don't throw; RTM didn't so we can't do it either.
             }
 
-            lock (s_internalSyncObject)
+            lock (TypeDescriptor.s_commonSyncObject)
             {
                 Hashtable editorTables = EditorTables;
                 if (!editorTables.ContainsKey(editorBaseType))
@@ -289,7 +286,6 @@ internal static void AddEditorTable(Type editorBaseType, Hashtable table)
             return obj ?? Activator.CreateInstance(objectType, args);
         }
 
-
         /// <summary>
         /// Helper method to create editors and type converters. This checks to see if the
         /// type implements a Type constructor, and if it does it invokes that ctor.
@@ -421,7 +417,7 @@ internal TypeConverter GetConverter([DynamicallyAccessedMembers(DynamicallyAcces
                 //
                 if (table == null)
                 {
-                    lock (s_internalSyncObject)
+                    lock (TypeDescriptor.s_commonSyncObject)
                     {
                         table = editorTables[editorBaseType];
                         if (table == null)
@@ -838,22 +834,11 @@ internal Type[] GetPopulatedTypes(Module module)
         {
             List<Type> typeList = new List<Type>();
 
-            lock (s_internalSyncObject)
+            foreach (KeyValuePair<Type, ReflectedTypeData> kvp in _typeData)
             {
-                Hashtable? typeData = _typeData;
-                if (typeData != null)
+                if (kvp.Key.Module == module && kvp.Value!.IsPopulated)
                 {
-                    // Manual use of IDictionaryEnumerator instead of foreach to avoid DictionaryEntry box allocations.
-                    IDictionaryEnumerator e = typeData.GetEnumerator();
-                    while (e.MoveNext())
-                    {
-                        DictionaryEntry de = e.Entry;
-                        Type type = (Type)de.Key;
-                        if (type.Module == module && ((ReflectedTypeData)de.Value!).IsPopulated)
-                        {
-                            typeList.Add(type);
-                        }
-                    }
+                    typeList.Add(kvp.Key);
                 }
             }
 
@@ -898,31 +883,23 @@ public override Type GetReflectionType(
         /// </summary>
         private ReflectedTypeData? GetTypeData([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)] Type type, bool createIfNeeded)
         {
-            ReflectedTypeData? td = null;
-
-            if (_typeData != null)
+            if (_typeData.TryGetValue(type, out ReflectedTypeData? td))
             {
-                td = (ReflectedTypeData?)_typeData[type];
-                if (td != null)
-                {
-                    return td;
-                }
+                Debug.Assert(td != null);
+                return td;
             }
 
-            lock (s_internalSyncObject)
+            lock (TypeDescriptor.s_commonSyncObject)
             {
-                if (_typeData != null)
+                if (_typeData.TryGetValue(type, out td))
                 {
-                    td = (ReflectedTypeData?)_typeData[type];
+                    Debug.Assert(td != null);
+                    return td;
                 }
 
-                if (td == null && createIfNeeded)
+                if (createIfNeeded)
                 {
                     td = new ReflectedTypeData(type);
-                    if (_typeData == null)
-                    {
-                        _typeData = new Hashtable();
-                    }
                     _typeData[type] = td;
                 }
             }
@@ -1010,7 +987,7 @@ internal static Attribute[] ReflectGetAttributes(Type type)
                 return attrs;
             }
 
-            lock (s_internalSyncObject)
+            lock (TypeDescriptor.s_commonSyncObject)
             {
                 attrs = (Attribute[]?)attributeCache[type];
                 if (attrs == null)
@@ -1038,7 +1015,7 @@ internal static Attribute[] ReflectGetAttributes(MemberInfo member)
                 return attrs;
             }
 
-            lock (s_internalSyncObject)
+            lock (TypeDescriptor.s_commonSyncObject)
             {
                 attrs = (Attribute[]?)attributeCache[member];
                 if (attrs == null)
@@ -1067,7 +1044,7 @@ private static EventDescriptor[] ReflectGetEvents(
                 return events;
             }
 
-            lock (s_internalSyncObject)
+            lock (TypeDescriptor.s_commonSyncObject)
             {
                 events = (EventDescriptor[]?)eventCache[type];
                 if (events == null)
@@ -1164,7 +1141,7 @@ private static PropertyDescriptor[] ReflectGetExtendedProperties(IExtenderProvid
             ReflectPropertyDescriptor[]? extendedProperties = (ReflectPropertyDescriptor[]?)extendedPropertyCache[providerType];
             if (extendedProperties == null)
             {
-                lock (s_internalSyncObject)
+                lock (TypeDescriptor.s_commonSyncObject)
                 {
                     extendedProperties = (ReflectPropertyDescriptor[]?)extendedPropertyCache[providerType];
 
@@ -1244,7 +1221,7 @@ private static PropertyDescriptor[] ReflectGetProperties(
                 return properties;
             }
 
-            lock (s_internalSyncObject)
+            lock (TypeDescriptor.s_commonSyncObject)
             {
                 properties = (PropertyDescriptor[]?)propertyCache[type];
 
diff --git a/src/libraries/System.ComponentModel.TypeConverter/src/System/ComponentModel/TypeDescriptor.cs b/src/libraries/System.ComponentModel.TypeConverter/src/System/ComponentModel/TypeDescriptor.cs
diff --git a/src/libraries/System.ComponentModel.TypeConverter/tests/PropertyDescriptorTests.cs b/src/libraries/System.ComponentModel.TypeConverter/tests/PropertyDescriptorTests.cs

Original file line number	Diff line number	Diff line change
`@@ -391,7 +391,7 @@ int32_t AppleCryptoNative_X509CopyWithPrivateKey(SecCertificateRef cert,`
`391`	`391`	`SecKeychainItemRef itemCopy = NULL;`
`392`	`392`
`393`	`393`	`// This only happens with an ephemeral key, so the keychain we're adding it to is temporary.`
`394`		`- if (status == errSecNoSuchKeychain)`
	`394`	`+ if (status == errSecNoSuchKeychain \|\| status == errSecInvalidItemRef)`
`395`	`395`	`{`
`396`	`396`	`status = AddKeyToKeychain(privateKey, targetKeychain, NULL);`
`397`	`397`	`}`
Original file line number	Diff line number	Diff line change
`@@ -2,8 +2,11 @@`
`2`	`2`	`// The .NET Foundation licenses this file to you under the MIT license.`
`3`	`3`
`4`	`4`	`using System.Collections;`
	`5`	`+using System.Collections.Concurrent;`
	`6`	`+using System.Collections.Generic;`
`5`	`7`	`using System.Diagnostics.CodeAnalysis;`
`6`	`8`	`using System.Reflection;`
	`9`	`+using System.Threading;`
`7`	`10`
`8`	`11`	`namespace System.ComponentModel`
`9`	`12`	`{`
`@@ -15,10 +18,11 @@ public abstract class PropertyDescriptor : MemberDescriptor`
`15`	`18`	`internal const string PropertyDescriptorPropertyTypeMessage = "PropertyDescriptor's PropertyType cannot be statically discovered.";`
`16`	`19`
`17`	`20`	`private TypeConverter? _converter;`
`18`		`- private Hashtable? _valueChangedHandlers;`
	`21`	`+ private ConcurrentDictionary<object, EventHandler?>? _valueChangedHandlers;`
`19`	`22`	`private object?[]? _editors;`
`20`	`23`	`private Type[]? _editorTypes;`
`21`	`24`	`private int _editorCount;`
	`25`	`+ private object? _syncObject;`
`22`	`26`
`23`	`27`	`/// <summary>`
`24`	`28`	`/// Initializes a new instance of the <see cref='System.ComponentModel.PropertyDescriptor'/> class with the specified name and`
`@@ -48,6 +52,8 @@ protected PropertyDescriptor(MemberDescriptor descr, Attribute[]? attrs) : base(`
`48`	`52`	`{`
`49`	`53`	`}`
`50`	`54`
	`55`	`+ private object SyncObject => LazyInitializer.EnsureInitialized(ref _syncObject);`
	`56`	`+`
`51`	`57`	`/// <summary>`
`52`	`58`	`/// When overridden in a derived class, gets the type of the`
`53`	`59`	`/// component this property is bound to.`
`@@ -132,13 +138,11 @@ public virtual void AddValueChanged(object component, EventHandler handler)`
`132`	`138`	`throw new ArgumentNullException(nameof(handler));`
`133`	`139`	`}`
`134`	`140`
`135`		`- if (_valueChangedHandlers == null)`
	`141`	`+ lock (SyncObject)`
`136`	`142`	`{`
`137`		`- _valueChangedHandlers = new Hashtable();`
	`143`	`+ _valueChangedHandlers ??= new ConcurrentDictionary<object, EventHandler?>(concurrencyLevel: 1, capacity: 0);`
	`144`	`+ _valueChangedHandlers.AddOrUpdate(component, handler, (k, v) => (EventHandler?)Delegate.Combine(v, handler));`
`138`	`145`	`}`
`139`		`-`
`140`		`- EventHandler? h = (EventHandler?)_valueChangedHandlers[component];`
`141`		`- _valueChangedHandlers[component] = Delegate.Combine(h, handler);`
`142`	`146`	`}`
`143`	`147`
`144`	`148`	`/// <summary>`
`@@ -392,7 +396,7 @@ protected virtual void OnValueChanged(object? component, EventArgs e)`
`392`	`396`	`{`
`393`	`397`	`if (component != null)`
`394`	`398`	`{`
`395`		`- ((EventHandler?)_valueChangedHandlers?[component])?.Invoke(component, e);`
	`399`	`+ _valueChangedHandlers?.GetValueOrDefault(component, defaultValue: null)?.Invoke(component, e);`
`396`	`400`	`}`
`397`	`401`	`}`
`398`	`402`
`@@ -412,15 +416,18 @@ public virtual void RemoveValueChanged(object component, EventHandler handler)`
`412`	`416`
`413`	`417`	`if (_valueChangedHandlers != null)`
`414`	`418`	`{`
`415`		`- EventHandler? h = (EventHandler?)_valueChangedHandlers[component];`
`416`		`- h = (EventHandler?)Delegate.Remove(h, handler);`
`417`		`- if (h != null)`
`418`		`- {`
`419`		`- _valueChangedHandlers[component] = h;`
`420`		`- }`
`421`		`- else`
	`419`	`+ lock (SyncObject)`
`422`	`420`	`{`
`423`		`- _valueChangedHandlers.Remove(component);`
	`421`	`+ EventHandler? h = _valueChangedHandlers.GetValueOrDefault(component, defaultValue: null);`
	`422`	`+ h = (EventHandler?)Delegate.Remove(h, handler);`
	`423`	`+ if (h != null)`
	`424`	`+ {`
	`425`	`+ _valueChangedHandlers[component] = h;`
	`426`	`+ }`
	`427`	`+ else`
	`428`	`+ {`
	`429`	`+ _valueChangedHandlers.TryRemove(component, out EventHandler? _);`
	`430`	`+ }`
`424`	`431`	`}`
`425`	`432`	`}`
`426`	`433`	`}`
`@@ -434,7 +441,7 @@ public virtual void RemoveValueChanged(object component, EventHandler handler)`
`434`	`441`	`{`
`435`	`442`	`if (component != null && _valueChangedHandlers != null)`
`436`	`443`	`{`
`437`		`- return (EventHandler?)_valueChangedHandlers[component];`
	`444`	`+ return _valueChangedHandlers.GetValueOrDefault(component, defaultValue: null);`
`438`	`445`	`}`
`439`	`446`	`else`
`440`	`447`	`{`
Original file line number	Diff line number	Diff line change
`@@ -3,6 +3,7 @@`
`3`	`3`
`4`	`4`	`using System.Collections;`
`5`	`5`	`using System.Collections.Generic;`
	`6`	`+using System.Collections.Concurrent;`
`6`	`7`	`using System.ComponentModel.Design;`
`7`	`8`	`using System.Diagnostics;`
`8`	`9`	`using System.Diagnostics.CodeAnalysis;`
`@@ -23,10 +24,8 @@ namespace System.ComponentModel`
`23`	`24`	`/// </summary>`
`24`	`25`	`internal sealed partial class ReflectTypeDescriptionProvider : TypeDescriptionProvider`
`25`	`26`	`{`
`26`		`- // Hastable of Type -> ReflectedTypeData. ReflectedTypeData contains all`
`27`		`- // of the type information we have gathered for a given type.`
`28`		`- //`
`29`		`- private Hashtable? _typeData;`
	`27`	`+ // ReflectedTypeData contains all of the type information we have gathered for a given type.`
	`28`	`+ private readonly ConcurrentDictionary<Type, ReflectedTypeData> _typeData = new ConcurrentDictionary<Type, ReflectedTypeData>();`
`30`	`29`
`31`	`30`	`// This is the signature we look for when creating types that are generic, but`
`32`	`31`	`// want to know what type they are dealing with. Enums are a good example of this;`
`@@ -81,8 +80,6 @@ internal sealed partial class ReflectTypeDescriptionProvider : TypeDescriptionPr`
`81`	`80`
`82`	`81`	`internal static Guid ExtenderProviderKey { get; } = Guid.NewGuid();`
`83`	`82`
`84`		`-`
`85`		`- private static readonly object s_internalSyncObject = new object();`
`86`	`83`	`/// <summary>`
`87`	`84`	`/// Creates a new ReflectTypeDescriptionProvider. The type is the`
`88`	`85`	`/// type we will obtain type information for.`
`@@ -234,7 +231,7 @@ internal static void AddEditorTable(Type editorBaseType, Hashtable table)`
`234`	`231`	`// don't throw; RTM didn't so we can't do it either.`
`235`	`232`	`}`
`236`	`233`
`237`		`- lock (s_internalSyncObject)`
	`234`	`+ lock (TypeDescriptor.s_commonSyncObject)`
`238`	`235`	`{`
`239`	`236`	`Hashtable editorTables = EditorTables;`
`240`	`237`	`if (!editorTables.ContainsKey(editorBaseType))`
`@@ -289,7 +286,6 @@ internal static void AddEditorTable(Type editorBaseType, Hashtable table)`
`289`	`286`	`return obj ?? Activator.CreateInstance(objectType, args);`
`290`	`287`	`}`
`291`	`288`
`292`		`-`
`293`	`289`	`/// <summary>`
`294`	`290`	`/// Helper method to create editors and type converters. This checks to see if the`
`295`	`291`	`/// type implements a Type constructor, and if it does it invokes that ctor.`
`@@ -421,7 +417,7 @@ internal TypeConverter GetConverter([DynamicallyAccessedMembers(DynamicallyAcces`
`421`	`417`	`//`
`422`	`418`	`if (table == null)`
`423`	`419`	`{`
`424`		`- lock (s_internalSyncObject)`
	`420`	`+ lock (TypeDescriptor.s_commonSyncObject)`
`425`	`421`	`{`
`426`	`422`	`table = editorTables[editorBaseType];`
`427`	`423`	`if (table == null)`
`@@ -838,22 +834,11 @@ internal Type[] GetPopulatedTypes(Module module)`
`838`	`834`	`{`
`839`	`835`	`List<Type> typeList = new List<Type>();`
`840`	`836`
`841`		`- lock (s_internalSyncObject)`
	`837`	`+ foreach (KeyValuePair<Type, ReflectedTypeData> kvp in _typeData)`
`842`	`838`	`{`
`843`		`- Hashtable? typeData = _typeData;`
`844`		`- if (typeData != null)`
	`839`	`+ if (kvp.Key.Module == module && kvp.Value!.IsPopulated)`
`845`	`840`	`{`
`846`		`- // Manual use of IDictionaryEnumerator instead of foreach to avoid DictionaryEntry box allocations.`
`847`		`- IDictionaryEnumerator e = typeData.GetEnumerator();`
`848`		`- while (e.MoveNext())`
`849`		`- {`
`850`		`- DictionaryEntry de = e.Entry;`
`851`		`- Type type = (Type)de.Key;`
`852`		`- if (type.Module == module && ((ReflectedTypeData)de.Value!).IsPopulated)`
`853`		`- {`
`854`		`- typeList.Add(type);`
`855`		`- }`
`856`		`- }`
	`841`	`+ typeList.Add(kvp.Key);`
`857`	`842`	`}`
`858`	`843`	`}`
`859`	`844`
`@@ -898,31 +883,23 @@ public override Type GetReflectionType(`
`898`	`883`	`/// </summary>`
`899`	`884`	`private ReflectedTypeData? GetTypeData([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)] Type type, bool createIfNeeded)`
`900`	`885`	`{`
`901`		`- ReflectedTypeData? td = null;`
`902`		`-`
`903`		`- if (_typeData != null)`
	`886`	`+ if (_typeData.TryGetValue(type, out ReflectedTypeData? td))`
`904`	`887`	`{`
`905`		`- td = (ReflectedTypeData?)_typeData[type];`
`906`		`- if (td != null)`
`907`		`- {`
`908`		`- return td;`
`909`		`- }`
	`888`	`+ Debug.Assert(td != null);`
	`889`	`+ return td;`
`910`	`890`	`}`
`911`	`891`
`912`		`- lock (s_internalSyncObject)`
	`892`	`+ lock (TypeDescriptor.s_commonSyncObject)`
`913`	`893`	`{`
`914`		`- if (_typeData != null)`
	`894`	`+ if (_typeData.TryGetValue(type, out td))`
`915`	`895`	`{`
`916`		`- td = (ReflectedTypeData?)_typeData[type];`
	`896`	`+ Debug.Assert(td != null);`
	`897`	`+ return td;`
`917`	`898`	`}`
`918`	`899`
`919`		`- if (td == null && createIfNeeded)`
	`900`	`+ if (createIfNeeded)`
`920`	`901`	`{`
`921`	`902`	`td = new ReflectedTypeData(type);`
`922`		`- if (_typeData == null)`
`923`		`- {`
`924`		`- _typeData = new Hashtable();`
`925`		`- }`
`926`	`903`	`_typeData[type] = td;`
`927`	`904`	`}`
`928`	`905`	`}`
`@@ -1010,7 +987,7 @@ internal static Attribute[] ReflectGetAttributes(Type type)`
`1010`	`987`	`return attrs;`
`1011`	`988`	`}`
`1012`	`989`
`1013`		`- lock (s_internalSyncObject)`
	`990`	`+ lock (TypeDescriptor.s_commonSyncObject)`
`1014`	`991`	`{`
`1015`	`992`	`attrs = (Attribute[]?)attributeCache[type];`
`1016`	`993`	`if (attrs == null)`
`@@ -1038,7 +1015,7 @@ internal static Attribute[] ReflectGetAttributes(MemberInfo member)`
`1038`	`1015`	`return attrs;`
`1039`	`1016`	`}`
`1040`	`1017`
`1041`		`- lock (s_internalSyncObject)`
	`1018`	`+ lock (TypeDescriptor.s_commonSyncObject)`
`1042`	`1019`	`{`
`1043`	`1020`	`attrs = (Attribute[]?)attributeCache[member];`
`1044`	`1021`	`if (attrs == null)`
`@@ -1067,7 +1044,7 @@ private static EventDescriptor[] ReflectGetEvents(`
`1067`	`1044`	`return events;`
`1068`	`1045`	`}`
`1069`	`1046`
`1070`		`- lock (s_internalSyncObject)`
	`1047`	`+ lock (TypeDescriptor.s_commonSyncObject)`
`1071`	`1048`	`{`
`1072`	`1049`	`events = (EventDescriptor[]?)eventCache[type];`
`1073`	`1050`	`if (events == null)`
`@@ -1164,7 +1141,7 @@ private static PropertyDescriptor[] ReflectGetExtendedProperties(IExtenderProvid`
`1164`	`1141`	`ReflectPropertyDescriptor[]? extendedProperties = (ReflectPropertyDescriptor[]?)extendedPropertyCache[providerType];`
`1165`	`1142`	`if (extendedProperties == null)`
`1166`	`1143`	`{`
`1167`		`- lock (s_internalSyncObject)`
	`1144`	`+ lock (TypeDescriptor.s_commonSyncObject)`
`1168`	`1145`	`{`
`1169`	`1146`	`extendedProperties = (ReflectPropertyDescriptor[]?)extendedPropertyCache[providerType];`
`1170`	`1147`
`@@ -1244,7 +1221,7 @@ private static PropertyDescriptor[] ReflectGetProperties(`
`1244`	`1221`	`return properties;`
`1245`	`1222`	`}`
`1246`	`1223`
`1247`		`- lock (s_internalSyncObject)`
	`1224`	`+ lock (TypeDescriptor.s_commonSyncObject)`
`1248`	`1225`	`{`
`1249`	`1226`	`properties = (PropertyDescriptor[]?)propertyCache[type];`
`1250`	`1227`