Add MetadataUpdateHandlerAttribute

src/coreclr/System.Private.CoreLib/System.Private.CoreLib.csproj

@@ -199,6 +199,7 @@
     <Compile Include="$(BclSourcesRoot)\System\Reflection\RuntimeModule.cs" />
     <Compile Include="$(BclSourcesRoot)\System\Reflection\RuntimeParameterInfo.cs" />
     <Compile Include="$(BclSourcesRoot)\System\Reflection\RuntimePropertyInfo.cs" />
+    <Compile Include="$(BclSourcesRoot)\System\Reflection\Metadata\RuntimeTypeMetadataUpdateHandler.cs" />
     <Compile Include="$(BclSourcesRoot)\System\Resources\ManifestBasedResourceGroveler.CoreCLR.cs" />
     <Compile Include="$(BclSourcesRoot)\System\Runtime\CompilerServices\CrossLoaderAllocatorHashHelpers.cs" />
     <Compile Include="$(BclSourcesRoot)\System\Runtime\CompilerServices\DependentHandle.cs" />

src/coreclr/System.Private.CoreLib/src/System/Reflection/Metadata/RuntimeTypeMetadataUpdateHandler.cs

@@ -0,0 +1,25 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Reflection.Metadata;
+
+[assembly: MetadataUpdateHandler(typeof(RuntimeTypeMetadataUpdateHandler))]
+
+namespace System.Reflection.Metadata
+{
+    /// <summary>Metadata update handler used to clear a Type's reflection cache in response to a metadata update notification.</summary>
+    internal static class RuntimeTypeMetadataUpdateHandler
+    {
+        public static void BeforeUpdate(Type? type)
+        {
+            if (type is RuntimeType rt)
+            {
+                rt.ClearCache();
+            }
+
+            // TODO: https://github.com/dotnet/runtime/issues/50938
+            // Do we need to clear the cache on other types, e.g. ones derived from this one?
+            // Do we need to clear a cache on any other kinds of types?
+        }
+    }
+}

src/coreclr/System.Private.CoreLib/src/System/RuntimeType.CoreCLR.cs

@@ -2418,6 +2418,37 @@ private RuntimeTypeCache InitializeCache()
             return cache;
         }
 
+        internal void ClearCache()
+        {
+            // If there isn't a GCHandle yet, there's nothing more to do.
+            if (Volatile.Read(ref m_cache) == IntPtr.Zero)
+            {
+                return;
+            }
+
+            // Loop until the cache is successfully zero'd out.
+            do
+            {
+                // If the GCHandle doesn't wrap a cache yet, there's nothing more to do.
+                RuntimeTypeCache? existingCache = (RuntimeTypeCache?)GCHandle.InternalGet(m_cache);
+                if (existingCache is null)
+                {
+                    return;
+                }
+
+                // Create a new, empty cache to replace the old one and try to substitute it in.
+                var newCache = new RuntimeTypeCache(this);
+                if (ReferenceEquals(GCHandle.InternalCompareExchange(m_cache, newCache, existingCache), existingCache))
+                {
+                    // We were successful, so there's nothing more to do.
+                    return;
+                }
+
+                // We raced with someone else to initialize the cache.  Try again.
+            }
+            while (true);
+        }
+
         private string? GetDefaultMemberName()
         {
             return Cache.GetDefaultMemberName();

src/libraries/System.Private.CoreLib/src/ILLink/ILLink.LinkAttributes.Shared.xml

@@ -29,6 +29,11 @@
     <type fullname="System.Diagnostics.DebuggerVisualizerAttribute">
       <attribute internal="RemoveAttributeInstances" />
     </type>
+
+    <!-- Hot reload attributes-->
+    <type fullname="System.Reflection.Metadata.MetadataUpdateHandlerAttribute">
+      <attribute internal="RemoveAttributeInstances" />
+    </type>
   </assembly>
 
   <assembly fullname="System.Private.CoreLib" feature="System.Diagnostics.Tracing.EventSource.IsSupported" featurevalue="false">

src/libraries/System.Private.CoreLib/src/System.Private.CoreLib.Shared.projitems

@@ -616,6 +616,7 @@
     <Compile Include="$(MSBuildThisFileDirectory)System\Reflection\TypeDelegator.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Reflection\TypeFilter.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Reflection\TypeInfo.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)System\Reflection\Metadata\MetadataUpdateHandlerAttribute.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\ResolveEventArgs.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\ResolveEventHandler.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Resources\FastResourceComparer.cs" />

src/libraries/System.Private.CoreLib/src/System/Reflection/Metadata/MetadataUpdateHandlerAttribute.cs

@@ -0,0 +1,21 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Diagnostics.CodeAnalysis;
+
+namespace System.Reflection.Metadata
+{
+    /// <summary>Specifies a type that should receive notifications of metadata updates.</summary>
+    [AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
+    public sealed class MetadataUpdateHandlerAttribute : Attribute
+    {
+        /// <summary>Initializes the attribute.</summary>
+        /// <param name="handlerType">A type that handles metadata updates and that should be notified when any occur.</param>
+        public MetadataUpdateHandlerAttribute([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)] Type handlerType) =>
+            HandlerType = handlerType;
+
+        /// <summary>Gets the type that handles metadata updates and that should be notified when any occur.</summary>
+        [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)]
+        public Type HandlerType { get; }
+    }
+}

