Best JustMockLite code snippet using Telerik.JustMock.Core.Castle.DynamicProxy.Contributors.ClassProxyWithTargetTargetContributor
ClassProxyWithTargetGenerator.cs
Source:ClassProxyWithTargetGenerator.cs
...50 var methodsToSkip = new List<MethodInfo>();51 var proxyInstance = new ClassProxyWithTargetInstanceContributor(targetType, methodsToSkip, additionalInterfacesToProxy,52 ProxyTypeConstants.ClassWithTarget);53 // TODO: the trick with methodsToSkip is not very nice...54 var proxyTarget = new ClassProxyWithTargetTargetContributor(targetType, methodsToSkip, namingScope)55 { Logger = Logger };56 IDictionary<Type, ITypeContributor> typeImplementerMapping = new Dictionary<Type, ITypeContributor>();57 // Order of interface precedence:58 // 1. first target59 // target is not an interface so we do nothing60 var targetInterfaces = targetType.GetAllInterfaces();61 // 2. then mixins62 var mixins = new MixinContributor(namingScope, false) { Logger = Logger };63 if (ProxyGenerationOptions.HasMixins)64 {65 foreach (var mixinInterface in ProxyGenerationOptions.MixinData.MixinInterfaces)66 {67 if (targetInterfaces.Contains(mixinInterface))68 {...
ClassProxyWithTargetTargetContributor.cs
Source:ClassProxyWithTargetTargetContributor.cs
...21 using Telerik.JustMock.Core.Castle.DynamicProxy.Generators;22 using Telerik.JustMock.Core.Castle.DynamicProxy.Generators.Emitters;23 using Telerik.JustMock.Core.Castle.DynamicProxy.Generators.Emitters.SimpleAST;24 using Telerik.JustMock.Core.Castle.DynamicProxy.Tokens;25 internal class ClassProxyWithTargetTargetContributor : CompositeTypeContributor26 {27 private readonly IList<MethodInfo> methodsToSkip;28 private readonly Type targetType;29 public ClassProxyWithTargetTargetContributor(Type targetType, IList<MethodInfo> methodsToSkip,30 INamingScope namingScope)31 : base(namingScope)32 {33 this.targetType = targetType;34 this.methodsToSkip = methodsToSkip;35 }36 protected override IEnumerable<MembersCollector> CollectElementsToProxyInternal(IProxyGenerationHook hook)37 {38 Debug.Assert(hook != null, "hook != null");39 var targetItem = new WrappedClassMembersCollector(targetType) { Logger = Logger };40 targetItem.CollectMembersToProxy(hook);41 yield return targetItem;42 foreach (var @interface in interfaces)43 {...
ClassProxyWithTargetTargetContributor
Using AI Code Generation
1using Telerik.JustMock.Core.Castle.DynamicProxy.Contributors;2using Telerik.JustMock.Core.Castle.DynamicProxy.Generators;3using Telerik.JustMock.Core.Castle.DynamicProxy.Generators.Emitters;4using Telerik.JustMock.Core.Castle.DynamicProxy.Generators.Emitters.SimpleAST;5using Telerik.JustMock.Core.Castle.DynamicProxy.Tokens;6{7 {8 private readonly Type targetType;9 public ClassProxyWithTargetTargetContributor(Type targetType)10 : base(targetType)11 {12 this.targetType = targetType;13 }14 public override void CollectElementsToProxy(IProxyGenerationHook hook, MetaType model)15 {16 base.CollectElementsToProxy(hook, model);17 model.AddElementsToProxy(targetType);18 }19 public override void Generate(ClassEmitter @class, ProxyGenerationOptions options, INamingScope namingScope)20 {21 base.Generate(@class, options, namingScope);22 @class.AddInterfaceImplementationIfNotAlreadyImplemented(typeof(ITargetAccessor));23 }24 public override void GenerateTargetProperty(ClassEmitter @class, INamingScope namingScope)25 {26 var targetTypeField = @class.GetField("__targetType");27 var targetField = @class.GetField("__target");28 var getTarget = new MethodReturnStatement(29 new CastExpression(30 new MethodInvocationExpression(31 new MethodInvocationExpression(32 new SelfReferenceExpression(),33 new ReferenceExpression(targetTypeField))));34 var setTarget = new ExpressionStatement(35 new AssignmentStatement(36 new ReferenceExpression(targetField),37 new CastExpression(38 new ReferenceExpression("__target"))));39 var targetProperty = new PropertyEmitter(40 new[] { typeof(ITargetAccessor) },41 setTarget);42 targetProperty.Generate();43 }44 public override void GenerateFields(ClassEmitter @class, INamingScope namingScope)45 {46 base.GenerateFields(@class, namingScope);47 @class.CreateField("__targetType", targetType);48 @class.CreateField("__target", typeof(object));49 }50 public override void GenerateMethods(ClassEmitter @class, ProxyGenerationOptions options, INamingScope namingScope)51 {52 base.GenerateMethods(@class, options
ClassProxyWithTargetTargetContributor
Using AI Code Generation
1using Telerik.JustMock.Core.Castle.DynamicProxy.Contributors;2using Telerik.JustMock.Core.Castle.DynamicProxy.Generators;3using Telerik.JustMock.Core.Castle.DynamicProxy.Generators.Emitters;4using Telerik.JustMock.Core.Castle.DynamicProxy.Generators.Emitters.SimpleAST;5using Telerik.JustMock.Core.Castle.DynamicProxy.Tokens;6using Telerik.JustMock.Core.Castle.DynamicProxy;7using System;8using System.Reflection;9{10 {11 private readonly Type targetType;12 public ClassProxyWithTargetTargetContributor(Type targetType, Type proxyType, ProxyGenerationOptions options, INamingScope namingScope)13 : base(proxyType, options, namingScope)14 {15 this.targetType = targetType;16 }17 protected override void GenerateFields(ClassEmitter @class)18 {19 base.GenerateFields(@class);20 @class.CreateField("__target", targetType);21 }22 protected override void GenerateConstructor(ClassEmitter @class, ConstructorInfo constructor, ConstructorInfo baseConstructor, Reference targetFieldReference)23 {24 var parameters = constructor.GetParameters();25 var arguments = new ArgumentReference[parameters.Length];26 var constructorArgs = new Expression[parameters.Length + 1];27 for (var i = 0; i < parameters.Length; i++)28 {29 var parameter = parameters[i];30 var argument = new ArgumentReference(parameter.ParameterType, parameter.Name);31 arguments[i] = argument;32 constructorArgs[i] = argument.ToExpression();33 }34 constructorArgs[parameters.Length] = targetFieldReference.ToExpression();35 var baseCtorCall = new ConstructorInvocationExpression(baseConstructor, constructorArgs);36 var ctor = @class.CreateConstructor(constructor.Attributes, arguments);37 ctor.CodeBuilder.AddStatement(baseCtorCall);38 }39 protected override void GenerateMethods(ClassEmitter @class, MethodCollection methods)40 {41 var targetTypeMethods = targetType.GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);42 var targetField = @class.GetField("__target");43 var targetFieldReference = new FieldReference(targetField);44 foreach (var method in methods)45 {46 var targetTypeMethod = Array.Find(targetTypeMethods, m => m.Name == method.Method.Name && m.GetParameters().Length == method.Method.GetParameters().Length);47 if (targetTypeMethod == null)
ClassProxyWithTargetTargetContributor
Using AI Code Generation
1using Telerik.JustMock.Core.Castle.DynamicProxy.Contributors;2using Telerik.JustMock.Core.Castle.DynamicProxy.Generators;3using Telerik.JustMock.Core.Castle.DynamicProxy.Generators.Emitters;4using Telerik.JustMock.Core.Castle.DynamicProxy.Generators.Emitters.SimpleAST;5using Telerik.JustMock.Core.Castle.DynamicProxy.Generators.Emitters.SimpleAST.CodeTargets;6using Telerik.JustMock.Core.Castle.DynamicProxy.Internal;7{8 {9 private readonly IProxyGenerationHook hook;10 public ClassProxyWithTargetTargetContributor(Type targetType, IProxyGenerationHook hook)11 : base(targetType)12 {13 this.hook = hook;14 }15 public override void CollectElementsToProxy(IProxyGenerationHook hook, MetaType model)16 {17 base.CollectElementsToProxy(hook, model);18 CollectElementsToProxyForTarget(hook, model);19 }20 protected override void CollectElementsToProxyForTarget(IProxyGenerationHook hook, MetaType model)21 {22 if (this.hook == null)23 {24 base.CollectElementsToProxyForTarget(hook, model);25 }26 {27 base.CollectElementsToProxyForTarget(this.hook, model);28 }29 }30 public override void Generate(ClassEmitter @class, ProxyGenerationOptions options)31 {32 var targetField = @class.CreateField("__target", TargetType);33 var target = new Reference(targetField);34 var targetReference = new Reference("__target");35 var targetFieldReference = new FieldReference(targetField);36 @class.CreateConstructor(37 new ArgumentReference[] { targetReference },38 {39 new AssignStatement(targetFieldReference, targetReference),40 });41 var targetGet = new MethodReturnStatement(target);42 var targetGetCodeTarget = new CodeTarget(targetGet);43 var targetSet = new AssignStatement(targetFieldReference, targetReference);44 var targetSetCodeTarget = new CodeTarget(targetSet);45 @class.CreateProperty("__Target", TargetType, targetGetCodeTarget, targetSetCodeTarget);46 base.Generate(@class, options);
ClassProxyWithTargetTargetContributor
Using AI Code Generation
1using Telerik.JustMock.Core.Castle.DynamicProxy.Contributors;2using Telerik.JustMock.Core.Castle.DynamicProxy.Generators.Emitters.SimpleAST;3using Telerik.JustMock.Core.Castle.DynamicProxy.Generators.Emitters;4{5 {6 public ClassProxyWithTargetTargetContributor(Type targetType, Type[] interfaces, IProxyGenerationHook hook, INamingScope namingScope, ProxyGenerationOptions options)7 : base(targetType, interfaces, hook, namingScope, options)8 {9 }10 protected override void CollectElementsToProxy(IProxyGenerationHook hook, MetaType model)11 {12 base.CollectElementsToProxy(hook, model);13 model.NonPublicMembersToProxy.AddMembersOfBaseTypes = true;14 }15 protected override void GenerateFields(ClassEmitter @class)16 {17 base.GenerateFields(@class);18 @class.CreateField("__target", TargetType);19 }20 protected override void GenerateConstructor(ClassEmitter @class, ConstructorInfo constructor, ConstructorInfo baseConstructor, FieldReference interceptorsField)21 {22 {23 new ArgumentReference(typeof(object[]), "__arguments"),24 new ArgumentReference(typeof(IInterceptor[]), "__interceptors"),25 new ArgumentReference(typeof(object), "__target")26 };27 var constructorEmitter = @class.CreateConstructor(arguments, baseConstructor);28 constructorEmitter.CodeBuilder.AddStatement(new AssignStatement(new FieldReference("__target"), arguments[2]));29 constructorEmitter.CodeBuilder.AddStatement(new AssignStatement(new FieldReference("__interceptors"), arguments[1]));30 constructorEmitter.CodeBuilder.AddStatement(new AssignStatement(new FieldReference("__arguments"), arguments[0]));31 constructorEmitter.CodeBuilder.AddStatement(new AssignStatement(new FieldReference("__target"), arguments[2]));32 constructorEmitter.CodeBuilder.AddStatement(new AssignStatement(new FieldReference("__interceptors"), arguments[1]));33 constructorEmitter.CodeBuilder.AddStatement(new AssignStatement(new FieldReference("__arguments"), arguments[0]));34 }35 protected override void GenerateMethods(ClassEmitter @class, MetaType model)36 {37 foreach (var method in model.GetNonAbstractMethods())38 {39 GenerateMethod(@class, method, model);40 }41 }42 protected override Expression GetTargetExpression()43 {44 return new FieldReference("__target");45 }
ClassProxyWithTargetTargetContributor
Using AI Code Generation
1using System;2using System.Collections.Generic;3using System.Linq;4using System.Text;5using System.Threading.Tasks;6using Telerik.JustMock.Core.Castle.DynamicProxy;7using Telerik.JustMock.Core.Castle.DynamicProxy.Contributors;8{9 {10 static void Main(string[] args)11 {12 var classProxyWithTargetTargetContributor = new ClassProxyWithTargetTargetContributor(typeof(Proxy), typeof(Proxy));13 classProxyWithTargetTargetContributor.ProxyTargetType = true;14 var proxyGenerator = new ProxyGenerator();15 var proxy = proxyGenerator.CreateClassProxyWithTarget(typeof(Proxy), new Proxy(), classProxyWithTargetTargetContributor);16 }17 }18 {19 public virtual string Test()20 {21 return "test";22 }23 }24}
ClassProxyWithTargetTargetContributor
Using AI Code Generation
1{2 using System;3 using System.Collections.Generic;4 using System.Linq;5 using System.Reflection;6 using System.Reflection.Emit;7 using System.Security;8 using System.Security.Permissions;9 using System.Security.Policy;10 using System.Text;11 using System.Threading.Tasks;12 using Telerik.JustMock.Core.Castle.Core.Internal;13 using Telerik.JustMock.Core.Castle.DynamicProxy.Generators;14 using Telerik.JustMock.Core.Castle.DynamicProxy.Generators.Emitters;15 using Telerik.JustMock.Core.Castle.DynamicProxy.Generators.Emitters.SimpleAST;16 using Telerik.JustMock.Core.Castle.DynamicProxy.Internal;17 using Telerik.JustMock.Core.Castle.DynamicProxy.Tokens;18 {19 private readonly Type targetType;20 public ClassProxyWithTargetTargetContributor(Type targetType, Type serviceType, ProxyGenerationOptions options)21 : base(serviceType, options)22 {23 this.targetType = targetType;24 }25 protected override void CollectElementsToProxy(IProxyGenerationHook hook, MetaType model)26 {27 base.CollectElementsToProxy(hook, model);28 model.AddElementsToProxy(targetType.GetInterfaces());29 }30 protected override ConstructorInfo ObtainProxiedTypeConstructor()31 {32 return targetType.GetConstructor(Type.EmptyTypes);33 }34 protected override void Generate(IProxyEmitter proxyEmitter, ClassEmitter @class, ConstructorInfo constructor, ConstructorInfo proxyTargetConstructor)35 {36 base.Generate(proxyEmitter, @class, constructor, proxyTargetConstructor);37 var proxyTargetField = @class.GetField("__target");38 var proxyTargetTypeField = @class.GetField("__targetType");39 var targetTypeLocal = @class.GetField("__targetType");40 var targetLocal = @class.GetField("__target");41 var targetType = this.targetType;42 var targetTypeConstructor = targetType.GetConstructor(Type.EmptyTypes);43 @class.AddMethod(44 new MethodAttributes(),45 new ReturnStatement(targetLocal));46 @class.AddMethod(47 new MethodAttributes(),48 typeof(Type
ClassProxyWithTargetTargetContributor
Using AI Code Generation
1using Telerik.JustMock.Core.Castle.DynamicProxy.Contributors;2using Telerik.JustMock.Core.Castle.DynamicProxy.Generators;3using System;4using System.Collections.Generic;5using System.Linq;6using System.Text;7using System.Threading.Tasks;8{9 {10 static void Main(string[] args)11 {12 var proxyGenerator = new ProxyGenerator();13 var proxy = proxyGenerator.CreateClassProxyWithTarget<Hello>(new Hello(), new ClassProxyWithTargetTargetContributor(), new ClassProxyWithTargetTargetContributor());14 proxy.Hi();15 }16 }17 {18 public void Hi()19 {20 Console.WriteLine("Hello");21 }22 }23}24using Telerik.JustMock.Core.Castle.DynamicProxy;25using Telerik.JustMock.Core.Castle.DynamicProxy.Contributors;26using Telerik.JustMock.Core.Castle.DynamicProxy.Generators;27using System;28using System.Collections.Generic;29using System.Linq;30using System.Text;31using System.Threading.Tasks;32{33 {34 static void Main(string[] args)35 {36 var proxyGenerator = new ProxyGenerator();37 var proxy = proxyGenerator.CreateClassProxyWithTarget<Hello>(new Hello(), new ClassProxyWithTargetTargetContributor());38 proxy.Hi();39 }40 }41 {42 public void Hi()43 {44 Console.WriteLine("Hello");45 }46 }47}
Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.
You could also refer to video tutorials over LambdaTest YouTube channel to get step by step demonstration from industry experts.
Get 100 minutes of automation test minutes FREE!!