Implement PersistentProxyBuilder for .NET 9+

Author: stakx

src/Castle.Core/DynamicProxy/ModuleScope.cs

@@ -377,6 +377,15 @@ internal AssemblyName GetAssemblyName(bool signStrongName)
 			return assemblyName;
 		}
 
+		internal void ResetModules()
+		{
+			lock (moduleLocker)
+			{
+				moduleBuilder = null;
+				moduleBuilderWithStrongName = null;
+			}
+		}
+
 #if FEATURE_ASSEMBLYBUILDER_SAVE
 		/// <summary>
 		///   Saves the generated assembly with the name and directory information given when this <see cref = "ModuleScope" /> instance was created (or with

src/Castle.Core/DynamicProxy/PersistentIsolatedTypesModuleScope.cs

@@ -0,0 +1,138 @@
+// Copyright 2004-2025 Castle Project - http://www.castleproject.org/
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#if NET9_0_OR_GREATER
+
+#nullable enable
+
+namespace Castle.DynamicProxy
+{
+	using System;
+	using System.IO;
+	using System.Reflection;
+	using System.Reflection.Emit;
+	using System.Runtime.Loader;
+
+	/// <summary>
+	///   A <see cref="ModuleScope"/> specialization that is based on <see cref="PersistedAssemblyBuilder"/>.
+	/// </summary>
+	/// <remarks>
+	///   Dynamic types created with <see cref="PersistedAssemblyBuilder"/> cannot be activated.
+	///   In order for them to be usable, the dynamic assembly has to first be written out
+	///   and then loaded by the runtime as a regular assembly. This implies that either all proxy types
+	///   must be generated ahead of time (if they are to be placed in a single assembly); or, that
+	///   every proxy type gets its own assembly (if they should be immediately activatable).
+	///   This class opts for the latter approach, thus its name.
+	/// </remarks>
+	internal sealed class PersistentIsolatedTypesModuleScope : ModuleScope
+	{
+		private readonly bool savePhysicalAssemblies;
+		private readonly string outputDirectory;
+
+		private int assemblyCount;
+		private bool usingStrongNamedModule;
+
+		public PersistentIsolatedTypesModuleScope(bool savePhysicalAssemblies = true,
+		                                          string ? outputDirectory = null)
+			: base(savePhysicalAssembly: false, disableSignedModule: false)
+		{
+			this.savePhysicalAssemblies = savePhysicalAssemblies;
+			this.outputDirectory = outputDirectory ?? Directory.GetCurrentDirectory();
+
+			assemblyCount = 0;
+			usingStrongNamedModule = false;
+		}
+
+		internal override AssemblyBuilder CreateAssembly(bool signStrongName)
+		{
+			var assemblyName = GetAssemblyName(signStrongName);
+			return new PersistedAssemblyBuilder(assemblyName, coreAssembly: typeof(object).Assembly);
+		}
+
+		internal override TypeBuilder DefineType(bool inSignedModulePreferably, string name, TypeAttributes flags)
+		{
+			TypeBuilder typeBuilder;
+
+			if (IsAuxiliaryType(name) == false)
+			{
+				// The requested `TypeBuilder` is for a main proxy type.
+				// Each of those gets placed in its own assembly.
+				ResetModules();
+				typeBuilder = base.DefineType(inSignedModulePreferably, name, flags);
+				usingStrongNamedModule = typeBuilder.Module == StrongNamedModule;
+			}
+			else
+			{
+				// The requested `TypeBuilder` is for an extra type needed for
+				// the main proxy type. (Currently, those are always invocation types.)
+				// They need to be placed in the same assembly as the main proxy type,
+				// otherwise the runtime won't find them during actual use.
+				//
+				// TODO: Currently, strong-named modules seem to be preferred for
+				// invocation types even when the main proxy type is in a non-strong-named
+				// module. Should find out why that is. Also, ignoring that preference
+				// may cause other problems.
+				typeBuilder = base.DefineType(usingStrongNamedModule, name, flags);
+			}
+
+			return typeBuilder;
+		}
+
+		internal override Type BuildType(TypeBuilder typeBuilder)
+		{
+			Type type = typeBuilder.CreateTypeInfo();
+			var typeName = type.FullName!;
+
+			if (IsAuxiliaryType(typeName) == false)
+			{
+				assemblyCount++;
+
+				var assemblyBuilder = (PersistedAssemblyBuilder)typeBuilder.Assembly;
+
+				using var stream = new MemoryStream();
+				assemblyBuilder.Save(stream);
+
+				if (savePhysicalAssemblies)
+				{
+					var inStrongNamedModule = type.Module == StrongNamedModule;
+					var assemblyFileName = inStrongNamedModule ? StrongNamedModuleName : WeakNamedModuleName;
+					assemblyFileName = Path.ChangeExtension(
+						assemblyFileName,
+						string.Concat(".", assemblyCount.ToString(), Path.GetExtension(assemblyFileName)));
+					var assemblyPath = Path.Combine(outputDirectory, assemblyFileName);
+
+					using var file = File.Open(assemblyPath, FileMode.Create, FileAccess.Write);
+					stream.Seek(0, SeekOrigin.Begin);
+					stream.CopyTo(file);
+					file.Close();
+				}
+
+				stream.Seek(0, SeekOrigin.Begin);
+				var alc = new AssemblyLoadContext(name: null);
+				var runnableAssembly = alc.LoadFromStream(stream);
+
+				type = runnableAssembly.GetType(typeName)!;
+			}
+
+			return type;
+		}
+
+		private bool IsAuxiliaryType(string name)
+		{
+			return name.StartsWith("Castle.Proxies.Invocations.");
+		}
+	}
+}
+
+#endif

