work-in-progress

Author: mikenakis

Benchmark/Benchmark.cs

@@ -207,47 +207,47 @@ public override void RunOnce()
 		}
 
 #region Handwrittern //////////////////////////////////////////////////////////////////////
-		public sealed class HandwrittenFooableEntwiner<T> : Entwiner, IFooable<T>
+		public sealed class HandwrittenFooableEntwiner<T> : IFooable<T>
 		{
+			private readonly AnyCall any_call;
+
 			public HandwrittenFooableEntwiner( AnyCall any_call )
-					: base( typeof(IFooable<T>), any_call )
-			{ }
+			{
+				this.any_call = any_call;
+			}
 
-			void IFooable<T>.Aardvark() => AnyCall( 0, Sys.Array.Empty<object>() );
-			T IFooable<T>.Buffalo() => (T)AnyCall( 1, Sys.Array.Empty<object>() );
-			void IFooable<T>.Crocodile( T t ) => AnyCall( 2, new object[] { t } );
+			void IFooable<T>.Aardvark() => any_call( 0, Sys.Array.Empty<object>() );
+			T IFooable<T>.Buffalo() => (T)any_call( 1, Sys.Array.Empty<object>() );
+			void IFooable<T>.Crocodile( T t ) => any_call( 2, new object[] { t } );
 
 			void IFooable<T>.Dog( T t, out T ot )
 			{
 				var args = new object[] { t, default(T) };
-				AnyCall( 3, args );
+				any_call( 3, args );
 				ot = (T)args[1];
 			}
 
 			void IFooable<T>.Eagle( T t, ref T rt )
 			{
 				var args = new object[] { t, rt };
-				AnyCall( 4, args );
+				any_call( 4, args );
 				rt = (T)args[1];
 			}
 
-			T IFooable<T>.Flamingo { get => (T)AnyCall( 5, Sys.Array.Empty<object>() ); set => AnyCall( 6, new object[] { value } ); }
-			T IFooable<T>.this[ T t ] { get => (T)AnyCall( 7, new object[] { t } ); set => AnyCall( 8, new object[] { t, value } ); }
+			T IFooable<T>.Flamingo { get => (T)any_call( 5, Sys.Array.Empty<object>() ); set => any_call( 6, new object[] { value } ); }
+			T IFooable<T>.this[ T t ] { get => (T)any_call( 7, new object[] { t } ); set => any_call( 8, new object[] { t, value } ); }
 		}
 
