C# Interceptors.KeepDataInterceptor类代码示例

		public void InterfaceProxyWithTarget_MethodInvocationTarget_should_be_null()
		{
			var interceptor = new KeepDataInterceptor();
			var proxy = generator.CreateInterfaceProxyWithoutTarget<IService>(interceptor);
			proxy.Sum(2, 2);
			Assert.IsNull(interceptor.Invocation.MethodInvocationTarget);
		}

		public void InvocationForInterfaceProxyWithTarget()
		{
			KeepDataInterceptor interceptor = new KeepDataInterceptor();

			object proxy = generator.CreateInterfaceProxyWithTarget(
				typeof (IService), new ServiceImpl(), interceptor);

			IService instance = (IService) proxy;

			instance.Sum(20, 25);

			Assert.IsNotNull(interceptor.Invocation);

			Assert.IsNotNull(interceptor.Invocation.Arguments);
			Assert.AreEqual(2, interceptor.Invocation.Arguments.Length);
			Assert.AreEqual(20, interceptor.Invocation.Arguments[0]);
			Assert.AreEqual(25, interceptor.Invocation.Arguments[1]);
			Assert.AreEqual(20, interceptor.Invocation.GetArgumentValue(0));
			Assert.AreEqual(25, interceptor.Invocation.GetArgumentValue(1));
			Assert.AreEqual(45, interceptor.Invocation.ReturnValue);

			Assert.IsNotNull(interceptor.Invocation.Proxy);
			Assert.IsNotInstanceOf(typeof(ServiceImpl), interceptor.Invocation.Proxy);

			Assert.IsNotNull(interceptor.Invocation.InvocationTarget);
			Assert.IsInstanceOf(typeof(ServiceImpl), interceptor.Invocation.InvocationTarget);
			Assert.IsNotNull(interceptor.Invocation.TargetType);
			Assert.AreSame(typeof(ServiceImpl), interceptor.Invocation.TargetType);

			Assert.IsNotNull(interceptor.Invocation.Method);
			Assert.IsNotNull(interceptor.Invocation.MethodInvocationTarget);
			Assert.AreNotSame(interceptor.Invocation.Method, interceptor.Invocation.MethodInvocationTarget);
		}

		public void InvocationForConcreteClassProxy()
		{
			KeepDataInterceptor interceptor = new KeepDataInterceptor();

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

			ServiceClass instance = (ServiceClass) proxy;

			instance.Sum(20, 25);

			Assert.IsNotNull(interceptor.Invocation);

			Assert.IsNotNull(interceptor.Invocation.Arguments);
			Assert.AreEqual(2, interceptor.Invocation.Arguments.Length);
			Assert.AreEqual(20, interceptor.Invocation.Arguments[0]);
			Assert.AreEqual(25, interceptor.Invocation.Arguments[1]);
			Assert.AreEqual(20, interceptor.Invocation.GetArgumentValue(0));
			Assert.AreEqual(25, interceptor.Invocation.GetArgumentValue(1));
			Assert.AreEqual(45, interceptor.Invocation.ReturnValue);

			Assert.IsNotNull(interceptor.Invocation.Proxy);
			Assert.IsInstanceOf(typeof (ServiceClass), interceptor.Invocation.Proxy);

			Assert.IsNotNull(interceptor.Invocation.InvocationTarget);
			Assert.IsInstanceOf(typeof (ServiceClass), interceptor.Invocation.InvocationTarget);
			Assert.IsNotNull(interceptor.Invocation.TargetType);
			Assert.AreSame(typeof (ServiceClass), interceptor.Invocation.TargetType);

			Assert.IsNotNull(interceptor.Invocation.Method);
			Assert.IsNotNull(interceptor.Invocation.MethodInvocationTarget);
			Assert.AreSame(interceptor.Invocation.Method, interceptor.Invocation.MethodInvocationTarget.GetBaseDefinition());
		}

		public void ClassProxy_MethodInvocationTarget_should_be_base_Method_for_interface_methods_implemented_virtually()
		{
			var interceptor = new KeepDataInterceptor();
			var proxy = generator.CreateClassProxy(typeof(ClassWithVirtualInterface), new[] { typeof(ISimpleInterface) }, interceptor) as ISimpleInterface;
			proxy.Do();
			var methodOnClass = typeof(ClassWithVirtualInterface).GetMethod("Do", Type.EmptyTypes);
			Assert.AreSame(methodOnClass, interceptor.Invocation.MethodInvocationTarget);
		}

		public void ClassProxy_MethodInvocationTarget_should_be_base_Method_for_interface_methods_implemented_non_virtually()
		{
			var interceptor = new KeepDataInterceptor();
			var proxy = generator.CreateClassProxy(typeof(One), new[] { typeof(IOne) }, interceptor) as IOne;
			proxy.OneMethod();
			var methodOnInterface = typeof(One).GetMethod("OneMethod", Type.EmptyTypes);
			Assert.AreSame(methodOnInterface, interceptor.Invocation.MethodInvocationTarget);
		}

		public void ClassProxy_MethodInvocationTarget_should_be_base_Method()
		{
			var interceptor = new KeepDataInterceptor();
			var proxy = generator.CreateClassProxy<ServiceClass>(interceptor);
			proxy.Sum(2, 2);
			var methodOnClass = typeof(ServiceClass).GetMethod("Sum", new[] { typeof(int), typeof(int) });
			Assert.AreSame(methodOnClass, interceptor.Invocation.MethodInvocationTarget);
		}

		public void InterfaceProxyWithTargetInterface_MethodInvocationTarget_should_be_methodOnTargetType()
		{
			var interceptor = new KeepDataInterceptor();
			var target = new ServiceImpl();
			var proxy = generator.CreateInterfaceProxyWithTargetInterface(typeof(IService), target, interceptor) as IService;
			proxy.Sum(2, 2);
			MethodInfo methodOnTarget = target.GetType().GetMethod("Sum", new[] { typeof(int), typeof(int) });
			Assert.AreSame(methodOnTarget, interceptor.Invocation.MethodInvocationTarget);
		}

		public void Should_share_invocations_for_interface_methods()
		{
			var interceptor1 = new KeepDataInterceptor();
			var interceptor2 = new KeepDataInterceptor();
			var first = generator.CreateInterfaceProxyWithTarget<IOne>(new One(), interceptor1);
			var second = generator.CreateInterfaceProxyWithTarget<IOne>(new OneTwo(), interceptor2);

			Assert.AreNotEqual(first.GetType(), second.GetType(), "proxy types are different");

			first.OneMethod();
			second.OneMethod();

			Assert.AreEqual(interceptor1.Invocation.GetType(), interceptor2.Invocation.GetType());
		}

		public void GenericMethod_WithConstraintOnSurroundingTypeParameter ()
		{
			Type type = typeof (IGenericInterfaceWithGenericMethodWithDependentConstraint<object>);

			KeepDataInterceptor interceptor = new KeepDataInterceptor ();
			IGenericInterfaceWithGenericMethodWithDependentConstraint<object> proxy = (IGenericInterfaceWithGenericMethodWithDependentConstraint<object>)
					generator.CreateInterfaceProxyWithoutTarget(type, new Type[] { }, interceptor);

			proxy.RegisterType<string> ();

			MethodInfo expectedMethod =
					typeof (IGenericInterfaceWithGenericMethodWithDependentConstraint<object>).GetMethod ("RegisterType").MakeGenericMethod (typeof (string));

			Assert.AreEqual (expectedMethod, interceptor.Invocation.Method);
		}

		public void Should_not_share_invocations_for_interface_methods_when_one_is_IChangeProxyTarget()
		{
			var interceptor1 = new KeepDataInterceptor();
			var interceptor2 = new KeepDataInterceptor();
			var first = generator.CreateInterfaceProxyWithTarget<IOne>(new One(), interceptor1);
			var second = generator.CreateInterfaceProxyWithTargetInterface<IOne>(new OneTwo(), interceptor2);

			Assert.AreNotEqual(first.GetType(), second.GetType(), "proxy types are different");

			first.OneMethod();
			second.OneMethod();

			Assert.IsNotInstanceOf<IChangeProxyTarget>(interceptor1.Invocation);
			Assert.IsInstanceOf<IChangeProxyTarget>(interceptor2.Invocation);
			Assert.AreNotEqual(interceptor1.Invocation.GetType(), interceptor2.Invocation.GetType());
		}

		public void GenericMethod_WithConstraintOnOtherParameter()
		{
			var type = typeof(IInterfaceWithGenericMethodWithDependentConstraint);

			var interceptor = new KeepDataInterceptor();
			var proxy = (IInterfaceWithGenericMethodWithDependentConstraint)
			            generator.CreateInterfaceProxyWithoutTarget(type, new Type[] { }, interceptor);

			proxy.RegisterType<object, string>();

			var expectedMethod =
				typeof(IInterfaceWithGenericMethodWithDependentConstraint).GetMethod("RegisterType").MakeGenericMethod(
					typeof(object), typeof(string));

			Assert.AreEqual(expectedMethod, interceptor.Invocation.Method);
		}

		public void MethodInfoClosedInGenTypeNongenMethodValueTypeRefType()
		{
			KeepDataInterceptor interceptor = new KeepDataInterceptor();
			GenClassWithGenReturn<int, List<object>> proxy =
				generator.CreateClassProxy<GenClassWithGenReturn<int, List<object>>>(interceptor);

			proxy.DoSomethingT();
			GenericTestUtility.CheckMethodInfoIsClosed(interceptor.Invocation.GetConcreteMethod(), typeof (int));
			Assert.AreEqual(interceptor.Invocation.GetConcreteMethod(),
			                interceptor.Invocation.GetConcreteMethodInvocationTarget().GetBaseDefinition());

			proxy.DoSomethingZ();
			GenericTestUtility.CheckMethodInfoIsClosed(interceptor.Invocation.GetConcreteMethod(), typeof (List<object>));
			Assert.AreEqual(interceptor.Invocation.GetConcreteMethod(),
							interceptor.Invocation.GetConcreteMethodInvocationTarget().GetBaseDefinition());
		}

		public void ThrowsWhenProxyingGenericTypeDefNoTarget()
		{
			var interceptor = new KeepDataInterceptor();

			Assert.Throws<GeneratorException>(() =>
				generator.CreateInterfaceProxyWithoutTarget(typeof(IGenInterfaceHierarchyBase<>), interceptor)
			);
		}

		public void ThrowsWhenProxyingGenericTypeDefNoTarget()
		{
			KeepDataInterceptor interceptor = new KeepDataInterceptor();

			Assert.Throws<GeneratorException>(delegate {
				generator.CreateClassProxy(typeof(GenClassWithGenReturn<,>), interceptor);
			});
		}

		public void MethodInfoClosedInGenTypeGenMethodValueType()
		{
			KeepDataInterceptor interceptor = new KeepDataInterceptor();
			GenClassWithGenMethods<int> proxy = generator.CreateClassProxy<GenClassWithGenMethods<int>>(interceptor);

			proxy.DoSomething(1);
			GenericTestUtility.CheckMethodInfoIsClosed(interceptor.Invocation.GetConcreteMethod(), typeof (int), typeof (int));
			Assert.AreEqual(interceptor.Invocation.GetConcreteMethod(),
			                interceptor.Invocation.GetConcreteMethodInvocationTarget());

			proxy.DoSomething(new List<object>());
			GenericTestUtility.CheckMethodInfoIsClosed(interceptor.Invocation.GetConcreteMethod(), typeof (int),
			                                           typeof (List<object>));
			Assert.AreEqual(interceptor.Invocation.GetConcreteMethod(),
			                interceptor.Invocation.GetConcreteMethodInvocationTarget());
		}