src/Castle.Core/DynamicProxy/PersistentProxyBuilder.cs

@@ -1,4 +1,4 @@
-// Copyright 2004-2021 Castle Project - http://www.castleproject.org/
+// Copyright 2004-2025 Castle Project - http://www.castleproject.org/
 // 
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -12,12 +12,15 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#if FEATURE_ASSEMBLYBUILDER_SAVE
-
 #nullable enable
 
+using System.Diagnostics.CodeAnalysis;
+
 namespace Castle.DynamicProxy
 {
+
+#if NET462_OR_GREATER
+
 	/// <summary>
 	///   ProxyBuilder that persists the generated type.
 	/// </summary>
@@ -46,6 +49,40 @@ public PersistentProxyBuilder() : base(new ModuleScope(true))
 			return ModuleScope.SaveAssembly();
 		}
 	}
-}
 
-#endif
+#elif NET9_0_OR_GREATER
+
+	/// <summary>
+	///   <see cref="IProxyBuilder"/> that saves assemblies for the generated types to disk.
+	///   Each generated proxy type will be placed in its own separate assembly.
+	/// </summary>
+	/// <remarks>
+	///   <para>
+	///     Each assembly will be automatically saved when the proxy type is created.
+	///     Saved assemblies include a generation number in their file names
+	///     (e. g. <c>CastleDynProxy2.{1,2,3,...}.dll</c>) so previous assemblies
+	///     aren't overwritten.
+	///   </para>
+	///   <para>
+	///     <b>Use with caution!</b> This class may lead to a lot of files being written to disk.
+	///     There may also be some overhead in the runtime due to the larger number of assemblies.
+	///   </para>
+	/// </remarks>
+	public sealed class PersistentProxyBuilder : DefaultProxyBuilder
+	{
+		/// <summary>
+		///   Initializes a new instance of the <see cref = "PersistentProxyBuilder" /> class.
+		/// </summary>
+		/// <param name="outputDirectory">
+		///   The directory where assemblies will be saved.
+		///   If <see langword="null"/>, the current working directory gets used.
+		/// </param>
+		public PersistentProxyBuilder(string? outputDirectory = null)
+			: base(new PersistentIsolatedTypesModuleScope(savePhysicalAssemblies: true, outputDirectory))
+		{
+		}
+	}
+
+#endif
+
+}