C# ProxyGenerationOptions.AddMixinInstance方法代码示例

		/// <summary>
		/// Returns a proxy capable of field interception.
		/// </summary>
		/// <returns></returns>
        public override object GetFieldInterceptionProxy() 
        {
            var proxyGenerationOptions = new ProxyGenerationOptions();
            var interceptor = new LazyFieldInterceptor();
            proxyGenerationOptions.AddMixinInstance(interceptor);
            return ProxyGenerator.CreateClassProxy(PersistentClass, proxyGenerationOptions, interceptor);
        }

		public void Mixin_methods_should_be_forwarded_to_target_if_implements_mixin_interface()
		{
			var options = new ProxyGenerationOptions();
			options.AddMixinInstance(new Two());
			var proxy = generator.CreateInterfaceProxyWithTargetInterface(typeof(IOne),
			                                                              new OneTwo(),
			                                                              options);
			var result = (proxy as ITwo).TwoMethod();
			Assert.AreEqual(2, result);
		}

		public void Invocation_should_be_IChangeInvocationTarget_for_Mixin_methods()
		{
			var options = new ProxyGenerationOptions();
			options.AddMixinInstance(new Two());
			var interceptor = new ChangeTargetInterceptor(new OneTwo());
			var proxy = generator.CreateInterfaceProxyWithTargetInterface(typeof(IOne),
			                                                              new One(),
			                                                              options,
			                                                              interceptor);

			var result = (proxy as ITwo).TwoMethod();

			Assert.AreEqual(2, result);
		}

		public void TwoMixinsWithSameInterface()
		{
			ProxyGenerationOptions options = new ProxyGenerationOptions();
			SimpleMixin mixin1 = new SimpleMixin();
			OtherMixinImplementingISimpleMixin mixin2 = new OtherMixinImplementingISimpleMixin();
			options.AddMixinInstance(mixin1);
			options.AddMixinInstance(mixin2);

			StandardInterceptor interceptor = new StandardInterceptor();

			Assert.Throws<InvalidMixinConfigurationException>(() =>
				generator.CreateClassProxy(typeof(SimpleClass), options, interceptor)
			);
		}

		public void TestTypeCachingWithMultipleMixins()
		{
			ProxyGenerationOptions options = new ProxyGenerationOptions();
			SimpleMixin mixin_instance1 = new SimpleMixin();
			ComplexMixin mixin_instance2 = new ComplexMixin();
			options.AddMixinInstance(mixin_instance1);
			options.AddMixinInstance(mixin_instance2);

			AssertInvocationInterceptor interceptor = new AssertInvocationInterceptor();

			object proxy1 = generator.CreateClassProxy(typeof (SimpleClass), options, interceptor);

			options = new ProxyGenerationOptions();
			mixin_instance1 = new SimpleMixin();
			mixin_instance2 = new ComplexMixin();
			options.AddMixinInstance(mixin_instance2);
			options.AddMixinInstance(mixin_instance1);

			interceptor = new AssertInvocationInterceptor();

			object proxy2 = generator.CreateClassProxy(typeof (SimpleClass), options, interceptor);

			Assert.IsTrue(proxy1.GetType().Equals(proxy2.GetType()));
		}

		public void MixinImplementingMoreThanOneInterface()
		{
			ProxyGenerationOptions proxyGenerationOptions = new ProxyGenerationOptions();

			ComplexMixin mixin_instance = new ComplexMixin();
			proxyGenerationOptions.AddMixinInstance(mixin_instance);

			AssertInvocationInterceptor interceptor = new AssertInvocationInterceptor();

			object proxy = generator.CreateClassProxy(
				typeof (SimpleClass), proxyGenerationOptions, interceptor);

			Assert.IsNotNull(proxy);
			Assert.IsTrue(typeof (SimpleClass).IsAssignableFrom(proxy.GetType()));

			Assert.IsFalse(interceptor.Invoked);

			IThird inter3 = proxy as IThird;
			Assert.IsNotNull(inter3);
			inter3.DoThird();

			Assert.IsTrue(interceptor.Invoked);
			Assert.AreSame(proxy, interceptor.proxy);
			Assert.AreSame(mixin_instance, interceptor.mixin);

			ISecond inter2 = proxy as ISecond;
			Assert.IsNotNull(inter2);
			inter2.DoSecond();

			Assert.IsTrue(interceptor.Invoked);
			Assert.AreSame(proxy, interceptor.proxy);
			Assert.AreSame(mixin_instance, interceptor.mixin);

			IFirst inter1 = proxy as IFirst;
			Assert.IsNotNull(inter1);
			inter1.DoFirst();

			Assert.IsTrue(interceptor.Invoked);
			Assert.AreSame(proxy, interceptor.proxy);
			Assert.AreSame(mixin_instance, interceptor.mixin);
		}

		public void CanCreateSimpleMixinWithoutGettingExecutionEngineExceptionsOrBadImageExceptions()
		{
			ProxyGenerationOptions proxyGenerationOptions = new ProxyGenerationOptions();
			proxyGenerationOptions.AddMixinInstance(new SimpleMixin());
			object proxy = generator.CreateClassProxy(
				typeof (object), proxyGenerationOptions, new AssertInvocationInterceptor());

			Assert.IsTrue(proxy is ISimpleMixin);

			((ISimpleMixin) proxy).DoSomething();
		}

		public void TwoMixinsWithSameInterface()
		{
			ProxyGenerationOptions options = new ProxyGenerationOptions();
			SimpleMixin mixin1 = new SimpleMixin();
			OtherMixinImplementingISimpleMixin mixin2 = new OtherMixinImplementingISimpleMixin();
			options.AddMixinInstance(mixin1);
			options.AddMixinInstance(mixin2);

			StandardInterceptor interceptor = new StandardInterceptor();
			generator.CreateClassProxy(typeof(SimpleClass), options, interceptor);
		}

		public void Null_target_can_be_replaced()
		{
			var options = new ProxyGenerationOptions();
			options.AddMixinInstance(new Two());
			var interceptor = new ChangeTargetInterceptor(new OneTwo());
			var proxy = generator.CreateInterfaceProxyWithTargetInterface(typeof(IOne),
			                                                              default(object),
			                                                              options,
			                                                              interceptor);

			Assert.AreEqual(3, ((IOne) proxy).OneMethod());
		}

		public void Uses_The_Provided_Options()
		{
			var options = new ProxyGenerationOptions();
			options.AddMixinInstance(new SimpleMixin());

			var target = new SimpleClassWithProperty();
			var proxy = generator.CreateClassProxyWithTarget(target, options);

			Assert.IsInstanceOf(typeof(ISimpleMixin), proxy);
		}

		private ProxyGenerationOptions MixIn(object mixin)
		{
			var options = new ProxyGenerationOptions();
			options.AddMixinInstance(mixin);
			return options;
		}

		public void ProxyGenerationOptionsRespectedOnDeserializationComplex ()
		{
			ProxyObjectReference.ResetScope ();

			MethodFilterHook hook = new MethodFilterHook ("get_Current");
			ProxyGenerationOptions options = new ProxyGenerationOptions (hook);
			options.AddMixinInstance (new SerializableMixin());
			options.Selector = new SerializableInterceptorSelector ();

			ComplexHolder holder = new ComplexHolder();
			holder.Type = typeof (MySerializableClass);
			holder.Element = generator.CreateClassProxy (typeof (MySerializableClass), new Type[0], options, new StandardInterceptor ());

			// check holder elements
			Assert.AreEqual (typeof (MySerializableClass), holder.Type);
			Assert.IsNotNull (holder.Element);
			Assert.IsTrue (holder.Element is MySerializableClass) ;
			Assert.AreNotEqual (typeof (MySerializableClass), holder.Element.GetType ());

			// check whether options were applied correctly
			Assert.AreEqual (holder.Element.GetType (), holder.Element.GetType ().GetMethod ("get_Current").DeclaringType);
			Assert.AreNotEqual (holder.Element.GetType (), holder.Element.GetType ().GetMethod ("CalculateSumDistanceNow").DeclaringType);
			Assert.AreEqual (holder.Element.GetType ().BaseType, holder.Element.GetType ().GetMethod ("CalculateSumDistanceNow").DeclaringType);
			ProxyGenerationOptions options2 = (ProxyGenerationOptions) holder.Element.GetType ().GetField ("proxyGenerationOptions").GetValue (null);
			Assert.IsNotNull (Array.Find (options2.MixinsAsArray (), delegate (object o) { return o is SerializableMixin; }));
			Assert.IsNotNull (options2.Selector);

			ComplexHolder otherHolder = (ComplexHolder) SerializeAndDeserialize (holder);

			// check holder elements
			Assert.AreEqual (typeof (MySerializableClass), otherHolder.Type);
			Assert.IsNotNull (otherHolder.Element);
			Assert.IsTrue (otherHolder.Element is MySerializableClass);
			Assert.AreNotEqual(typeof (MySerializableClass), otherHolder.Element.GetType());

			// check whether options were applied correctly
			Assert.AreEqual (otherHolder.Element.GetType (), otherHolder.Element.GetType ().GetMethod ("get_Current").DeclaringType);
			Assert.AreNotEqual (otherHolder.Element.GetType (), otherHolder.Element.GetType ().GetMethod ("CalculateSumDistanceNow").DeclaringType);
			Assert.AreEqual (otherHolder.Element.GetType ().BaseType, otherHolder.Element.GetType ().GetMethod ("CalculateSumDistanceNow").DeclaringType);
			options2 = (ProxyGenerationOptions) otherHolder.Element.GetType ().GetField ("proxyGenerationOptions").GetValue (null);
			Assert.IsNotNull (Array.Find (options2.MixinsAsArray (), delegate (object o) { return o is SerializableMixin; }));
			Assert.IsNotNull (options2.Selector);
		}

		public void MixinsAppliedOnDeserialization ()
		{
			ProxyObjectReference.ResetScope ();

			ProxyGenerationOptions options = new ProxyGenerationOptions ();
			options.AddMixinInstance (new SerializableMixin ());

			MySerializableClass proxy = (MySerializableClass) generator.CreateClassProxy (
					typeof (MySerializableClass),
					new Type[0],
					options,
					new StandardInterceptor ());

			Assert.IsTrue (proxy is IMixedInterface);

			MySerializableClass otherProxy = (MySerializableClass) SerializeAndDeserialize (proxy);
			Assert.IsTrue (otherProxy is IMixedInterface);
		}

		public void ProxyGenerationOptionsRespectedOnDeserialization ()
		{
			ProxyObjectReference.ResetScope();

			MethodFilterHook hook = new MethodFilterHook ("get_Current");
			ProxyGenerationOptions options = new ProxyGenerationOptions (hook);
			options.AddMixinInstance (new SerializableMixin());
			options.Selector = new SerializableInterceptorSelector ();

			MySerializableClass proxy = (MySerializableClass) generator.CreateClassProxy (
			    typeof (MySerializableClass),
			    new Type[0],
			    options,
			    new StandardInterceptor());

			Assert.AreEqual (proxy.GetType(), proxy.GetType().GetMethod ("get_Current").DeclaringType);
			Assert.AreNotEqual (proxy.GetType(), proxy.GetType().GetMethod ("CalculateSumDistanceNow").DeclaringType);
			Assert.AreEqual (proxy.GetType().BaseType, proxy.GetType().GetMethod ("CalculateSumDistanceNow").DeclaringType);
			ProxyGenerationOptions options2 = (ProxyGenerationOptions) proxy.GetType().GetField("proxyGenerationOptions").GetValue(null);
			Assert.IsNotNull (Array.Find (options2.MixinsAsArray (), delegate (object o) { return o is SerializableMixin; }));
			Assert.IsNotNull (options2.Selector);

			MySerializableClass otherProxy = (MySerializableClass) SerializeAndDeserialize (proxy);
			Assert.AreEqual (otherProxy.GetType(), otherProxy.GetType().GetMethod ("get_Current").DeclaringType);
			Assert.AreNotEqual (otherProxy.GetType(), otherProxy.GetType().GetMethod ("CalculateSumDistanceNow").DeclaringType);
			Assert.AreEqual (otherProxy.GetType().BaseType, otherProxy.GetType().GetMethod ("CalculateSumDistanceNow").DeclaringType);
			options2 = (ProxyGenerationOptions) otherProxy.GetType ().GetField ("proxyGenerationOptions").GetValue (null);
			Assert.IsNotNull (Array.Find (options2.MixinsAsArray (), delegate (object o) { return o is SerializableMixin; }));
			Assert.IsNotNull (options2.Selector);
		}

		public void ProxyKnowsItsGenerationOptions ()
		{
			MethodFilterHook hook = new MethodFilterHook (".*");
			ProxyGenerationOptions options = new ProxyGenerationOptions (hook);
			options.AddMixinInstance (new SerializableMixin ());

			object proxy = generator.CreateClassProxy (
					typeof (MySerializableClass),
					new Type[0],
					options,
					new StandardInterceptor ());

			FieldInfo field = proxy.GetType ().GetField ("proxyGenerationOptions");
			Assert.IsNotNull (field);
			Assert.AreSame (options, field.GetValue (proxy));

			base.Init ();

			proxy = generator.CreateInterfaceProxyWithoutTarget (typeof (IService), new StandardInterceptor ());
			field = proxy.GetType ().GetField ("proxyGenerationOptions");
			Assert.AreSame (ProxyGenerationOptions.Default, field.GetValue (proxy));

			base.Init ();

			proxy = generator.CreateInterfaceProxyWithTarget (typeof (IService), new ServiceImpl(), options, new StandardInterceptor ());
			field = proxy.GetType ().GetField ("proxyGenerationOptions");
			Assert.AreSame (options, field.GetValue (proxy));

			base.Init ();

			proxy = generator.CreateInterfaceProxyWithTargetInterface (typeof (IService), new ServiceImpl(), new StandardInterceptor ());
			field = proxy.GetType ().GetField ("proxyGenerationOptions");
			Assert.AreSame (ProxyGenerationOptions.Default, field.GetValue (proxy));
		}