How to use MetaMethod class of Telerik.JustMock.Core.Castle.DynamicProxy.Generators package

...47				item.CollectMembersToProxy(hook);48				yield return item;49			}50		}51		protected override MethodGenerator GetMethodGenerator(MetaMethod method, ClassEmitter @class,52		                                                      ProxyGenerationOptions options,53		                                                      OverrideMethodDelegate overrideMethod)54		{55			if (methodsToSkip.Contains(method.Method))56			{57				return null;58			}59			if (!method.Proxyable)60			{61				return new MinimialisticMethodGenerator(method,62				                                        overrideMethod);63			}64			if (ExplicitlyImplementedInterfaceMethod(method))65			{66				return ExplicitlyImplementedInterfaceMethodGenerator(method, @class, options, overrideMethod);67			}68			var invocation = GetInvocationType(method, @class, options);69			GetTargetExpressionDelegate getTargetTypeExpression = (c, m) => new TypeTokenExpression(targetType);70			return new MethodWithInvocationGenerator(method,71			                                         @class.GetField("__interceptors"),72			                                         invocation,73			                                         getTargetTypeExpression,74			                                         getTargetTypeExpression,75			                                         overrideMethod,76			                                         null);77		}78		private Type BuildInvocationType(MetaMethod method, ClassEmitter @class, ProxyGenerationOptions options)79		{80			var methodInfo = method.Method;81			if (!method.HasTarget)82			{83				return new InheritanceInvocationTypeGenerator(targetType,84				                                              method,85				                                              null, null)86					.Generate(@class, options, namingScope)87					.BuildType();88			}89			var callback = CreateCallbackMethod(@class, methodInfo, method.MethodOnTarget);90			return new InheritanceInvocationTypeGenerator(callback.DeclaringType,91			                                              method,92			                                              callback, null)93				.Generate(@class, options, namingScope)94				.BuildType();95		}96		private MethodBuilder CreateCallbackMethod(ClassEmitter emitter, MethodInfo methodInfo, MethodInfo methodOnTarget)97		{98			var targetMethod = methodOnTarget ?? methodInfo;99			var callBackMethod = emitter.CreateMethod(namingScope.GetUniqueName(methodInfo.Name + "_callback"), targetMethod);100			if (targetMethod.IsGenericMethod)101			{102				targetMethod = targetMethod.MakeGenericMethod(callBackMethod.GenericTypeParams.AsTypeArray());103			}104			var exps = new Expression[callBackMethod.Arguments.Length];105			for (var i = 0; i < callBackMethod.Arguments.Length; i++)106			{107				exps[i] = callBackMethod.Arguments[i].ToExpression();108			}109			// invocation on base class110			callBackMethod.CodeBuilder.AddStatement(111				new ReturnStatement(112					new MethodInvocationExpression(SelfReference.Self,113					                               targetMethod,114					                               exps)));115			return callBackMethod.MethodBuilder;116		}117		private bool ExplicitlyImplementedInterfaceMethod(MetaMethod method)118		{119			return method.MethodOnTarget.IsPrivate;120		}121		private MethodGenerator ExplicitlyImplementedInterfaceMethodGenerator(MetaMethod method, ClassEmitter @class,122		                                                                      ProxyGenerationOptions options,123		                                                                      OverrideMethodDelegate overrideMethod)124		{125			var @delegate = GetDelegateType(method, @class, options);126			var contributor = GetContributor(@delegate, method);127			var invocation = new InheritanceInvocationTypeGenerator(targetType, method, null, contributor)128				.Generate(@class, options, namingScope)129				.BuildType();130			return new MethodWithInvocationGenerator(method,131			                                         @class.GetField("__interceptors"),132			                                         invocation,133			                                         (c, m) => new TypeTokenExpression(targetType),134			                                         overrideMethod,135			                                         contributor);136		}137		private IInvocationCreationContributor GetContributor(Type @delegate, MetaMethod method)138		{139			if (@delegate.GetTypeInfo().IsGenericType == false)140			{141				return new InvocationWithDelegateContributor(@delegate, targetType, method, namingScope);142			}143			return new InvocationWithGenericDelegateContributor(@delegate,144			                                                    method,145			                                                    new FieldReference(InvocationMethods.ProxyObject));146		}147		private Type GetDelegateType(MetaMethod method, ClassEmitter @class, ProxyGenerationOptions options)148		{149			var scope = @class.ModuleScope;150			var key = new CacheKey(151				typeof(Delegate).GetTypeInfo(),152				targetType,153				new[] { method.MethodOnTarget.ReturnType }154					.Concat(ArgumentsUtil.GetTypes(method.MethodOnTarget.GetParameters())).155					ToArray(),156				null);157			var type = scope.GetFromCache(key);158			if (type != null)159			{160				return type;161			}162			type = new DelegateTypeGenerator(method, targetType)163				.Generate(@class, options, namingScope)164				.BuildType();165			scope.RegisterInCache(key, type);166			return type;167		}168		private Type GetInvocationType(MetaMethod method, ClassEmitter @class, ProxyGenerationOptions options)169		{170			// NOTE: No caching since invocation is tied to this specific proxy type via its invocation method171			return BuildInvocationType(method, @class, options);172		}173	}174}...

...46				item.CollectMembersToProxy(hook);47				yield return item;48			}49		}50		protected override MethodGenerator GetMethodGenerator(MetaMethod method, ClassEmitter @class,51		                                                      ProxyGenerationOptions options,52		                                                      OverrideMethodDelegate overrideMethod)53		{54			if (methodsToSkip.Contains(method.Method))55			{56				return null;57			}58			if (!method.Proxyable)59			{60				return new MinimialisticMethodGenerator(method,61				                                        overrideMethod);62			}63			if (IsDirectlyAccessible(method) == false)64			{65				return IndirectlyCalledMethodGenerator(method, @class, options, overrideMethod);66			}67			var invocation = GetInvocationType(method, @class, options);68			return new MethodWithInvocationGenerator(method,69			                                         @class.GetField("__interceptors"),70			                                         invocation,71			                                         (c, m) => c.GetField("__target").ToExpression(),72			                                         overrideMethod,73			                                         null);74		}75		private Type BuildInvocationType(MetaMethod method, ClassEmitter @class, ProxyGenerationOptions options)76		{77			if (!method.HasTarget)78			{79				return new InheritanceInvocationTypeGenerator(targetType,80				                                              method,81				                                              null, null)82					.Generate(@class, options, namingScope)83					.BuildType();84			}85			return new CompositionInvocationTypeGenerator(method.Method.DeclaringType,86			                                              method,87			                                              method.Method,88			                                              false,89			                                              null)90				.Generate(@class, options, namingScope)91				.BuildType();92		}93		private IInvocationCreationContributor GetContributor(Type @delegate, MetaMethod method)94		{95			if (@delegate.GetTypeInfo().IsGenericType == false)96			{97				return new InvocationWithDelegateContributor(@delegate, targetType, method, namingScope);98			}99			return new InvocationWithGenericDelegateContributor(@delegate,100			                                                    method,101			                                                    new FieldReference(InvocationMethods.Target));102		}103		private Type GetDelegateType(MetaMethod method, ClassEmitter @class, ProxyGenerationOptions options)104		{105			var scope = @class.ModuleScope;106			var key = new CacheKey(107				typeof(Delegate).GetTypeInfo(),108				targetType,109				new[] { method.MethodOnTarget.ReturnType }110					.Concat(ArgumentsUtil.GetTypes(method.MethodOnTarget.GetParameters())).111					ToArray(),112				null);113			var type = scope.GetFromCache(key);114			if (type != null)115			{116				return type;117			}118			type = new DelegateTypeGenerator(method, targetType)119				.Generate(@class, options, namingScope)120				.BuildType();121			scope.RegisterInCache(key, type);122			return type;123		}124		private Type GetInvocationType(MetaMethod method, ClassEmitter @class, ProxyGenerationOptions options)125		{126			var scope = @class.ModuleScope;127			var invocationInterfaces = new[] { typeof(IInvocation) };128			var key = new CacheKey(method.Method, CompositionInvocationTypeGenerator.BaseType, invocationInterfaces, null);129			// no locking required as we're already within a lock130			var invocation = scope.GetFromCache(key);131			if (invocation != null)132			{133				return invocation;134			}135			invocation = BuildInvocationType(method, @class, options);136			scope.RegisterInCache(key, invocation);137			return invocation;138		}139		private MethodGenerator IndirectlyCalledMethodGenerator(MetaMethod method, ClassEmitter proxy,140		                                                        ProxyGenerationOptions options,141		                                                        OverrideMethodDelegate overrideMethod)142		{143			var @delegate = GetDelegateType(method, proxy, options);144			var contributor = GetContributor(@delegate, method);145			var invocation = new CompositionInvocationTypeGenerator(targetType, method, null, false, contributor)146				.Generate(proxy, options, namingScope)147				.BuildType();148			return new MethodWithInvocationGenerator(method,149			                                         proxy.GetField("__interceptors"),150			                                         invocation,151			                                         (c, m) => c.GetField("__target").ToExpression(),152			                                         overrideMethod,153			                                         contributor);154		}155		private bool IsDirectlyAccessible(MetaMethod method)156		{157			return method.MethodOnTarget.IsPublic;158		}159	}160}...

...24	using Telerik.JustMock.Core.Castle.DynamicProxy.Tokens;25	internal class InvocationWithGenericDelegateContributor : IInvocationCreationContributor26	{27		private readonly Type delegateType;28		private readonly MetaMethod method;29		private readonly Reference targetReference;30		public InvocationWithGenericDelegateContributor(Type delegateType, MetaMethod method, Reference targetReference)31		{32			Debug.Assert(delegateType.GetTypeInfo().IsGenericType, "delegateType.IsGenericType");33			this.delegateType = delegateType;34			this.method = method;35			this.targetReference = targetReference;36		}37		public ConstructorEmitter CreateConstructor(ArgumentReference[] baseCtorArguments, AbstractTypeEmitter invocation)38		{39			return invocation.CreateConstructor(baseCtorArguments);40		}41		public MethodInfo GetCallbackMethod()42		{43			return delegateType.GetMethod("Invoke");44		}...

1using Telerik.JustMock.Core.Castle.DynamicProxy.Generators;2using Telerik.JustMock.Core.Castle.DynamicProxy.Generators.Emitters;3using Telerik.JustMock.Core.Castle.DynamicProxy.Generators.Emitters.SimpleAST;4using System.Reflection;5using System;6{7    {8        static void Main(string[] args)9        {10            var method = new MethodEmitter(null, null, null, null, null, null);11            var meta = new MetaMethod(method, typeof(TestClass), null, null, null);12            var methodInfo = meta.GetMethod();13            Console.WriteLine(methodInfo);14        }15    }16    {17        public void TestMethod()18        {19        }20    }21}22using Telerik.JustMock.Core.Castle.DynamicProxy.Generators;23using Telerik.JustMock.Core.Castle.DynamicProxy.Generators.Emitters;24using Telerik.JustMock.Core.Castle.DynamicProxy.Generators.Emitters.SimpleAST;25using System.Reflection;26using System;27{28    {29        static void Main(string[] args)30        {31            var method = new MethodEmitter(null, null, null, null, null, null);32            var meta = new MetaMethod(method, typeof(TestClass), null, null, null);33            var methodInfo = meta.GetMethod();34            Console.WriteLine(methodInfo);35        }36    }37    {38        public void TestMethod()39        {40        }41    }42}

1using System;2using System.Collections.Generic;3using System.Linq;4using System.Text;5using System.Threading.Tasks;6using Telerik.JustMock.Core.Castle.DynamicProxy.Generators;7using Telerik.JustMock.Core.Context;8using Telerik.JustMock.Core;9{10    {11        public void Test()12        {13            var metaMethod = new MetaMethod();14            var method = typeof(TestClass).GetMethod("Test");15            metaMethod.Initialize(method);16            var mock = Mock.Create<TestClass>();17            Mock.Arrange(() => mock.Test(Arg.IsAny<int>(), Arg.IsAny<string>())).Returns(1);18            var result = metaMethod.Invoke(mock, new object[] { 1, "test" });19            Console.WriteLine(result);20        }21        {22            public int Test(int i, string s)23            {24                return 0;25            }26        }27    }28}

1using Telerik.JustMock.Core.Castle.DynamicProxy.Generators;2using Telerik.JustMock.Core.Castle.Core.Internal;3using Telerik.JustMock.Core.Castle.Core;4using Telerik.JustMock.Core.Castle.Core.Internal;5using Telerik.JustMock.Core.Castle.Core;6using Telerik.JustMock.Core.Castle.Core.Internal;7using Telerik.JustMock.Core.Castle.Core;8using Telerik.JustMock.Core.Castle.Core.Internal;9using Telerik.JustMock.Core.Castle.Core;10using Telerik.JustMock.Core.Castle.Core.Internal;11using Telerik.JustMock.Core.Castle.Core;12using Telerik.JustMock.Core.Castle.Core.Internal;13using Telerik.JustMock.Core.Castle.Core;14using Telerik.JustMock.Core.Castle.Core.Internal;15using Telerik.JustMock.Core.Castle.Core;16using Telerik.JustMock.Core.Castle.Core.Internal;17using Telerik.JustMock.Core.Castle.Core;

1using Telerik.JustMock.Core.Castle.DynamicProxy.Generators;2using System;3using System.Collections.Generic;4using System.Linq;5using System.Text;6using System.Threading.Tasks;7{8    {9        static void Main(string[] args)10        {11            var mm = new MetaMethod(typeof(Program), "Main", new Type[] { typeof(string[]) }, typeof(void));12            Console.WriteLine(mm.ToString());13            Console.Read();14        }15    }16}

1using System;2using System.Collections.Generic;3using System.Linq;4using System.Text;5using System.Threading.Tasks;6using Telerik.JustMock.Core.Castle.DynamicProxy.Generators.Emitters.SimpleAST;7{8    {9        public virtual void Foo()10        {11            Console.WriteLine("Foo");12        }13    }14}15using System;16using System.Collections.Generic;17using System.Linq;18using System.Text;19using System.Threading.Tasks;20using Telerik.JustMock.Core.Castle.DynamicProxy.Generators.Emitters.SimpleAST;21{22    {23        public virtual void Foo()24        {25            Console.WriteLine("Foo");26        }27    }28}29using System;30using System.Collections.Generic;31using System.Linq;32using System.Text;33using System.Threading.Tasks;34using Telerik.JustMock.Core.Castle.DynamicProxy.Generators.Emitters.SimpleAST;35{36    {37        public virtual void Foo()38        {39            Console.WriteLine("Foo");40        }41    }42}43using System;44using System.Collections.Generic;45using System.Linq;46using System.Text;47using System.Threading.Tasks;48using Telerik.JustMock.Core.Castle.DynamicProxy.Generators.Emitters.SimpleAST;49{50    {51        public virtual void Foo()52        {53            Console.WriteLine("Foo");54        }55    }56}

1using Telerik.JustMock.Core.Castle.DynamicProxy.Generators;2using System;3using System.Collections.Generic;4using System.Linq;5using System.Text;6using System.Threading.Tasks;7{8    {9        public Class1()10        {11            var metaMethod = new MetaMethod();12        }13    }14}15var mock = Mock.Create<Class1>();

1using Telerik.JustMock.Core.Castle.DynamicProxy.Generators;2using System;3using System.Reflection;4{5    {6        static void Main(string[] args)7        {8            var method = new MetaMethod(typeof(Program), "TestMethod", new Type[] { typeof(string) });9            Console.WriteLine(method.ToString());10        }11        public void TestMethod(string test)12        {13        }14    }15}16public void TestMethod(System.String test)

1using System;2using System.Collections.Generic;3using System.Linq;4using System.Text;5using System.Threading.Tasks;6using Telerik.JustMock.Core.Castle.DynamicProxy.Generators;7using Telerik.JustMock.Core.Castle.DynamicProxy.Generators.Emitters.SimpleAST;8using Telerik.JustMock.Core.Castle.DynamicProxy.Generators.Emitters;9using System.Reflection.Emit;10using System.Reflection;11{12    {13        public void Test()14        {15            var method = new MetaMethod(typeof(void), "Method", new Type[] { typeof(int) });16            var method2 = new MetaMethod(typeof(void), "Method", new Type[] { typeof(int) });17            var method3 = new MetaMethod(typeof(void), "Method", new Type[] { typeof(int), typeof(int) });18            var method4 = new MetaMethod(typeof(void), "Method", new Type[] { typeof(int), typeof(int) });19            var method5 = new MetaMethod(typeof(void), "Method", new Type[] { typeof(int), typeof(int), typeof(int) });20            var method6 = new MetaMethod(typeof(void), "Method", new Type[] { typeof(int), typeof(int), typeof(int) });21            var method7 = new MetaMethod(typeof(void), "Method", new Type[] { typeof(int), typeof(int), typeof(int), typeof(int) });22            var method8 = new MetaMethod(typeof(void), "Method", new Type[] { typeof(int), typeof(int), typeof(int), typeof(int) });23            var method9 = new MetaMethod(typeof(void), "Method", new Type[] { typeof(int), typeof(int), typeof(int), typeof(int), typeof(int) });24            var method10 = new MetaMethod(typeof(void), "Method", new Type[] { typeof(int), typeof(int), typeof(int), typeof(int), typeof(int) });25            var method11 = new MetaMethod(typeof(void), "Method", new Type[] { typeof(int), typeof(int), typeof(int), typeof(int), typeof(int), typeof(int) });26            var method12 = new MetaMethod(typeof(void), "Method", new Type[] { typeof(int), typeof(int), typeof(int), typeof(int), typeof(int), typeof(int) });27            var method13 = new MetaMethod(typeof(void), "Method", new Type[] { typeof(int), typeof(int), typeof(int), typeof(int), typeof(int

1using System;2using System.Reflection;3using Telerik.JustMock.Core.Castle.DynamicProxy.Generators;4{5    public static void Main()6    {7        var method = new MetaMethod("Test", typeof(string), new Type[0], null, null);8        var result = method.Invoke(new Program(), new object[0]);9        Console.WriteLine(result);10    }11    public string Test()12    {13        return "Hello World";14    }15}16Error CS0234 The type or namespace name 'DynamicProxy' does not exist in the namespace 'Telerik.JustMock.Core.Castle' (are you missing an assembly reference?) ConsoleApp1 C:\Users\Me\source\repos\ConsoleApp1\ConsoleApp1\Program.cs 5 Active

1{2    public virtual void Method1()3    {4    }5}6{7    public override void Method1()8    {9        var method = new MetaMethod(typeof(Foo).GetMethod("Method1"));10        var parameters = method.GetParameters();11    }12}