-		private sealed class HandwrittenFooableUntwiner<T> : Untwiner
+		private sealed class HandwrittenFooableUntwiner<T>
 		{
 			private readonly IFooable<T> target;
 
 			public HandwrittenFooableUntwiner( IFooable<T> target )
-					: base( typeof(IFooable<T>) )
 			{
 				this.target = target;
 			}
 
-			public override object Target => target;
-
-			public override object AnyCall( int selector, object[] args )
+			public object AnyCall( int selector, object[] args )
 			{
 				switch( selector )
 				{
@@ -295,8 +295,8 @@ private sealed class BenchmarkHandwrittenInvocation : Benchmark
 			public BenchmarkHandwrittenInvocation()
 			{
 				IFooable<string> fooable = new FooImplementation<string>();
-				Untwiner untwiner = new HandwrittenFooableUntwiner<string>( fooable );
-				entwiner = new HandwrittenFooableEntwiner<string>( untwiner.AnyCall );
+				AnyCall untwiner = new HandwrittenFooableUntwiner<string>( fooable ).AnyCall;
+				entwiner = new HandwrittenFooableEntwiner<string>( untwiner );
 			}
 
 			public override void RunOnce()
@@ -307,20 +307,20 @@ public override void RunOnce()
 #endregion
 
 #region Castle Benchmarking Routines //////////////////////////////////////////////////////
-		private sealed class BenchmarkCastleCreation/*WithCaching*/ : Benchmark
+		private sealed class BenchmarkCastleCreation /*WithCaching*/ : Benchmark
 		{
 			private readonly IFooable<string> fooable;
 
-			public BenchmarkCastleCreation/*WithCaching*/()
+			public BenchmarkCastleCreation /*WithCaching*/()
 			{
 				fooable = new FooImplementation<string>();
 				//CastleProxyGenerator.ProxyBuilder.ModuleScope.IsCaching = true;  This used to compile, but not anymore. It appears that they discontinued the "IsCaching" property.
 			}
 
 			public override void RunOnce()
 			{
-				Untwiner untwiner = CastleGetUntwiner( fooable );
-				CastleGetEntwiner<IFooable<string>>( untwiner.AnyCall );
+				AnyCall untwiner = CastleGetUntwiner( fooable );
+				CastleGetEntwiner<IFooable<string>>( untwiner );
 			}
 		}
 
@@ -331,8 +331,8 @@ private sealed class BenchmarkCastleInvocation : Benchmark
 			public BenchmarkCastleInvocation()
 			{
 				IFooable<string> fooable = new FooImplementation<string>();
-				Untwiner untwiner = CastleGetUntwiner( fooable );
-				entwiner = CastleGetEntwiner<IFooable<string>>( untwiner.AnyCall );
+				AnyCall untwiner = CastleGetUntwiner( fooable );
+				entwiner = CastleGetEntwiner<IFooable<string>>( untwiner );
 			}
 
 			public override void RunOnce()
@@ -349,28 +349,29 @@ public static T CastleGetEntwiner<T>( AnyCall any_call ) where T : class //actua
 			return CastleProxyGenerator.CreateInterfaceProxyWithoutTarget<T>( interceptor );
 		}
 
-		public static Untwiner CastleGetUntwiner<T>( T target ) where T : class //actually, interface
+		public static AnyCall CastleGetUntwiner<T>( T target ) where T : class //actually, interface
 		{
 			// The Castle DynamicProxy does not offer any untwining functionality, so we use a reflecting untwiner.
-			return new ReflectingUntwiner( typeof(T), target );
+			return new ReflectingUntwiner( typeof(T), target ).AnyCall;
 		}
 
-		private sealed class EntwinerForCastle : Entwiner, CastleDP.IInterceptor
+		private sealed class EntwinerForCastle : CastleDP.IInterceptor
 		{
+			private readonly AnyCall any_call;
 			private readonly Dictionary<SysReflect.MethodInfo, int> selector_map = new Dictionary<SysReflect.MethodInfo, int>();
 
 			public EntwinerForCastle( System.Type interface_type, AnyCall any_call )
-					: base( interface_type, any_call )
 			{
-				var method_infos = InterfaceType.GetMethods( SysReflect.BindingFlags.Public | SysReflect.BindingFlags.NonPublic | SysReflect.BindingFlags.Instance );
+				this.any_call = any_call;
+				var method_infos = interface_type.GetMethods( SysReflect.BindingFlags.Public | SysReflect.BindingFlags.NonPublic | SysReflect.BindingFlags.Instance );
 				for( int i = 0; i < method_infos.Length; i++ )
 					selector_map.Add( method_infos[i], i );
 			}
 
 			void CastleDP.IInterceptor.Intercept( CastleDP.IInvocation invocation )
 			{
 				int selector = selector_map[invocation.Method];
-				invocation.ReturnValue = AnyCall( selector, invocation.Arguments );
+				invocation.ReturnValue = any_call( selector, invocation.Arguments );
 			}
 		}
 #endregion
@@ -475,22 +476,23 @@ public static AnyCall LinFuGetUntwiner<T>( T target )
 			return new ReflectingUntwiner( typeof(T), target ).AnyCall;
 		}
 
-		private sealed class EntwinerForLinFu : Entwiner, LinFuDP.IInterceptor
+		private sealed class EntwinerForLinFu : LinFuDP.IInterceptor
 		{
+			private readonly AnyCall any_call;
 			private readonly Dictionary<SysReflect.MethodInfo, int> selector_map = new Dictionary<SysReflect.MethodInfo, int>();
 
-			public EntwinerForLinFu( System.Type interface_type, AnyCall any_call )
-					: base( interface_type, any_call )
+			public EntwinerForLinFu( Sys.Type interface_type, AnyCall any_call )
 			{
-				var method_infos = InterfaceType.GetMethods( SysReflect.BindingFlags.Public | SysReflect.BindingFlags.NonPublic | SysReflect.BindingFlags.Instance );
+				this.any_call = any_call;
+				var method_infos = interface_type.GetMethods( SysReflect.BindingFlags.Public | SysReflect.BindingFlags.NonPublic | SysReflect.BindingFlags.Instance );
 				for( int i = 0; i < method_infos.Length; i++ )
 					selector_map.Add( method_infos[i], i );
 			}
 
 			object LinFuDP.IInterceptor.Intercept( LinFuDP.InvocationInfo info )
 			{
 				int selector = selector_map[info.TargetMethod];
-				return AnyCall( selector, info.Arguments );
+				return any_call( selector, info.Arguments );
 			}
 		}
 #endregion

Benchmark/ReflectingUntwiner.cs

@@ -2,25 +2,25 @@
 
 namespace MikeNakis.Intertwine.Benchmark
 {
+	using Sys = System;
+
 	/// <summary>
 	/// An untwiner which uses reflection to do its job. Keep for reference. WARNING: SLOW AS MOLASSES.
 	/// </summary>
-	public class ReflectingUntwiner : Untwiner
+	public class ReflectingUntwiner
 	{
-		private readonly System.Reflection.MethodInfo[] method_infos;
+		private readonly object target;
+		private readonly Sys.Reflection.MethodInfo[] method_infos;
 
-		public ReflectingUntwiner( System.Type interface_type, object target )
-				: base( interface_type )
+		public ReflectingUntwiner( Sys.Type interface_type, object target )
 		{
-			Target = target;
-			method_infos = InterfaceType.GetMethods( System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance );
+			this.target = target;
+			method_infos = interface_type.GetMethods( System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance );
 		}
 
-		public override object Target { get; }
-
-		public override object AnyCall( int selector, object[] arguments )
+		public object AnyCall( int selector, object[] arguments )
 		{
-			return method_infos[selector].Invoke( Target, arguments );
+			return method_infos[selector].Invoke( target, arguments );
 		}
 	}
 }

InterfaceEvents/InterfaceEventManager.cs

@@ -14,9 +14,9 @@ namespace MikeNakis.Intertwine.InterfaceEvents
 	[SysDiag.DebuggerDisplay( "{" + nameof(DebugView) + ",nq}" )]
 	public sealed class InterfaceEventManager<I> : IInterfaceEventSource<I> where I : class
 	{
-		[SysDiag.DebuggerBrowsable( SysDiag.DebuggerBrowsableState.RootHidden )] public Untwiner[] DebugView => untwiners.ToArray();
+		[SysDiag.DebuggerBrowsable( SysDiag.DebuggerBrowsableState.RootHidden )] public AnyCall[] DebugView => untwiners.ToArray();
 		private readonly IntertwineFactory intertwine_factory;
-		private readonly List<Untwiner> untwiners = new List<Untwiner>();
+		private readonly List<AnyCall> untwiners = new List<AnyCall>();
 
 		/// <summary>
 		/// The trigger of the event. (Invoke this to cause the event to be triggered.)
@@ -51,7 +51,7 @@ void IInterfaceEventSource<I>.RegisterObserver( bool register, I observer )
 		{
 			if( register )
 			{
-				Untwiner untwiner = intertwine_factory.GetIntertwine<I>().NewUntwiner( observer );
+				AnyCall untwiner = intertwine_factory.GetIntertwine<I>().NewUntwiningInstance( observer );
 				Dbg.Assert( !Source.IsObserverRegistered( observer ) ); //observer is already registered.
 				untwiners.Add( untwiner );
 			}
@@ -69,7 +69,7 @@ bool IInterfaceEventSource<I>.IsObserverRegistered( I observer )
 			return find_untwiner_by_observer( observer ) != null;
 		}
 
-		private Untwiner find_untwiner_by_observer( I observer )
+		private AnyCall find_untwiner_by_observer( I observer )
 		{
 			foreach( var untwiner in untwiners )
 				if( untwiner.Target == observer )
@@ -84,7 +84,7 @@ private object any_call( int selector, object[] args )
 			int hashcode = get_hashcode( args );
 			foreach( var untwiner in untwiners.ToArray() )
 			{
-				untwiner.AnyCall( selector, args );
+				untwiner.Invoke( selector, args );
 				Dbg.Assert( get_hashcode( args ) == hashcode ); // Ensure that the untwiner did not alter any arguments.
 			}
 			if( Dbg.False )
@@ -96,7 +96,7 @@ private object any_call( int selector, object[] args )
 				{
 					try
 					{
-						untwiner.AnyCall( selector, args );
+						untwiner.Invoke( selector, args );
 					}
 					catch( System.Exception e )
 					{

Intertwine.sln

@@ -4,16 +4,16 @@ VisualStudioVersion = 12.0.31101.0
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{FA184FB0-3834-44F4-A391-0AE48034E0D0}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Intertwine", "Intertwine\Intertwine.csproj", "{B840485B-A5C6-4D9B-A8FF-67E971B2C488}"
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Intertwine", "Intertwine\MikeNakis.Intertwine.csproj", "{B840485B-A5C6-4D9B-A8FF-67E971B2C488}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Test", "Test\Test.csproj", "{C2E57D84-8AF9-4992-87B2-5D8897A91481}"
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Test", "Test\MikeNakis.Intertwine Test.csproj", "{C2E57D84-8AF9-4992-87B2-5D8897A91481}"
 	ProjectSection(ProjectDependencies) = postProject
 		{B840485B-A5C6-4D9B-A8FF-67E971B2C488} = {B840485B-A5C6-4D9B-A8FF-67E971B2C488}
 	EndProjectSection
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "InterfaceEvents", "InterfaceEvents\InterfaceEvents.csproj", "{1816F332-8FC7-4E95-A8D3-2D53B33D4F9C}"
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "InterfaceEvents", "InterfaceEvents\MikeNakis.Intertwine.InterfaceEvents.csproj", "{1816F332-8FC7-4E95-A8D3-2D53B33D4F9C}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Benchmark", "Benchmark\Benchmark.csproj", "{DA9C27C3-6348-4D2A-A8B0-AF69CD49FE18}"
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Benchmark", "Benchmark\MikeNakis.Intertwine.Benchmark.csproj", "{DA9C27C3-6348-4D2A-A8B0-AF69CD49FE18}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution

Intertwine.sln.DotSettings

@@ -1,2 +1,12 @@
 <wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
-	<s:Boolean x:Key="/Default/UserDictionary/Words/=Entwiner/@EntryIndexedValue">True</s:Boolean></wpf:ResourceDictionary>
+	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/PredefinedNamingRules/=Locals/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aa_bb" /&gt;</s:String>
+	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/PredefinedNamingRules/=Parameters/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aa_bb" /&gt;</s:String>
+	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/PredefinedNamingRules/=PrivateInstanceFields/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aa_bb" /&gt;</s:String>
+	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/UserRules/=59618f95_002Dfd13_002D44b2_002D86ba_002Dd82abdd718a5/@EntryIndexedValue">&lt;Policy&gt;&lt;Descriptor Staticness="Static, Instance" AccessRightKinds="Private" Description="Method (private)"&gt;&lt;ElementKinds&gt;&lt;Kind Name="ASYNC_METHOD" /&gt;&lt;Kind Name="METHOD" /&gt;&lt;/ElementKinds&gt;&lt;/Descriptor&gt;&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aa_bb" /&gt;&lt;/Policy&gt;</s:String>
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=Entwiner/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=entwiners/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=Nakis/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=untwined/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=Untwiner/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=untwiners/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=Untwining/@EntryIndexedValue">True</s:Boolean></wpf:ResourceDictionary>

Intertwine/AnyCall.cs

@@ -7,5 +7,6 @@ namespace MikeNakis.Intertwine
 	/// <param name="selector">The ordinal number of the interface method being called.</param>
 	/// <param name="arguments">An array of objects containing the arguments of the call.</param>
 	/// <returns>An object representing the return value of the method call.</returns>
+	///<author>michael.gr</author>
 	public delegate object AnyCall( int selector, object[] arguments );
 }

Intertwine/CachingIntertwine.cs

@@ -6,7 +6,8 @@ namespace MikeNakis.Intertwine
 	using System.Collections.Generic;
 	using Sys = System;
 
-	/// <summary> A decorator of <see cref="IntertwineFactory" /> which adds caching.</summary>
+	///<summary>A decorator of <see cref="IntertwineFactory" /> which adds caching.</summary>
+	///<author>michael.gr</author>
 	public class CachingIntertwineFactory : IntertwineFactory
 	{
 		private readonly IntertwineFactory decoree;