src/libraries/System.Runtime.Loader/ref/System.Runtime.Loader.cs

@@ -12,6 +12,13 @@ public static partial class AssemblyExtensions
         public unsafe static bool TryGetRawMetadata(this System.Reflection.Assembly assembly, out byte* blob, out int length) { throw null; }
         public static void ApplyUpdate(Assembly assembly, ReadOnlySpan<byte> metadataDelta, ReadOnlySpan<byte> ilDelta, ReadOnlySpan<byte> pdbDelta) { throw null; }
     }
+    [System.AttributeUsage(System.AttributeTargets.Assembly, AllowMultiple = true)]
+    public sealed class MetadataUpdateHandlerAttribute : System.Attribute
+    {
+        public MetadataUpdateHandlerAttribute([System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembersAttribute(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.All)] System.Type handlerType) { }
+        [System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembersAttribute(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.All)]
+        public System.Type HandlerType { get { throw null; } }
+    }
 }
 namespace System.Runtime.Loader
 {

src/libraries/System.Runtime.Loader/tests/MetadataUpdateHandlerAttributeTest.cs

@@ -0,0 +1,18 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Xunit;
+
+namespace System.Reflection.Metadata
+{
+    public class MetadataUpdateHandlerAttributeTest
+    {
+        [Fact]
+        public void Ctor_RoundtripType()
+        {
+            Type t = typeof(MetadataUpdateHandlerAttributeTest);
+            var a = new MetadataUpdateHandlerAttribute(t);
+            Assert.Same(t, a.HandlerType);
+        }
+    }
+}

src/libraries/System.Runtime.Loader/tests/System.Runtime.Loader.Tests.csproj

@@ -13,6 +13,7 @@
     <Compile Include="CollectibleAssemblyLoadContextTest.cs" />
     <Compile Include="ContextualReflection.cs" />
     <Compile Include="CustomTPALoadContext.cs" />
+    <Compile Include="MetadataUpdateHandlerAttributeTest.cs" />
     <Compile Include="ResourceAssemblyLoadContext.cs" />
     <Compile Include="SatelliteAssemblies.cs" />
     <Compile Include="LoaderLinkTest.cs" />

src/libraries/System.Runtime/tests/System.Runtime.Tests.csproj

@@ -206,6 +206,7 @@
     <Compile Include="System\Reflection\ObfuscateAssemblyAttributeTests.cs" />
     <Compile Include="System\Reflection\ObfuscationAttributeTests.cs" />
     <Compile Include="System\Reflection\PointerTests.cs" />
+    <Compile Include="System\Reflection\ReflectionCacheTests.cs" />
     <Compile Include="System\Reflection\ReflectionContextTests.cs" />
     <Compile Include="System\Reflection\ReflectionTypeLoadExceptionTests.cs" />
     <Compile Include="System\Reflection\StrongNameKeyPairTests.cs" />

src/libraries/System.Runtime/tests/System/Reflection/ReflectionCacheTests.cs

@@ -0,0 +1,43 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Xunit;
+
+namespace System.Reflection.Tests
+{
+    public class ReflectionCacheTests
+    {
+        [Fact]
+        public void GetMethod_MultipleCalls_SameObjects()
+        {
+            MethodInfo mi1 = typeof(ReflectionCacheTests).GetMethod(nameof(GetMethod_MultipleCalls_SameObjects));
+            Assert.NotNull(mi1);
+
+            MethodInfo mi2 = typeof(ReflectionCacheTests).GetMethod(nameof(GetMethod_MultipleCalls_SameObjects));
+            Assert.NotNull(mi2);
+
+            Assert.Same(mi1, mi2);
+        }
+
+        [ActiveIssue("https://github.com/dotnet/runtime/issues/50978", TestRuntimes.Mono)]
+        [Fact]
+        public void GetMethod_MultipleCalls_ClearCache_DifferentObjects()
+        {
+            Type updateHandler = typeof(Type).Assembly.GetType("System.Reflection.Metadata.RuntimeTypeMetadataUpdateHandler", throwOnError: true, ignoreCase: false);
+            MethodInfo beforeUpdate = updateHandler.GetMethod("BeforeUpdate", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static, new[] { typeof(Type) });
+            Assert.NotNull(beforeUpdate);
+
+            MethodInfo mi1 = typeof(ReflectionCacheTests).GetMethod(nameof(GetMethod_MultipleCalls_ClearCache_DifferentObjects));
+            Assert.NotNull(mi1);
+            Assert.Equal(nameof(GetMethod_MultipleCalls_ClearCache_DifferentObjects), mi1.Name);
+
+            beforeUpdate.Invoke(null, new object[] { typeof(ReflectionCacheTests) });
+
+            MethodInfo mi2 = typeof(ReflectionCacheTests).GetMethod(nameof(GetMethod_MultipleCalls_ClearCache_DifferentObjects));
+            Assert.NotNull(mi2);
+            Assert.Equal(nameof(GetMethod_MultipleCalls_ClearCache_DifferentObjects), mi2.Name);
+
+            Assert.NotSame(mi1, mi2);
+        }
+    }
+}