dotnet
diff --git a/‎src/Microsoft.DotNet.Wpf/src/System.Xaml/System/Xaml/Schema/XamlNamespace.cs
Lines changed: 13 additions & 12 deletions b/‎src/Microsoft.DotNet.Wpf/src/System.Xaml/System/Xaml/Schema/XamlNamespace.cs
Lines changed: 13 additions & 12 deletions
diff --git a/‎src/Microsoft.DotNet.Wpf/src/System.Xaml/System/Xaml/XamlSchemaContext.cs
Lines changed: 1 addition & 0 deletions b/‎src/Microsoft.DotNet.Wpf/src/System.Xaml/System/Xaml/XamlSchemaContext.cs
Lines changed: 1 addition & 0 deletions
@@ -15,7 +15,7 @@ internal class XamlNamespace
     {
         public readonly XamlSchemaContext SchemaContext;
 
-        private List<AssemblyNamespacePair> _assemblyNamespaces;
+        private AssemblyNamespacePair[] _assemblyNamespaces;
         private ConcurrentDictionary<string, XamlType> _typeCache;
         private ICollection<XamlType> _allPublicTypes;
 
@@ -169,15 +169,15 @@ internal int RevisionNumber
         {
             // The only external mutation we allow is adding new namespaces. So the count of
             // namespaces also serves as a revision number.
-            get => (_assemblyNamespaces is not null) ? _assemblyNamespaces.Count : 0;
+            get => (_assemblyNamespaces != null) ? _assemblyNamespaces.Length : 0;
         }
 
         private Type TryGetType(string typeName)
         {
             Type type = SearchAssembliesForShortName(typeName);
             if (type is null && IsClrNamespace)
             {
-                Debug.Assert(_assemblyNamespaces.Count == 1);
+                Debug.Assert(_assemblyNamespaces.Length == 1);
                 type = XamlLanguage.LookupClrNamespaceType(_assemblyNamespaces[0], typeName);
             }
 
@@ -233,13 +233,13 @@ private ICollection<XamlType> LookupAllTypes()
             return xamlTypeList.AsReadOnly();
         }
 
-        private List<AssemblyNamespacePair> GetClrNamespacePair(string clrNs, string assemblyName)
+        private AssemblyNamespacePair[] GetClrNamespacePair(string clrNs, string assemblyName)
         {
             Assembly asm = SchemaContext.OnAssemblyResolve(assemblyName);
             if (asm is null)
                 return null;
 
-            return new List<AssemblyNamespacePair>(1) { new AssemblyNamespacePair(asm, clrNs) };
+            return new AssemblyNamespacePair[1] { new AssemblyNamespacePair(asm, clrNs) };
         }
 
         private Type SearchAssembliesForShortName(string shortName)
@@ -268,22 +268,23 @@ private Type SearchAssembliesForShortName(string shortName)
         // This method should only be called inside SchemaContext._syncExaminingAssemblies lock
         internal void AddAssemblyNamespacePair(AssemblyNamespacePair pair)
         {
-            // To allow the list to be read by multiple threads, we create a new list, add the pair,
-            // then assign it back to the original variable. Assignments are assured to be atomic.
+            // To allow the array to be read concurrently by multiple threads, we create a new array, add the pair,
+            // then assign it back to the original variable. Assignments are guaranteed to be atomic for word size.
 
-            List<AssemblyNamespacePair> assemblyNamespacesCopy;
+            AssemblyNamespacePair[] assemblyNamespacesCopy;
             if (_assemblyNamespaces is null)
             {
-                assemblyNamespacesCopy = new List<AssemblyNamespacePair>(1);
+                assemblyNamespacesCopy = new AssemblyNamespacePair[1];
                 Initialize();
             }
             else
             {
-                assemblyNamespacesCopy = new List<AssemblyNamespacePair>(_assemblyNamespaces.Count + 1);
+                assemblyNamespacesCopy = new AssemblyNamespacePair[_assemblyNamespaces.Length + 1];
             }
 
-            assemblyNamespacesCopy.AddRange(_assemblyNamespaces);
-            assemblyNamespacesCopy.Add(pair);
+            // Copy over and add new item
+            _assemblyNamespaces.CopyTo(assemblyNamespacesCopy, 0);
+            assemblyNamespacesCopy[assemblyNamespacesCopy.Length - 1] = pair;
 
             _assemblyNamespaces = assemblyNamespacesCopy;
         }
 
@@ -1181,6 +1181,7 @@ private bool UpdateXmlNsInfo(XmlNsInfo nsInfo)
             return foundNew;
         }
 
