internal static T GetInterceptingInstance <T>(params object[] ctorValues)
{
Type typeToIntercept = typeof(T);
if (typeToIntercept.IsGenericType)
{
typeToIntercept = typeToIntercept.GetGenericTypeDefinition();
}
global::Unity.Interception.Interceptors.TypeInterceptors.VirtualMethodInterception.InterceptingClassGeneration.InterceptingClassGenerator generator = new global::Unity.Interception.Interceptors.TypeInterceptors.VirtualMethodInterception.InterceptingClassGeneration.InterceptingClassGenerator(typeToIntercept);
Type generatedType = generator.GenerateType();
if (generatedType.IsGenericTypeDefinition)
{
generatedType = generatedType.MakeGenericType(typeof(T).GetGenericArguments());
}
return((T)Activator.CreateInstance(generatedType, ctorValues));
}
public void CanInterceptClassWithReservedTypeAttributes()
{
global::Unity.Interception.Interceptors.TypeInterceptors.VirtualMethodInterception.InterceptingClassGeneration.InterceptingClassGenerator generator =
new global::Unity.Interception.Interceptors.TypeInterceptors.VirtualMethodInterception.InterceptingClassGeneration.InterceptingClassGenerator(typeof(ClassWithPermissionAttribute));
Type generatedType = generator.GenerateType();
ClassWithPermissionAttribute instance = (ClassWithPermissionAttribute)Activator.CreateInstance(generatedType);
int intercepts = 0;
((IInterceptingProxy)instance)
.AddInterceptionBehavior(
new DelegateInterceptionBehavior((mi, gn) => { intercepts++; return(gn()(mi, gn)); }));
instance.Method();
Assert.AreEqual(1, intercepts);
}
public void InterceptingClassOverridesBaseClassVirtualMethods()
{
Type baseType = typeof(ClassWithDefaultCtor);
VirtualMethodInterceptor interceptor = new VirtualMethodInterceptor();
global::Unity.Interception.Interceptors.TypeInterceptors.VirtualMethodInterception.InterceptingClassGeneration.InterceptingClassGenerator generator = new global::Unity.Interception.Interceptors.TypeInterceptors.VirtualMethodInterception.InterceptingClassGeneration.InterceptingClassGenerator(baseType);
Type generatedType = generator.GenerateType();
MethodInfo methodOne = generatedType.GetMethod("MethodOne");
MethodInfo calculateAnswer = generatedType.GetMethod("CalculateAnswer");
Assert.AreSame(generatedType, methodOne.DeclaringType);
Assert.AreSame(generatedType, calculateAnswer.DeclaringType);
}
public void DoesNotReImplementAdditionalInterfaceAlreadyImplementedByInterceptedClass()
{
global::Unity.Interception.Interceptors.TypeInterceptors.VirtualMethodInterception.InterceptingClassGeneration.InterceptingClassGenerator generator =
new global::Unity.Interception.Interceptors.TypeInterceptors.VirtualMethodInterception.InterceptingClassGeneration.InterceptingClassGenerator(typeof(InterfaceImplementingMainType), typeof(IDeriveFromIDoSomething));
Type generatedType = generator.GenerateType();
object instance = Activator.CreateInstance(generatedType);
List <MethodBase> interceptedMethods = new List <MethodBase>();
((IInterceptingProxy)instance)
.AddInterceptionBehavior(
new DelegateInterceptionBehavior((mi, n) =>
{
interceptedMethods.Add(mi.MethodBase);
return(mi.CreateMethodReturn(1));
}));
((InterfaceImplementingMainType)instance).DoSomething();
((InterfaceImplementingMainType)instance).DoSomething(String.Empty);
((IDoSomething)instance).DoSomething();
((IDoSomething)instance).DoSomething(String.Empty);
((IDeriveFromIDoSomething)instance).DoSomething();
((IDeriveFromIDoSomething)instance).DoSomething(String.Empty);
((IDeriveFromIDoSomething)instance).DoSomethingElse();
Assert.AreEqual(4, interceptedMethods.Count);
// only the virtual implicit method implementation is invoked for IDoSomething
Assert.AreSame(
StaticReflection.GetMethodInfo <InterfaceImplementingMainType>(i => i.DoSomething(null)),
interceptedMethods[0]);
Assert.AreSame(
StaticReflection.GetMethodInfo <InterfaceImplementingMainType>(i => i.DoSomething(null)),
interceptedMethods[1]);
Assert.AreSame(
StaticReflection.GetMethodInfo <InterfaceImplementingMainType>(i => i.DoSomething(null)),
interceptedMethods[2]);
Assert.AreSame(
StaticReflection.GetMethodInfo <IDeriveFromIDoSomething>(i => i.DoSomethingElse()),
interceptedMethods[3]);
}
public void CanInterceptMixedPublicProtectedVirtualProperties()
{
global::Unity.Interception.Interceptors.TypeInterceptors.VirtualMethodInterception.InterceptingClassGeneration.InterceptingClassGenerator generator =
new global::Unity.Interception.Interceptors.TypeInterceptors.VirtualMethodInterception.InterceptingClassGeneration.InterceptingClassGenerator(typeof(ClassWithMixedPublicProtectedProperty));
Type generatedType = generator.GenerateType();
ClassWithMixedPublicProtectedProperty instance =
(ClassWithMixedPublicProtectedProperty)Activator.CreateInstance(generatedType);
int intercepts = 0;
((IInterceptingProxy)instance)
.AddInterceptionBehavior(
new DelegateInterceptionBehavior((mi, gn) =>
{
intercepts++;
return(gn()(mi, gn));
}));
instance.SetProperty(10);
int value = instance.GetProperty();
Assert.AreEqual(10, value);
Assert.AreEqual(2, intercepts);
}
public void CanImplementAdditionalInterfaceWithMethodsHavingSignaturesMatchingMethodsInTheBaseClass()
{
// arrange
global::Unity.Interception.Interceptors.TypeInterceptors.VirtualMethodInterception.InterceptingClassGeneration.InterceptingClassGenerator generator =
new global::Unity.Interception.Interceptors.TypeInterceptors.VirtualMethodInterception.InterceptingClassGeneration.InterceptingClassGenerator(typeof(MainType), typeof(IDoSomething));
Type generatedType = generator.GenerateType();
// act
object instance = Activator.CreateInstance(generatedType);
// assert
Assert.IsTrue(instance is MainType);
Assert.IsTrue(instance is IDoSomething);
}
public void CanInvokeMethodsFromDifferentTypesWithMatchingSignatures()
{
global::Unity.Interception.Interceptors.TypeInterceptors.VirtualMethodInterception.InterceptingClassGeneration.InterceptingClassGenerator generator =
new global::Unity.Interception.Interceptors.TypeInterceptors.VirtualMethodInterception.InterceptingClassGeneration.InterceptingClassGenerator(typeof(MainType), typeof(IDoSomething), typeof(IDoSomethingToo));
Type generatedType = generator.GenerateType();
object instance = Activator.CreateInstance(generatedType);
List <MethodBase> invokedMethods = new List <MethodBase>();
((IInterceptingProxy)instance)
.AddInterceptionBehavior(
new DelegateInterceptionBehavior((mi, n) =>
{
invokedMethods.Add(mi.MethodBase);
return(mi.CreateMethodReturn(1));
}));
((MainType)instance).DoSomething();
((IDoSomething)instance).DoSomething();
((IDoSomethingToo)instance).DoSomething();
Assert.AreSame(StaticReflection.GetMethodInfo <MainType>(i => i.DoSomething()), invokedMethods[0]);
Assert.AreSame(StaticReflection.GetMethodInfo <IDoSomething>(i => i.DoSomething()), invokedMethods[1]);
Assert.AreSame(StaticReflection.GetMethodInfo <IDoSomethingToo>(i => i.DoSomething()), invokedMethods[2]);
}
public void CanImplementINotifyPropertyChanged()
{
global::Unity.Interception.Interceptors.TypeInterceptors.VirtualMethodInterception.InterceptingClassGeneration.InterceptingClassGenerator generator = new global::Unity.Interception.Interceptors.TypeInterceptors.VirtualMethodInterception.InterceptingClassGeneration.InterceptingClassGenerator(typeof(MainType), typeof(INotifyPropertyChanged));
Type generatedType = generator.GenerateType();
object instance = Activator.CreateInstance(generatedType);
string changeProperty = null;
PropertyChangedEventHandler handler = (sender, args) => changeProperty = args.PropertyName;
((IInterceptingProxy)instance).AddInterceptionBehavior(new NaiveINotifyPropertyChangedInterceptionBehavior());
((INotifyPropertyChanged)instance).PropertyChanged += handler;
((MainType)instance).IntProperty = 100;
Assert.AreEqual(100, ((MainType)instance).IntProperty);
Assert.AreEqual("IntProperty", changeProperty);
changeProperty = null;
((INotifyPropertyChanged)instance).PropertyChanged -= handler;
((MainType)instance).IntProperty = 200;
Assert.AreEqual(200, ((MainType)instance).IntProperty);
Assert.AreEqual(null, changeProperty);
}
public void CanSuccessfullyInvokeAnAdditionalInterfaceMethodIfAnInterceptorDoesNotForwardTheCall()
{
// arrange
global::Unity.Interception.Interceptors.TypeInterceptors.VirtualMethodInterception.InterceptingClassGeneration.InterceptingClassGenerator generator = new global::Unity.Interception.Interceptors.TypeInterceptors.VirtualMethodInterception.InterceptingClassGeneration.InterceptingClassGenerator(typeof(MainType), typeof(IAdditionalInterface));
Type generatedType = generator.GenerateType();
object instance = Activator.CreateInstance(generatedType);
bool invoked = false;
((IInterceptingProxy)instance).AddInterceptionBehavior(
new DelegateInterceptionBehavior(
(input, getNext) => { invoked = true; return(input.CreateMethodReturn(100)); }));
// act
int result = ((IAdditionalInterface)instance).DoSomethingElse();
// assert
Assert.IsTrue(invoked);
Assert.AreEqual(100, result);
}
public void InvokingMethodOnAdditionalInterfaceThrowsIfNotHandledByInterceptor()
{
// arrange
global::Unity.Interception.Interceptors.TypeInterceptors.VirtualMethodInterception.InterceptingClassGeneration.InterceptingClassGenerator generator = new global::Unity.Interception.Interceptors.TypeInterceptors.VirtualMethodInterception.InterceptingClassGeneration.InterceptingClassGenerator(typeof(MainType), typeof(IAdditionalInterface));
Type generatedType = generator.GenerateType();
object instance = Activator.CreateInstance(generatedType);
// act
Exception exception = null;
try
{
((IAdditionalInterface)instance).DoSomethingElse();
Assert.Fail("should have thrown");
}
catch (NotImplementedException e)
{
exception = e;
}
// assert
Assert.IsNotNull(exception);
}
public void CanImplementAdditionalInterfaces()
{
// arrange
global::Unity.Interception.Interceptors.TypeInterceptors.VirtualMethodInterception.InterceptingClassGeneration.InterceptingClassGenerator generator =
new global::Unity.Interception.Interceptors.TypeInterceptors.VirtualMethodInterception.InterceptingClassGeneration.InterceptingClassGenerator(typeof(MainType), typeof(IAdditionalInterface));
Type generatedType = generator.GenerateType();
// act
object instance = Activator.CreateInstance(generatedType);
// assert
Assert.IsTrue(instance is MainType);
Assert.IsTrue(instance is IAdditionalInterface);
}
public void GeneratedTypeForAdditionalInterfaceWithMethodsHavingSignaturesMatchingMethodsInTheBaseClassIsVerifiable()
{
PermissionSet grantSet = new PermissionSet(PermissionState.None);
grantSet.AddPermission(
new SecurityPermission(
SecurityPermissionFlag.Execution
| SecurityPermissionFlag.ControlEvidence
| SecurityPermissionFlag.ControlPolicy));
grantSet.AddPermission(
new ReflectionPermission(ReflectionPermissionFlag.RestrictedMemberAccess
| ReflectionPermissionFlag.MemberAccess));
grantSet.AddPermission(new FileIOPermission(PermissionState.Unrestricted));
AppDomain sandbox =
AppDomain.CreateDomain(
"sandbox",
AppDomain.CurrentDomain.Evidence,
new AppDomainSetup {
ApplicationBase = AppDomain.CurrentDomain.BaseDirectory
},
grantSet);
sandbox.DoCallBack(() =>
{
global::Unity.Interception.Interceptors.TypeInterceptors.VirtualMethodInterception.InterceptingClassGeneration.InterceptingClassGenerator generator =
new global::Unity.Interception.Interceptors.TypeInterceptors.VirtualMethodInterception.InterceptingClassGeneration.InterceptingClassGenerator(typeof(MainType), typeof(IDoSomething), typeof(IDoSomethingToo));
Type generatedType = generator.GenerateType();
});
}
