/// <summary> /// Wraps a matcher in a proxy that checks assertion results, formats /// error messages, and performs other housekeeping. /// </summary> /// <typeparam name="TActual"> /// The type of object tested by the wrapped matcher. /// </typeparam> /// <typeparam name="TMatcher"> /// The type of matcher to be wrapped. /// </typeparam> /// <param name="actual"> /// The actual value being tested. /// </param> /// <returns> /// Returns a wrapped matcher that tests the <paramref name="actual"/> /// value given. /// </returns> public static TMatcher Wrap <TActual, TMatcher>(TActual actual) where TMatcher : BaseMatcher <TActual, TMatcher> { var matcher = (TMatcher)ProxyGenerator.CreateClassProxy( typeof(TMatcher), ProxyGenerationOptions, new NullActualInterceptor <TActual, TMatcher>(), new ErrorInterceptor <TActual, TMatcher>()); var inverted = (TMatcher)ProxyGenerator.CreateClassProxy( typeof(TMatcher), ProxyGenerationOptions, new NullActualInterceptor <TActual, TMatcher>(), new ErrorInterceptor <TActual, TMatcher>(), new InversionInterceptor <TActual, TMatcher>()); matcher.Not = inverted; matcher.actual = actual; inverted.Not = matcher; inverted.actual = actual; inverted.inverted = true; matcher.InvokeInitializer(); inverted.InvokeInitializer(); return(matcher); }
public object Read(object id, Type type) { ValidateId(id); var result = SqlQuery(command => { command.CommandText = "SELECT Value, Type FROM KeyValueStore WHERE Id = @id AND type = @type"; command.Parameters.AddWithValue("@id", id); command.Parameters.AddWithValue("@type", GetDefinition(type).Name); var reader = command.ExecuteReader(); if (!reader.Read()) { return(null); } return(new Tuple <string, string>( reader.GetString(reader.GetOrdinal("Value")), reader.GetString(reader.GetOrdinal("Type")))); }); if (result == null) { return(null); } var instance = Deserialize(result.Item1, type); return(ProxyGenerator.CreateClassProxy(type, new[] { typeof(IProxy) }, new CallInterceptor(instance, this, id))); }
/// <summary> /// Creates a proxy instance of the specified proxy type using the specified target. /// </summary> /// <typeparam name="TProxy">The type of the proxy.</typeparam> /// <param name="target">The target.</param> /// <param name="interceptor">The interceptor.</param> /// <param name="interfaces">The interfaces.</param> /// <returns></returns> /// <exception cref="ArgumentNullException">The <paramref name="target" /> is <c>null</c>.</exception> /// <exception cref="ArgumentNullException">The <paramref name="interceptor" /> is <c>null</c>.</exception> public TProxy Create <TProxy>(TProxy target, IInterceptor interceptor, params Type[] interfaces) { Argument.IsNotNull("target", target); Argument.IsNotNull("interceptor", interceptor); var interceptorAdapter = new InterceptorAdapter(interceptor, target); var proxyType = typeof(TProxy); if (!proxyType.IsInterfaceEx()) { return ((TProxy) _proxyGenerator.CreateClassProxy(proxyType, interfaces, new Castle.DynamicProxy.IInterceptor[] { interceptorAdapter })); } return ((TProxy) _proxyGenerator.CreateInterfaceProxyWithoutTarget(proxyType, interfaces, new Castle.DynamicProxy.IInterceptor[] { interceptorAdapter })); }
internal static T ToEntity <T>(SPListItem listItem, bool reloadLookupItem = true) { if (listItem == null) { return(default(T)); } var itemType = typeof(T); var props = itemType.GetProperties(); foreach (var prop in props) { if (CommonHelper.IsPropertyNotMapped(prop)) { continue; } Assert.IsPropertyVirtual(prop); } var entity = _proxyGenerator.CreateClassProxy( itemType, new DocumentAccessInterceptor(listItem), new ItemAccessInterceptor(listItem, reloadLookupItem)); return((T)entity); }
public static T Get <T>(params object[] parameters) { Init(); T proxiedObject = default(T); try { if (null == parameters || 0 == parameters.Length) { proxiedObject = (T)_generator.CreateClassProxy( typeof(T), new LoggingAspect(), new ErrorHandlingAspect()); } else { proxiedObject = (T)_generator.CreateClassProxy( typeof(T), parameters, new LoggingAspect(), new ErrorHandlingAspect()); } } catch (Exception eProxification) { var logger = LogManager.GetLogger(Tmx_Core_Resources.LogName); logger.Error("Failed to proxify type {0}", typeof(T).Name); logger.Error(eProxification); } return(proxiedObject); }
public object Create(Type mixinType, object[] args, IEnumerable <object> implementations) { var options = new ProxyGenerationOptions(); if (implementations != null) { foreach (var impl in implementations) { options.AddMixinInstance(impl); } } try { if (!options.HasMixins && !mixinType.IsAbstract) { return(Activator.CreateInstance(mixinType, args)); } return(Generator.CreateClassProxy(mixinType, options, args)); } catch (MissingMethodException mme) { throw new FrameworkException( "Can't create instance of an {0}. Arguments: ({1})".With( mixinType.Name, string.Join(", ", args.Select(it => "{0}: {1}".With( it != null ? it.GetType().Name : "<unknown>", it != null ? it.ToString() : "<null>")))), mme); } }
public TProxy Create <TProxy>(TProxy target, IInterceptor interceptor, params Type[] interfaces) { var adapter = new CastleInterceptorAdapter(interceptor, target); return(typeof(TProxy).IsInterface ? (TProxy)factory.CreateInterfaceProxyWithoutTarget(typeof(TProxy), interfaces, adapter) : (TProxy)factory.CreateClassProxy(typeof(TProxy), interfaces, adapter)); }
public void CreateSerializable() { ProxyObjectReference.ResetScope(); MySerializableClass proxy = (MySerializableClass) generator.CreateClassProxy(typeof(MySerializableClass), new StandardInterceptor()); Assert.IsTrue(proxy.GetType().IsSerializable); }
public override bool TryConvert(ConvertBinder binder, out object result) { var type = binder.Type; result = type.IsInterface ? _generator.CreateInterfaceProxyWithoutTarget(type, _interceptor) : _generator.CreateClassProxy(type, _interceptor); return(true); }
public void RunCreationTests() { var time = Run("new", TimeSpan.Zero, () => new Model()); Run("activator", time, () => Activator.CreateInstance <Model>()); Run("castle", time, () => _proxyGenerator.CreateClassProxy <Model>()); Run("castle.interface", time, () => _proxyGenerator.CreateInterfaceProxyWithTarget <IHello>(new Model())); Run("cob", time, () => new CBO()); }
public static void Test() { var generator = new ProxyGenerator(); var myObject = generator.CreateClassProxy <CastleDynamicProxy>(new MyInterceptorAspect()); var myOtherObject = generator.CreateClassProxy <MyOtherClass>(new MyInterceptorAspect()); myObject.DoStuff(); Console.WriteLine(); myOtherObject.DoOtherStuff(); }
/// <summary>Creates user defined page.</summary> /// <param name="webDriver">The web driver. </param> /// <param name="javaScriptExecutor">The js executor. </param> /// <typeparam name="TPage">The page type. </typeparam> /// <returns>The new instance of user defined page. </returns> public static TPage Page <TPage>(IWebDriver webDriver, IJavaScriptExecutor javaScriptExecutor) where TPage : BasePage, new() { var page = proxyGenerator.CreateClassProxy <TPage>(proxyGenerationOptions, new PropertyInterceptor(), new CollectionPropertyInterceptor(), new InvalidWriteOperationInterceptor()); page.Initialize(webDriver, javaScriptExecutor); return(page); }
private object CreateLazyLoadingProxy( ProxiesOptionsExtension options, IEntityType entityType, ILazyLoader loader, object[] constructorArguments) => _generator.CreateClassProxy( entityType.ClrType, GetInterfacesToProxy(options, entityType), ProxyGenerationOptions.Default, constructorArguments, GetNotifyChangeInterceptors(options, entityType, new LazyLoadingInterceptor(entityType, loader)));
public object Create(Type t, Type asType, object glassModel) { // Return proxy with inner item if (t.GetConstructors(ConstructorFlags).FirstOrDefault(info => info.GetParameters().FirstOrDefault(pi => pi.ParameterType.IsInstanceOfType(glassModel)) != null) != null) { return(ProxyGenerator.CreateClassProxy(t, new[] { glassModel }, _interceptorFactory(asType, glassModel))); } // Return proxy with default constructor return(ProxyGenerator.CreateClassProxy(t, _interceptorFactory(asType, glassModel))); }
public Object CreateProxy(Type type, params IInterceptor[] interceptors) { if (interceptors.Length == 0) { interceptors = emptyCallbacks; } if (type.IsInterface) { return(proxyGenerator.CreateInterfaceProxyWithoutTarget(type, ProxyOptionsFactory.CreateProxyGenerationOptions(), interceptors)); } return(proxyGenerator.CreateClassProxy(type, ProxyOptionsFactory.CreateProxyGenerationOptions(), interceptors)); }
public object CreateProxyClass(Type type, params object[] paramObjects) { var args = OnAgentPreparation(type); if (paramObjects.Length == 0) { return(_proxyGenerator.CreateClassProxy(args.ToProxyType, args.AdditionalInterfacesToProxy.ToArray(), args.GenerationOptions, args.Interceptors.ToArray())); } return(_proxyGenerator.CreateClassProxy(args.ToProxyType, args.AdditionalInterfacesToProxy.ToArray(), args.GenerationOptions, paramObjects, args.Interceptors.ToArray())); }
protected virtual void MakeProxy(ProxyGenerator p) { if (typeof(T).IsClass) { Send = p.CreateClassProxy <T>(new HubConnectionProxy(this, SendType.Send)); Invoke = p.CreateClassProxy <T>(new HubConnectionProxy(this, SendType.Invoke)); } else if (typeof(T).IsInterface) { Send = p.CreateInterfaceProxyWithoutTarget <T>(new HubConnectionProxy(this, SendType.Send)); Invoke = p.CreateInterfaceProxyWithoutTarget <T>(new HubConnectionProxy(this, SendType.Invoke)); } }
static async Task Main(string[] args) { var proxyGenerator = new ProxyGenerator(); Console.WriteLine("First example: Without interceptors"); await RunFoo(new SampleClass()); Console.WriteLine("Second example: With classic interceptor"); await RunFoo(proxyGenerator.CreateClassProxy <SampleClass>(new SampleSyncTracingInterceptor())); Console.WriteLine("Third example: With async interceptor"); await RunFoo(proxyGenerator.CreateClassProxy <SampleClass>(new AsyncToSyncInterceptorAdapter(new SampleAsyncTracingInterceptor()))); }
public void CachedClassProxies() { object proxy = _generator.CreateClassProxy( typeof(ServiceClass), new StandardInterceptor( )); Assert.IsNotNull(proxy); Assert.IsTrue(typeof(ServiceClass).IsAssignableFrom(proxy.GetType())); proxy = _generator.CreateClassProxy( typeof(ServiceClass), new StandardInterceptor( )); Assert.IsNotNull(proxy); Assert.IsTrue(typeof(ServiceClass).IsAssignableFrom(proxy.GetType())); }
public void CacheHitClassProxy() { // Arrange CollectingLogger logger = new CollectingLogger(); ProxyGenerator generator = new ProxyGenerator { Logger = logger }; // Act generator.CreateClassProxy<EmptyClass>(); generator.CreateClassProxy<EmptyClass>(); // Assert Assert.True(logger.RecordedMessage(LoggerLevel.Debug, "Found cached proxy type Castle.Proxies.EmptyClassProxy " + "for target type CastleTests.DynamicProxy.Tests.Classes.EmptyClass.")); }
public void CacheHitClassProxy() { // Arrange CollectingLogger logger = new CollectingLogger(); ProxyGenerator generator = new ProxyGenerator { Logger = logger }; // Act generator.CreateClassProxy<EmptyClass>(); generator.CreateClassProxy<EmptyClass>(); // Assert Assert.That(logger.RecordedMessage(LoggerLevel.Debug, "Found cached proxy type Castle.Proxies.EmptyClassProxy " + "for target type CastleTests.DynamicProxy.Tests.Classes.EmptyClass.")); }
/// <summary> /// 지정된 객체 생성 메소드를 통해 원본 객체를 생성하고, Interceptor를 가지는 Proxy를 생성하여 반환합니다. /// </summary> /// <param name="classToProxy"></param> /// <param name="additionalInterfaces"></param> /// <param name="interceptors"></param> /// <returns></returns> public static object Create(Type classToProxy, Type[] additionalInterfaces, params IInterceptor[] interceptors) { classToProxy.ShouldNotBeNull("classToProxy"); if (IsDebugEnabled) { log.Debug("대상 수형[{0}]의 Proxy를 생성합니다. additionalInterfaces=[{1}], interceptors=[{2}]", classToProxy.FullName, additionalInterfaces.CollectionToString(), interceptors.CollectionToString()); } return(proxyGenerator.CreateClassProxy(classToProxy, additionalInterfaces, interceptors)); }
private static object BuildProxy <T>(IPublishedContent node) { var ops = new ProxyGenerationOptions(); ops.AddMixinInstance(new LazyResolverMixin(node)); var classToProxy = typeof(T); // Determine whether to use constructor that takes IPublishedContent var useContentConstructor = classToProxy.GetConstructors().Any(c => c.GetParameters().Any(p => p.ParameterType == typeof(IPublishedContent))); return(useContentConstructor ? _generator.CreateClassProxy(classToProxy, ops, new object[] { node }, _interceptor) : _generator.CreateClassProxy(classToProxy, ops, _interceptor)); }
public static T Create <T>(object[] args = null) where T : Device { var interceptor = new SetterInterceptor(); var proxy = (T)_generator.CreateClassProxy(typeof(T), args, interceptor); return(proxy); }
public override INHibernateProxy GetProxy(object id, ISessionImplementor session) { INHibernateProxy proxy; try { var behaviorInfo = _behaviorConfigurator.GetProxyInformation(PersistentClass); var initializer = new LazyInitializer(EntityName, PersistentClass, id, GetIdentifierMethod, SetIdentifierMethod, ComponentIdType, session); IInterceptor[] interceptors = behaviorInfo.Interceptors .Select(i => _kernel.Resolve(i)) .OfType <IInterceptor>() .Union(new[] { initializer }).ToArray(); Type[] interfaces = Interfaces.Union(behaviorInfo.AdditionalInterfaces).ToArray(); object obj2 = IsClassProxy ? ProxyGenerator.CreateClassProxy(PersistentClass, interfaces, interceptors) : ProxyGenerator.CreateInterfaceProxyWithoutTarget(interfaces[0], interfaces, new IInterceptor[] { initializer }); initializer._constructed = true; proxy = (INHibernateProxy)obj2; } catch (Exception exception) { log.Error("Creating a proxy instance failed", exception); throw new HibernateException("Creating a proxy instance failed", exception); } return(proxy); }
private void InjectPageObjects(List <FieldInfo> fields, IInterceptor proxy) { foreach (FieldInfo field in fields) { field.SetValue(this, ProxyGenerator.CreateClassProxy(field.FieldType, proxy)); } }
public void Async_Test() { var proxy = ProxyGenerator.CreateClassProxy <FakeAsyncClass>(); var result = proxy.Async(100); Assert.IsAssignableFrom <Task <int> >(result); }
public static ProxyGeneratorResult GenerateProxy( Type typeOfProxy, IFakeCallProcessorProvider fakeCallProcessorProvider) { Guard.AgainstNull(typeOfProxy, nameof(typeOfProxy)); var invokeMethod = typeOfProxy.GetMethod("Invoke") !; if (!IsAccessibleToDynamicProxy(typeOfProxy)) { try { // This is the only way to get the proper error message. // The need for this will go away when we start really using DynamicProxy to generate delegate proxies. ProxyGenerator.CreateClassProxy(typeOfProxy); } catch (Exception ex) { return(new ProxyGeneratorResult(ex.Message)); } } var eventRaiser = new DelegateCallInterceptedEventRaiser(fakeCallProcessorProvider, invokeMethod, typeOfProxy); fakeCallProcessorProvider.EnsureInitialized(eventRaiser.Instance); return(new ProxyGeneratorResult(eventRaiser.Instance)); }
public T Build <T>() where T : BaseModel, new() { var item = (T)_generator.CreateClassProxy(typeof(T), GetInterceptor <T>()); item.Repository = _repository; return(item); }
private static T GenerateProxy <T>(IServiceProvider serviceProvider, IInterceptor[] interceptors) { var proxyGenerator = new ProxyGenerator(); var ctrParams = ResolveTypeConstructorParameters(serviceProvider, typeof(T)); return((T)proxyGenerator.CreateClassProxy(typeof(T), ctrParams, interceptors.ToArray())); }
public static TEntity MakeTrackable <TEntity>(TEntity entity) where TEntity : class { var trackableInterceptor = new DirtyPropertiesTrackerInterceptor(); var options = new ProxyGenerationOptions(_generationHook); options.AddMixinInstance(new DirtyPropertiesTracker()); var proxy = (TEntity)_generator.CreateClassProxy <TEntity>( options, trackableInterceptor); if (entity == null) { return(proxy); } var result = EntityPatcher <TEntity> .Patch(entity, proxy); if (result.IsSuccess) { return(result.Value); } else { return(proxy); } }
public void CreateProxyOfTypeWithMixinCausingDiamondWhenMethodIsNonVirtual() { ProxyGenerator generator = new ProxyGenerator(); object proxy = generator.CreateClassProxy(typeof(FirstImpl), new Type[]{typeof(ISecond)}, new StandardInterceptor(), false); Assert.IsTrue(proxy is FirstImpl); Assert.IsTrue(proxy is IFirst); Assert.IsTrue(proxy is ISecond); }
public void ProxyAnAbstractClass() { ProxyGenerator generator = new ProxyGenerator(); LoginInterceptor interceptor = new LoginInterceptor(); AbsCls ac = (AbsCls)generator.CreateClassProxy(typeof(AbsCls),interceptor, false); ac.Method(); Assert.AreEqual("Method", interceptor.Methods[0]); }
private void TryLoggingViaProxy() { var generator = new ProxyGenerator(); var testLogger2 = generator.CreateClassProxy<TestLogger2>( ServiceLocator.Current.GetInstance<IInterceptor>("LogInterceptor")); testLogger2.GetMessage("message1"); testLogger2.GetMessageVirtual("message2"); testLogger2.GetMessageNotLogged("message3"); }
public void CreateSerializable() { MySerializableClass myClass = new MySerializableClass(); ProxyGenerator generator = new ProxyGenerator(); MySerializableClass proxy = (MySerializableClass) generator.CreateClassProxy( typeof(MySerializableClass), new StandardInvocationHandler(myClass) ); Assert.IsTrue( proxy.GetType().IsSerializable ); }
public void ParametersAreCopiedToProxiedObject() { ProxyGenerator pg = new ProxyGenerator(); ClassWithAttributesOnMethodParameters requiredObj = (ClassWithAttributesOnMethodParameters) pg.CreateClassProxy( typeof(ClassWithAttributesOnMethodParameters), new RequiredParamInterceptor()); requiredObj.MethodOne(-1); }
public void CanGetParameterAttributeFromProxiedObject() { ProxyGenerator pg = new ProxyGenerator(); ClassWithAttributesOnMethodParameters requiredObj = (ClassWithAttributesOnMethodParameters) pg.CreateClassProxy( typeof(ClassWithAttributesOnMethodParameters), new RequiredParamInterceptor()); requiredObj.MethodTwo(null); }
public void WithNullableDynamicProxyObject() { ProxyGenerator generator = new ProxyGenerator(); SimpleProxy proxy = (SimpleProxy)generator.CreateClassProxy(typeof(SimpleProxy), new StandardInterceptor()); PropertyBag["src"] = proxy; ProcessView_StripRailsExtension("home/WithNullableDynamicProxyObject.rails"); string expected = @"BarBaz foo what? there"; AssertReplyEqualTo(expected); }
public void CacheMiss() { // Arrange CollectingLogger logger = new CollectingLogger(); ProxyGenerator generator = new ProxyGenerator { Logger = logger }; // Act generator.CreateClassProxy<EmptyClass>(); // Assert Assert.That(logger.RecordedMessage(LoggerLevel.Debug, "No cached proxy type was found for target type " + "Castle.DynamicProxy.Tests.LoggingTestCase+EmptyClass.")); }
public void ProtectedConstructor() { ProxyGenerator generator = new ProxyGenerator(); NonPublicConstructorClass proxy = generator.CreateClassProxy( typeof(NonPublicConstructorClass), new StandardInterceptor() ) as NonPublicConstructorClass; Assert.IsNotNull(proxy); proxy.DoSomething(); }
public void EnsureProxyHasAttributesOnClassAndMethods() { ProxyGenerator generator = new ProxyGenerator(); AttributedClass instance = (AttributedClass) generator.CreateClassProxy(typeof(AttributedClass), new StandardInterceptor()); object[] attributes = instance.GetType().GetCustomAttributes(typeof(NonInheritableAttribute), false); Assert.AreEqual(1, attributes.Length); Assert.IsInstanceOfType(typeof(NonInheritableAttribute), attributes[0]); attributes = instance.GetType().GetMethod("Do1").GetCustomAttributes(typeof(NonInheritableAttribute), false); Assert.AreEqual(1, attributes.Length); Assert.IsInstanceOfType(typeof(NonInheritableAttribute), attributes[0]); }
public void ProtectedMethods() { ProxyGenerator generator = new ProxyGenerator(); LogInvocationInterceptor logger = new LogInvocationInterceptor(); NonPublicMethodsClass proxy = (NonPublicMethodsClass) generator.CreateClassProxy( typeof(NonPublicMethodsClass), logger ); proxy.DoSomething(); Assert.AreEqual( 2, logger.Invocations.Length ); Assert.AreEqual( "DoSomething", logger.Invocations[0] ); Assert.AreEqual( "DoOtherThing", logger.Invocations[1] ); }
public void ProxyGenerationOptionsEqualsAndGetHashCodeNotOverriden() { // Arrange CollectingLogger logger = new CollectingLogger(); ProxyGenerator generator = new ProxyGenerator { Logger = logger }; // Act ProxyGenerationOptions options = new ProxyGenerationOptions { Hook = new EmptyHook() }; generator.CreateClassProxy(typeof(EmptyClass), options); // Assert Assert.That(logger.RecordedMessage(LoggerLevel.Warn, "The IProxyGenerationHook type " + "Castle.DynamicProxy.Tests.LoggingTestCase+EmptyHook does not override both Equals and GetHashCode. " + "If these are not correctly overridden caching will fail to work causing performance problems.")); }
public void ProxyIsXmlSerializable() { ProxyGenerator gen = new ProxyGenerator(); ClassToSerialize proxy = (ClassToSerialize) gen.CreateClassProxy(typeof(ClassToSerialize), new StandardInterceptor()); XmlSerializer serializer = new XmlSerializer(proxy.GetType()); StringWriter writer = new StringWriter(); serializer.Serialize(writer, proxy); StringReader reader = new StringReader(writer.GetStringBuilder().ToString()); object newObj = serializer.Deserialize(reader); Assert.IsNotNull(newObj); Assert.IsInstanceOfType(typeof(ClassToSerialize), newObj); }
public void CanHandleDynamicProxyObjects() { ProxyGenerator generator = new ProxyGenerator(); object o = generator.CreateClassProxy(typeof(HomeController.SimpleProxy), new StandardInterceptor()); try { o.GetType().GetProperty("Text"); } catch(AmbiguousMatchException) { } PropertyBag["src"] = o; string expected = "<?xml version=\"1.0\" ?>\r\n" + @"<html> <h1>BarBaz</h1> </html>"; // should not raise ambigious match exception ProcessView_StripRailsExtension("Home/withDynamicProxyObject.rails"); AssertReplyEqualTo(expected); }
public void AttributesOnTargetClasses() { ProxyGenerator _generator = new ProxyGenerator(); AttributeCheckerInterceptor interceptor = new AttributeCheckerInterceptor(); object proxy = _generator.CreateClassProxy(typeof (MyInterfaceImpl), interceptor); IMyInterface inter = (IMyInterface) proxy; Assert.AreEqual(45, inter.Calc(20, 25)); Assert.IsTrue(interceptor.LastTargethasAttribute); Assert.IsTrue(interceptor.LastMethodHasAttribute); Assert.AreEqual(48, inter.Calc(20, 25, 1, 2)); Assert.IsTrue(interceptor.LastMethodHasAttribute); Assert.IsTrue(interceptor.LastTargethasAttribute); inter.Name = "hammett"; Assert.IsFalse(interceptor.LastMethodHasAttribute); Assert.IsTrue(interceptor.LastTargethasAttribute); }
public void EnsureProxyHasAttributesOnClassAndMethods_ComplexAttributes() { ProxyGenerator generator = new ProxyGenerator(); AttributedClass2 instance = (AttributedClass2) generator.CreateClassProxy(typeof(AttributedClass2), new StandardInterceptor()); object[] attributes = instance.GetType().GetCustomAttributes(typeof(ComplexNonInheritableAttribute), false); Assert.AreEqual(1, attributes.Length); Assert.IsInstanceOfType(typeof(ComplexNonInheritableAttribute), attributes[0]); ComplexNonInheritableAttribute att = (ComplexNonInheritableAttribute) attributes[0]; // (1, 2, true, "class", FileAccess.Write) Assert.AreEqual(1, att.Id); Assert.AreEqual(2, att.Num); Assert.AreEqual(true, att.IsSomething); Assert.AreEqual("class", att.Name); Assert.AreEqual(FileAccess.Write, att.Access); attributes = instance.GetType().GetMethod("Do1").GetCustomAttributes(typeof(ComplexNonInheritableAttribute), false); Assert.AreEqual(1, attributes.Length); Assert.IsInstanceOfType(typeof(ComplexNonInheritableAttribute), attributes[0]); att = (ComplexNonInheritableAttribute) attributes[0]; // (2, 3, "Do1", Access = FileAccess.ReadWrite) Assert.AreEqual(2, att.Id); Assert.AreEqual(3, att.Num); Assert.AreEqual(false, att.IsSomething); Assert.AreEqual("Do1", att.Name); Assert.AreEqual(FileAccess.ReadWrite, att.Access); attributes = instance.GetType().GetMethod("Do2").GetCustomAttributes(typeof(ComplexNonInheritableAttribute), false); Assert.AreEqual(1, attributes.Length); Assert.IsInstanceOfType(typeof(ComplexNonInheritableAttribute), attributes[0]); att = (ComplexNonInheritableAttribute) attributes[0]; // (3, 4, "Do2", IsSomething=true) Assert.AreEqual(3, att.Id); Assert.AreEqual(4, att.Num); Assert.AreEqual(true, att.IsSomething); Assert.AreEqual("Do2", att.Name); }
public void FoundExplicitlyImplementedInterfaceMethods() { // Arrange CollectingLogger logger = new CollectingLogger(); ProxyGenerator generator = new ProxyGenerator { Logger = logger }; // Act generator.CreateClassProxy<ClassWithInterfaceMethodExplicitlyImplemented>(); // Assert Assert.That(logger.RecordedMessage(LoggerLevel.Debug, "Excluded explicitly implemented interface method " + "Castle.DynamicProxy.Tests.LoggingTestCase.ISingleMethodInterface.InterfaceMethod on type " + "Castle.DynamicProxy.Tests.LoggingTestCase+ClassWithInterfaceMethodExplicitlyImplemented " + "because it cannot be intercepted.")); }
public void ProxyArrayListICollectionCtor() { ProxyGenerator generator = new ProxyGenerator(); ArrayList list = (ArrayList)generator.CreateClassProxy(typeof(ArrayList),new StandardInterceptor(), (ICollection)new int[]{1,2,3}); Assert.AreEqual(3,list.Count); }
public void ExcludedNonVirtualMethods() { // Arrange CollectingLogger logger = new CollectingLogger(); ProxyGenerator generator = new ProxyGenerator { Logger = logger }; // Act generator.CreateClassProxy<NonVirtualMethodClass>(); // Assert Assert.That(logger.RecordedMessage(LoggerLevel.Debug, "Excluded non-virtual method ClassMethod on " + "Castle.DynamicProxy.Tests.LoggingTestCase+NonVirtualMethodClass because it cannot be intercepted.")); Assert.That(logger.RecordedMessage(LoggerLevel.Debug, "Excluded sealed method InterfaceMethod on " + "Castle.DynamicProxy.Tests.LoggingTestCase+NonVirtualMethodClass because it cannot be intercepted.")); }
public void CanCreateClassProxy() { var proxyGenerator = new ProxyGenerator(); proxyGenerator.CreateClassProxy<ClassWithMethodsWithAllKindsOfOptionalParameters>(); }
public void ProxySynchronizationContext() { var proxyGenerator = new ProxyGenerator(); proxyGenerator.CreateClassProxy<SynchronizationContext>(); }