+        // This method should be called inside _syncExaminingAssemblies lock
         private bool UpdateNamespaceByUriList(XmlNsInfo nsInfo)
         {
             IList<XmlNsInfo.XmlNsDefinition> xmlnsDefs = nsInfo.NsDefs;
Original file line number	Diff line number	Diff line change
`@@ -15,7 +15,7 @@ internal class XamlNamespace`
`15`	`15`	`{`
`16`	`16`	`public readonly XamlSchemaContext SchemaContext;`
`17`	`17`
`18`		`- private List<AssemblyNamespacePair> _assemblyNamespaces;`
	`18`	`+ private AssemblyNamespacePair[] _assemblyNamespaces;`
`19`	`19`	`private ConcurrentDictionary<string, XamlType> _typeCache;`
`20`	`20`	`private ICollection<XamlType> _allPublicTypes;`
`21`	`21`
`@@ -169,15 +169,15 @@ internal int RevisionNumber`
`169`	`169`	`{`
`170`	`170`	`// The only external mutation we allow is adding new namespaces. So the count of`
`171`	`171`	`// namespaces also serves as a revision number.`
`172`		`- get => (_assemblyNamespaces is not null) ? _assemblyNamespaces.Count : 0;`
	`172`	`+ get => (_assemblyNamespaces != null) ? _assemblyNamespaces.Length : 0;`
`173`	`173`	`}`
`174`	`174`
`175`	`175`	`private Type TryGetType(string typeName)`
`176`	`176`	`{`
`177`	`177`	`Type type = SearchAssembliesForShortName(typeName);`
`178`	`178`	`if (type is null && IsClrNamespace)`
`179`	`179`	`{`
`180`		`- Debug.Assert(_assemblyNamespaces.Count == 1);`
	`180`	`+ Debug.Assert(_assemblyNamespaces.Length == 1);`
`181`	`181`	`type = XamlLanguage.LookupClrNamespaceType(_assemblyNamespaces[0], typeName);`
`182`	`182`	`}`
`183`	`183`
`@@ -233,13 +233,13 @@ private ICollection<XamlType> LookupAllTypes()`
`233`	`233`	`return xamlTypeList.AsReadOnly();`
`234`	`234`	`}`
`235`	`235`
`236`		`- private List<AssemblyNamespacePair> GetClrNamespacePair(string clrNs, string assemblyName)`
	`236`	`+ private AssemblyNamespacePair[] GetClrNamespacePair(string clrNs, string assemblyName)`
`237`	`237`	`{`
`238`	`238`	`Assembly asm = SchemaContext.OnAssemblyResolve(assemblyName);`
`239`	`239`	`if (asm is null)`
`240`	`240`	`return null;`
`241`	`241`
`242`		`- return new List<AssemblyNamespacePair>(1) { new AssemblyNamespacePair(asm, clrNs) };`
	`242`	`+ return new AssemblyNamespacePair[1] { new AssemblyNamespacePair(asm, clrNs) };`
`243`	`243`	`}`
`244`	`244`
`245`	`245`	`private Type SearchAssembliesForShortName(string shortName)`
`@@ -268,22 +268,23 @@ private Type SearchAssembliesForShortName(string shortName)`
`268`	`268`	`// This method should only be called inside SchemaContext._syncExaminingAssemblies lock`
`269`	`269`	`internal void AddAssemblyNamespacePair(AssemblyNamespacePair pair)`
`270`	`270`	`{`
`271`		`- // To allow the list to be read by multiple threads, we create a new list, add the pair,`
`272`		`- // then assign it back to the original variable. Assignments are assured to be atomic.`
	`271`	`+ // To allow the array to be read concurrently by multiple threads, we create a new array, add the pair,`
	`272`	`+ // then assign it back to the original variable. Assignments are guaranteed to be atomic for word size.`
`273`	`273`
`274`		`- List<AssemblyNamespacePair> assemblyNamespacesCopy;`
	`274`	`+ AssemblyNamespacePair[] assemblyNamespacesCopy;`
`275`	`275`	`if (_assemblyNamespaces is null)`
`276`	`276`	`{`
`277`		`- assemblyNamespacesCopy = new List<AssemblyNamespacePair>(1);`
	`277`	`+ assemblyNamespacesCopy = new AssemblyNamespacePair[1];`
`278`	`278`	`Initialize();`
`279`	`279`	`}`
`280`	`280`	`else`
`281`	`281`	`{`
`282`		`- assemblyNamespacesCopy = new List<AssemblyNamespacePair>(_assemblyNamespaces.Count + 1);`
	`282`	`+ assemblyNamespacesCopy = new AssemblyNamespacePair[_assemblyNamespaces.Length + 1];`
`283`	`283`	`}`
`284`	`284`
`285`		`- assemblyNamespacesCopy.AddRange(_assemblyNamespaces);`
`286`		`- assemblyNamespacesCopy.Add(pair);`
	`285`	`+ // Copy over and add new item`
	`286`	`+ _assemblyNamespaces.CopyTo(assemblyNamespacesCopy, 0);`
	`287`	`+ assemblyNamespacesCopy[assemblyNamespacesCopy.Length - 1] = pair;`
`287`	`288`
`288`	`289`	`_assemblyNamespaces = assemblyNamespacesCopy;`
`289`	`290`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1181,6 +1181,7 @@ private bool UpdateXmlNsInfo(XmlNsInfo nsInfo)`
`1181`	`1181`	`return foundNew;`
`1182`	`1182`	`}`
`1183`	`1183`
	`1184`	`+ // This method should be called inside _syncExaminingAssemblies lock`
`1184`	`1185`	`private bool UpdateNamespaceByUriList(XmlNsInfo nsInfo)`
`1185`	`1186`	`{`
`1186`	`1187`	`IList<XmlNsInfo.XmlNsDefinition> xmlnsDefs = nsInfo.NsDefs;`