Implement a static IFieldInterceptorAccessor

Author: fredericDelaporte

src/AsyncGenerator.yml

@@ -196,6 +196,8 @@
       name: LinqReadonlyTestsContext
     - conversion: Ignore
       name: MultiThreadRunner
+    - conversion: Ignore
+      name: PeVerifier
     - conversion: Ignore
       hasAttributeName: IgnoreAttribute
     - conversion: NewType

src/NHibernate.Test/Async/DynamicProxyTests/PeVerifyFixture.cs

@@ -1,9 +1,9 @@
 using System;
-using System.IO;
 using System.Reflection;
 using System.Reflection.Emit;
 using NUnit.Framework;
 using NHibernate.Proxy.DynamicProxy;
+using NHibernate.Test.ProxyTest;
 
 namespace NHibernate.Test.DynamicProxyTests
 {

src/NHibernate.Test/DynamicProxyTests/PeVerifyFixture.cs

@@ -3,11 +3,11 @@
 using System.IO;
 using NUnit.Framework;
 
-namespace NHibernate.Test.DynamicProxyTests
+namespace NHibernate.Test.ProxyTest
 {
 	// utility class to run PEVerify.exe against a saved-to-disk assembly, similar to:
 	// http://stackoverflow.com/questions/7290893/is-there-an-api-for-verifying-the-msil-of-a-dynamic-assembly-at-runtime
-	public partial class PeVerifier
+	public class PeVerifier
 	{
 		private string _assemlyLocation;
 		private string _peVerifyPath;

src/NHibernate.Test/DynamicProxyTests/PeVerifier.cs renamed to src/NHibernate.Test/ProxyTest/PeVerifier.cs

@@ -1,6 +1,13 @@
 using System.Collections.Generic;
 using NHibernate.Proxy;
 using NUnit.Framework;
+#if NETFX
+using System;
+using System.Reflection;
+using System.Reflection.Emit;
+using NHibernate.Proxy.DynamicProxy;
+using NHibernate.Test.ProxyTest;
+#endif
 
 namespace NHibernate.Test.StaticProxyTest
 {
@@ -24,5 +31,90 @@ public void CanCreateProxyForClassWithInternalInterface()
 			var proxy = factory.GetProxy(1, null);
 			Assert.That(proxy, Is.Not.Null);
 		}
+
+#if NETFX
+		[Test]
+		public void VerifyFieldInterceptorProxy()
+		{
+			var proxyBuilderType = typeof(StaticProxyFactory).Assembly.GetType("NHibernate.Proxy.FieldInterceptorProxyBuilder", true);
+			var proxyBuilder = proxyBuilderType.GetMethod("CreateProxyType");
+			Assert.That(proxyBuilder, Is.Not.Null, "Failed to find method CreateProxyType");
+			var proxyBuilderAssemblyBuilder = proxyBuilderType.GetField("ProxyAssemblyBuilder", BindingFlags.NonPublic | BindingFlags.Static);
+			Assert.That(proxyBuilderAssemblyBuilder, Is.Not.Null, "Failed to find assembly builder field");
+
+			const string assemblyName = "VerifyFieldInterceptorProxy";
+			var assemblyBuilder = new SavingProxyAssemblyBuilder(assemblyName);
+
+			var backupAssemblyBuilder = proxyBuilderAssemblyBuilder.GetValue(null);
+			proxyBuilderAssemblyBuilder.SetValue(null, assemblyBuilder);
+			try
+			{
+				proxyBuilder.Invoke(null, new object[] { typeof(TestClass) });
+			}
+			finally
+			{
+				proxyBuilderAssemblyBuilder.SetValue(null, backupAssemblyBuilder);
+			}
+
+			new PeVerifier($"{assemblyName}.dll").AssertIsValid();
+		}
+
+		public class SavingProxyAssemblyBuilder : IProxyAssemblyBuilder
+		{
+			private readonly string _assemblyName;
+
+			public SavingProxyAssemblyBuilder(string assemblyName)
+			{
+				_assemblyName = assemblyName;
+			}
+
+			public AssemblyBuilder DefineDynamicAssembly(AppDomain appDomain, AssemblyName name)
+			{
+				return appDomain.DefineDynamicAssembly(
+					new AssemblyName(_assemblyName),
+					AssemblyBuilderAccess.RunAndSave,
+					TestContext.CurrentContext.TestDirectory);
+			}
+
+			public ModuleBuilder DefineDynamicModule(AssemblyBuilder assemblyBuilder, string moduleName)
+			{
+				return assemblyBuilder.DefineDynamicModule(moduleName, $"{_assemblyName}.mod", true);
+			}
+
+			public void Save(AssemblyBuilder assemblyBuilder)
+			{
+				assemblyBuilder.Save($"{_assemblyName}.dll");
+			}
+		}
+#endif
+
+		public interface IPublicTest
+		{
+			int Id { get; }
+		}
+
+		public class PublicInterfaceTestClass : IPublicTest
+		{
+			public virtual int Id { get; set; }
+		}
+
+		[Test]
+		public void CanGenerateValidFieldInterceptorProxyWithAdditionalInterface()
+		{
+			var factory = new StaticProxyFactory();
+			factory.PostInstantiate(
+				typeof(PublicInterfaceTestClass).FullName,
+				typeof(PublicInterfaceTestClass),
+				// By way of the "proxy" attribute on the "class" mapping, an interface to use for the
+				// lazy entity load proxy instead of the persistentClass can be specified. This is "translated" into
+				// having an additional interface in the interface list, instead of just having INHibernateProxy.
+				// (Quite a loosy semantic...)
+				// The field interceptor proxy ignores this setting, as it does not delegate its implementation
+				// to an instance of the persistentClass, and so cannot implement interface methods.
+				new HashSet<System.Type> {typeof(INHibernateProxy), typeof(IPublicTest)},
+				null, null, null);
+			var fieldProxy = factory.GetFieldInterceptionProxy(null);
+			Assert.That(fieldProxy, Is.InstanceOf<PublicInterfaceTestClass>());
+		}
 	}
 }