public DynamicMixinTypeGenerator(ModuleScope scope, Type targetType, IEnumerable <MethodInfo> methodsToOverride, MethodInvocationHandler invocationHandler)
{
ArgumentUtility.CheckNotNull("scope", scope);
ArgumentUtility.CheckNotNull("targetType", targetType);
ArgumentUtility.CheckNotNull("methodsToOverride", methodsToOverride);
ArgumentUtility.CheckNotNull("invocationHandler", invocationHandler);
if (targetType.ContainsGenericParameters)
{
throw new NotSupportedException("Open generic target types are not supported by this type generator.");
}
_methodsToOverride = methodsToOverride;
_invocationHandler = invocationHandler;
string className = "DynamicMixinFor_" + targetType.Name;
_baseCallInterface = BaseRequirements.BuildBaseRequirements(_methodsToOverride, className + "_BaseRequirements", scope);
Type mixinBase = typeof(Mixin <,>).MakeGenericType(typeof(object), _baseCallInterface.RequirementsType);
_emitter = new CustomClassEmitter(scope, className, mixinBase);
_invocationHandlerField = _emitter.CreateStaticField("InvocationHandler", typeof(MethodInvocationHandler));
foreach (MethodInfo method in _methodsToOverride)
{
AddOverrider(method, _invocationHandlerField);
}
}
public void ForceUnsignedFalse()
{
var classEmitter = new CustomClassEmitter(Scope, "ForceUnsignedFalse", typeof(object), Type.EmptyTypes, TypeAttributes.Public, false);
Type t = classEmitter.BuildType();
Assert.That(StrongNameUtil.IsAssemblySigned(t.Assembly), Is.True);
}
public void CreateMethod_CopyParametersAndReturnTypeOutRef()
{
var classEmitter = new CustomClassEmitter(Scope, "CreateMethod_CopyParametersAndReturnTypeOutRef", typeof(object));
var method = classEmitter.CreateMethod(
"MethodWithOutRef",
MethodAttributes.Public,
typeof(ClassWithAllKindsOfMembers).GetMethod("MethodWithOutRef"));
method.AddStatement(new AssignStatement(new IndirectReference(method.ArgumentReferences[0]), NullExpression.Instance));
method.ImplementByReturningDefault();
object instance = Activator.CreateInstance(classEmitter.BuildType());
MethodInfo builtMethod = instance.GetType().GetMethod("MethodWithOutRef");
Assert.That(builtMethod.ReturnType, Is.EqualTo(typeof(void)));
ParameterInfo[] parameters = builtMethod.GetParameters();
Assert.That(parameters.Length, Is.EqualTo(2));
Assert.That(parameters[0].ParameterType, Is.EqualTo(typeof(string).MakeByRefType()));
Assert.That(parameters[0].ParameterType.IsByRef, Is.True);
Assert.That(parameters[0].IsOut, Is.True);
Assert.That(parameters[0].IsIn, Is.False);
Assert.That(parameters[1].ParameterType, Is.EqualTo(typeof(int).MakeByRefType()));
Assert.That(parameters[1].ParameterType.IsByRef, Is.True);
Assert.That(parameters[1].IsOut, Is.False);
Assert.That(parameters[1].IsIn, Is.False);
var arguments = new object[] { "foo", 5 };
builtMethod.Invoke(instance, arguments);
Assert.That(arguments[0], Is.EqualTo(null));
Assert.That(arguments[1], Is.EqualTo(5));
}
public void OverrideGenericMethod_WithConstraint_ModifiedByClosedGenericClass()
{
Type baseType = typeof(GenericClassWithGenericMethod <IConvertible, List <string>, int, object, IConvertible, List <List <IConvertible[]> > >);
var classEmitter = new CustomClassEmitter(
Scope,
"OverrideGenericMethod_WithConstraint_ModifiedByClosedGenericClass",
baseType,
Type.EmptyTypes,
TypeAttributes.Public | TypeAttributes.Class, false);
MethodInfo baseMethod = baseType.GetMethod("GenericMethod");
var methodEmitter = classEmitter.CreateMethodOverride(baseMethod);
methodEmitter.ImplementByBaseCall(baseMethod);
Type builtType = classEmitter.BuildType();
var instance =
(GenericClassWithGenericMethod <IConvertible, List <string>, int, object, IConvertible, List <List <IConvertible[]> > >)
Activator.CreateInstance(builtType);
string result = instance.GenericMethod(1, new List <int[]> (), new List <List <IConvertible[]> > ());
Assert.That(result, Is.EqualTo("1, System.Collections.Generic.List`1[System.Int32[]], System.Collections.Generic.List`1[System.Collections.Generic.List`1["
+ "System.IConvertible[]]]"));
}
public void CreateDefaultConstructor()
{
var classEmitter = new CustomClassEmitter(Scope, "CreateDefaultConstructor", typeof(object));
classEmitter.CreateDefaultConstructor();
Activator.CreateInstance(classEmitter.BuildType());
}
public void OverridingSimpleMembersOfOpenGenericClass()
{
CustomClassEmitter classEmitter = new CustomClassEmitter(Scope, "OverridingSimpleMembersOfOpenGenericClass", typeof(GenericClassWithAllKindsOfMembers <>), Type.EmptyTypes,
TypeAttributes.Public | TypeAttributes.Class, false);
MethodInfo baseMethod = typeof(GenericClassWithAllKindsOfMembers <>).GetMethod("Method");
var overriddenMethod = classEmitter.CreateMethodOverride(baseMethod);
overriddenMethod.ImplementByBaseCall(baseMethod);
PropertyInfo baseProperty = typeof(GenericClassWithAllKindsOfMembers <>).GetProperty("Property");
CustomPropertyEmitter overriddenProperty = classEmitter.CreatePropertyOverride(baseProperty);
overriddenProperty.GetMethod = classEmitter.CreateMethodOverride(baseProperty.GetGetMethod());
overriddenProperty.GetMethod.ImplementByBaseCall(baseProperty.GetGetMethod());
EventInfo baseEvent = typeof(GenericClassWithAllKindsOfMembers <>).GetEvent("Event");
CustomEventEmitter overriddenEvent = classEmitter.CreateEventOverride(baseEvent);
overriddenEvent.AddMethod = classEmitter.CreateMethodOverride(baseEvent.GetAddMethod());
overriddenEvent.AddMethod.ImplementByBaseCall(baseEvent.GetAddMethod());
overriddenEvent.RemoveMethod = classEmitter.CreateMethodOverride(baseEvent.GetRemoveMethod());
overriddenEvent.RemoveMethod.ImplementByBaseCall(baseEvent.GetRemoveMethod());
Type builtType = classEmitter.BuildType();
GenericClassWithAllKindsOfMembers <int> instance =
(GenericClassWithAllKindsOfMembers <int>)Activator.CreateInstance(builtType.MakeGenericType(typeof(int)));
instance.Method(5);
Assert.That(instance.Property, Is.EqualTo(0));
instance.Event += delegate { return(0); };
instance.Event -= delegate { return(0); };
}
public void CreateFullNamedMethodOverride_ProtectedMethod()
{
var classEmitter = new CustomClassEmitter(Scope, "CreateFullNamedMethodOverride_ProtectedMethod", typeof(ClassWithProtectedVirtualMethod), new[] { typeof(IMarkerInterface) },
TypeAttributes.Public | TypeAttributes.Class, false);
var toStringMethod = classEmitter.CreateFullNamedMethodOverride(typeof(ClassWithProtectedVirtualMethod).GetMethod(
"GetSecret", BindingFlags.NonPublic | BindingFlags.Instance));
toStringMethod.AddStatement(new ReturnStatement(new ConstReference("P0wned!")));
Type builtType = classEmitter.BuildType();
MethodInfo method = builtType.GetMethod("GetSecret",
BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly);
Assert.That(method, Is.Null);
method = builtType.GetMethod(typeof(ClassWithProtectedVirtualMethod).FullName + ".GetSecret",
BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly);
Assert.That(method, Is.Not.Null);
Assert.That(method.IsFamily, Is.True);
Assert.That(method.IsVirtual, Is.True);
Assert.That(method.IsFinal, Is.True);
var instance = (ClassWithProtectedVirtualMethod)Activator.CreateInstance(builtType);
Assert.That(method.Invoke(instance, null), Is.EqualTo("P0wned!"));
}
public void HasBeenBuilt()
{
var classEmitter = new CustomClassEmitter(Scope, "HasBeenBuilt", typeof(ClassEmitterTest));
Assert.That(classEmitter.HasBeenBuilt, Is.False);
classEmitter.BuildType();
Assert.That(classEmitter.HasBeenBuilt, Is.True);
}
private static MethodInfo DefineEquivalentInterfaceMethod(CustomClassEmitter emitter, MethodInfo method)
{
var interfaceMethod = emitter.CreateMethod(
method.Name,
MethodAttributes.Public | MethodAttributes.Abstract | MethodAttributes.Virtual,
method);
return(interfaceMethod.MethodBuilder);
}
public void CreateStaticField_WithAttributes()
{
var classEmitter = new CustomClassEmitter(Scope, "CreateStaticField_WithAttributes", typeof(object));
classEmitter.CreateStaticField("_test", typeof(string), FieldAttributes.Private);
Type t = classEmitter.BuildType();
Assert.That(t.GetField("_test", BindingFlags.NonPublic | BindingFlags.Static).Attributes, Is.EqualTo(FieldAttributes.Static | FieldAttributes.Private));
}
public void CreateProperty()
{
var classEmitter = new CustomClassEmitter(Scope, "CreateProperty", typeof(object));
CustomPropertyEmitter property = classEmitter.CreateProperty("Check", PropertyKind.Instance, typeof(string), Type.EmptyTypes, PropertyAttributes.None);
property.CreateGetMethod().AddStatement(new ReturnStatement(new ConstReference("4711")));
object instance = Activator.CreateInstance(classEmitter.BuildType());
Assert.That(instance.GetType().GetProperty("Check").GetValue(instance, null), Is.EqualTo("4711"));
}
public void CreateMethod()
{
var classEmitter = new CustomClassEmitter(Scope, "CreateMethod", typeof(object));
var method = classEmitter.CreateMethod("Check", MethodAttributes.Public, typeof(string), new Type[0]);
method.AddStatement(new ReturnStatement(new ConstReference("ret")));
object instance = Activator.CreateInstance(classEmitter.BuildType());
Assert.That(instance.GetType().GetMethod("Check").Invoke(instance, null), Is.EqualTo("ret"));
}
public void CreateStaticMethod()
{
var classEmitter = new CustomClassEmitter(Scope, "CreateStaticMethod", typeof(object));
var method = classEmitter.CreateMethod("Check", MethodAttributes.Public | MethodAttributes.Static, typeof(string), new Type[0]);
method.AddStatement(new ReturnStatement(new ConstReference("stat")));
Type t = classEmitter.BuildType();
Assert.That(t.GetMethod("Check").Invoke(null, null), Is.EqualTo("stat"));
}
public void DeriveFromClosedGenericTypeWithConstraints()
{
Type baseType = typeof(GenericClassWithConstraints <ICloneable, List <string>, int, object, ICloneable, List <List <ICloneable[]> > >);
CustomClassEmitter classEmitter = new CustomClassEmitter(Scope, "DeriveFromClosedGenericTypeWithConstraints", baseType, Type.EmptyTypes,
TypeAttributes.Public | TypeAttributes.Class, false);
Type builtType = classEmitter.BuildType();
Assert.That(builtType.ContainsGenericParameters, Is.False);
Assert.That(builtType.BaseType.ContainsGenericParameters, Is.False);
Assert.That(builtType.BaseType, Is.EqualTo(typeof(GenericClassWithConstraints <ICloneable, List <string>, int, object, ICloneable, List <List <ICloneable[]> > >)));
}
public override void SetUp()
{
base.SetUp();
_classEmitter = null;
_unsavedClassEmitter = null;
_methodEmitter = null;
_builtType = null;
_builtInstance = null;
_unsavedBuiltType = null;
}
public void PropertyNamePreservedOnOverride()
{
var classEmitter = new CustomClassEmitter(Scope, "PropertyNamePreservedOnOverride", typeof(ClassWithAllKindsOfMembers), Type.EmptyTypes,
TypeAttributes.Public | TypeAttributes.Class, false);
CustomPropertyEmitter property =
classEmitter.CreatePropertyOverride(typeof(ClassWithAllKindsOfMembers).GetProperty("Property", _declaredInstanceBindingFlags));
Assert.That(property.PropertyBuilder.Name, Is.EqualTo("Property"));
classEmitter.BuildType();
}
public void EmitSimpleClass()
{
var classEmitter = new CustomClassEmitter(Scope, "SimpleClass", typeof(ClassEmitterTest), new[] { typeof(IMarkerInterface) },
TypeAttributes.Public | TypeAttributes.Class, false);
Type builtType = classEmitter.BuildType();
Assert.That(builtType.FullName, Is.EqualTo("SimpleClass"));
Assert.That(builtType.BaseType, Is.EqualTo(typeof(ClassEmitterTest)));
Assert.That(typeof(IMarkerInterface).IsAssignableFrom(builtType), Is.True);
Assert.That(builtType.IsClass, Is.True);
Assert.That(builtType.IsPublic, Is.True);
}
public void GetPublicMethodWrapper()
{
var classEmitter = new CustomClassEmitter(Scope, "GetPublicMethodWrapper", typeof(ClassWithProtectedMethod));
classEmitter.GetPublicMethodWrapper(typeof(ClassWithProtectedMethod).GetMethod("GetSecret", _declaredInstanceBindingFlags));
object instance = Activator.CreateInstance(classEmitter.BuildType());
MethodInfo publicWrapper = instance.GetType().GetMethod("__wrap__GetSecret");
Assert.That(publicWrapper, Is.Not.Null);
Assert.That(publicWrapper.Invoke(instance, null), Is.EqualTo("The secret is to be more provocative and interesting than anything else in [the] environment."));
}
public void CreateEvent()
{
var classEmitter = new CustomClassEmitter(Scope, "CreateEvent", typeof(object));
CustomEventEmitter eventEmitter = classEmitter.CreateEvent("Eve", EventKind.Instance, typeof(Func <string>));
eventEmitter.AddMethod.AddStatement(new ReturnStatement());
eventEmitter.RemoveMethod.AddStatement(new ReturnStatement());
object instance = Activator.CreateInstance(classEmitter.BuildType());
Assert.That(instance.GetType().GetEvent("Eve"), Is.Not.Null);
}
public void CreateTypeConstructorCreateStaticField()
{
var classEmitter = new CustomClassEmitter(Scope, "CreateTypeConstructorCreateStaticField", typeof(object));
FieldReference field = classEmitter.CreateStaticField("s_test", typeof(string));
classEmitter.CreateTypeConstructor().CodeBuilder
.AddStatement(new AssignStatement(field, (new ConstReference("Yay").ToExpression())))
.AddStatement(new ReturnStatement());
Type t = classEmitter.BuildType();
Assert.That(t.GetField("s_test").GetValue(null), Is.EqualTo("Yay"));
}
public void SaveAssemblyUnsigned()
{
ModuleScope scope = new ModuleScope(true);
CustomClassEmitter emitter = new CustomClassEmitter(scope, "UnsignedType", typeof(object), Type.EmptyTypes, TypeAttributes.Public, true);
emitter.BuildType();
string[] paths = AssemblySaver.SaveAssemblies(scope);
Assert.That(paths.Length, Is.EqualTo(1));
Assert.That(paths[0], Is.EqualTo(Path.Combine(Environment.CurrentDirectory, scope.WeakNamedModuleName)));
File.Delete(paths[0]);
File.Delete(paths[0].Replace(".dll", ".pdb"));
}
public void DeriveFromOpenGenericTypeWithConstraints()
{
Type baseType = typeof(GenericClassWithConstraints <, , , , ,>);
CustomClassEmitter classEmitter = new CustomClassEmitter(Scope, "DeriveFromOpenGenericTypeWithConstraints", baseType, Type.EmptyTypes,
TypeAttributes.Public | TypeAttributes.Class, false);
Type builtType = classEmitter.BuildType();
Assert.That(builtType.ContainsGenericParameters, Is.True);
Type[] typeParameters = builtType.GetGenericArguments();
Assert.That(typeParameters.Length, Is.EqualTo(6));
Assert.That(builtType.BaseType.ContainsGenericParameters, Is.True);
Assert.That(builtType.BaseType.GetGenericArguments()[0], Is.EqualTo(typeParameters[0]));
}
public void GetPublicMethodWrapper_HasAttribute()
{
var classEmitter = new CustomClassEmitter(Scope, "GetPublicMethodWrapper_HasAttribute", typeof(ClassWithProtectedMethod));
classEmitter.GetPublicMethodWrapper(typeof(ClassWithProtectedMethod).GetMethod("GetSecret", _declaredInstanceBindingFlags));
object instance = Activator.CreateInstance(classEmitter.BuildType());
MethodInfo publicWrapper = instance.GetType().GetMethod("__wrap__GetSecret");
var attribute = AttributeUtility.GetCustomAttribute <GeneratedMethodWrapperAttribute> (publicWrapper, false);
Assert.That(attribute, Is.Not.Null);
}
public void CreatePublicInterfaceMethodImplementation()
{
var classEmitter = new CustomClassEmitter(Scope, "CreatePublicInterfaceMethodImplementation", typeof(object),
new[] { typeof(ICloneable) }, TypeAttributes.Public | TypeAttributes.Class, false);
var cloneMethod = classEmitter.CreatePublicInterfaceMethodImplementation(typeof(ICloneable).GetMethod("Clone"));
cloneMethod.AddStatement(new ReturnStatement(new ConstReference("P0wned!")));
Type builtType = classEmitter.BuildType();
object instance = Activator.CreateInstance(builtType);
Assert.That(((ICloneable)instance).Clone(), Is.EqualTo("P0wned!"));
}
public void AddCustomAttribute()
{
var classEmitter = new CustomClassEmitter(Scope, "AddCustomAttribute", typeof(object), Type.EmptyTypes, TypeAttributes.Public, true);
classEmitter.AddCustomAttribute(new CustomAttributeBuilder(typeof(SimpleAttribute).GetConstructor(Type.EmptyTypes), new object[0],
typeof(SimpleAttribute).GetFields(), new object[] { "value" }));
Type builtType = classEmitter.BuildType();
var attributes = (SimpleAttribute[])builtType.GetCustomAttributes(typeof(SimpleAttribute), false);
Assert.That(attributes.Length, Is.EqualTo(1));
Assert.That(attributes[0].S, Is.EqualTo("value"));
}
public void CreateConstructorCreateField()
{
var classEmitter = new CustomClassEmitter(Scope, "CreateConstructorCreateField", typeof(object));
FieldReference field = classEmitter.CreateField("_test", typeof(string));
ConstructorEmitter constructor = classEmitter.CreateConstructor(new[] { typeof(string), typeof(int) });
constructor.CodeBuilder.InvokeBaseConstructor();
constructor.CodeBuilder
.AddStatement(new AssignStatement(field, new ArgumentReference(typeof(string), 1).ToExpression()))
.AddStatement(new ReturnStatement());
object instance = Activator.CreateInstance(classEmitter.BuildType(), "bla", 0);
Assert.That(instance.GetType().GetField("_test").GetValue(instance), Is.EqualTo("bla"));
}
public void PropertyNameIsNotChangedOnPublicInterfaceImplementation()
{
var classEmitter = new CustomClassEmitter(Scope, "PropertyNameIsNotChangedOnPublicInterfaceImplementation", typeof(object), new[] { typeof(IInterfaceWithProperty) },
TypeAttributes.Public | TypeAttributes.Class, false);
CustomPropertyEmitter property = classEmitter.CreatePublicInterfacePropertyImplementation(
typeof(IInterfaceWithProperty).GetProperty("Property", _declaredInstanceBindingFlags));
Assert.That(property.PropertyBuilder.Name, Is.EqualTo("Property"));
property.SetMethod = classEmitter.CreateInterfaceMethodImplementation(
typeof(IInterfaceWithProperty).GetMethod("set_Property", _declaredInstanceBindingFlags));
property.SetMethod.AddStatement(new ReturnStatement());
classEmitter.BuildType();
}
public void GetPublicMethodWrapper_Cached()
{
var classEmitter = new CustomClassEmitter(Scope, "GetPublicMethodWrapper_Cached", typeof(ClassWithProtectedMethod));
MethodInfo emitter1 =
classEmitter.GetPublicMethodWrapper(typeof(ClassWithProtectedMethod).GetMethod("GetSecret", _declaredInstanceBindingFlags));
MethodInfo emitter2 =
classEmitter.GetPublicMethodWrapper(typeof(ClassWithProtectedMethod).GetMethod("GetSecret", _declaredInstanceBindingFlags));
Assert.That(emitter2, Is.SameAs(emitter1));
MethodInfo emitter3 =
classEmitter.GetPublicMethodWrapper(typeof(object).GetMethod("Finalize", _declaredInstanceBindingFlags));
Assert.That(emitter3, Is.Not.SameAs(emitter1));
classEmitter.BuildType();
}
public void OverrideConstrainedGenericMethod()
{
CustomClassEmitter classEmitter = new CustomClassEmitter(Scope, "OverrideConstrainedGenericMethod", typeof(ClassWithConstrainedGenericMethod), Type.EmptyTypes,
TypeAttributes.Public | TypeAttributes.Class, false);
MethodInfo baseMethod = typeof(ClassWithConstrainedGenericMethod).GetMethod("GenericMethod");
var methodEmitter = classEmitter.CreateMethodOverride(baseMethod);
methodEmitter.ImplementByBaseCall(baseMethod);
Type builtType = classEmitter.BuildType();
ClassWithConstrainedGenericMethod instance = (ClassWithConstrainedGenericMethod)Activator.CreateInstance(builtType);
string result = instance.GenericMethod("1", 2, "2");
Assert.That(result, Is.EqualTo("1, 2, 2"));
}
public void CreateIndexedPropertyOverride()
{
var classEmitter = new CustomClassEmitter(Scope, "CreateIndexedPropertyOverride", typeof(ClassWithAllKindsOfMembers), Type.EmptyTypes,
TypeAttributes.Public | TypeAttributes.Class, false);
PropertyInfo baseProperty = typeof(ClassWithAllKindsOfMembers).GetProperty("Item", _declaredInstanceBindingFlags);
CustomPropertyEmitter property = classEmitter.CreatePropertyOverride(baseProperty);
property.CreateGetMethod().ImplementByBaseCall(baseProperty.GetGetMethod());
property.CreateSetMethod().ImplementByBaseCall(baseProperty.GetSetMethod());
Type builtType = classEmitter.BuildType();
var instance = (ClassWithAllKindsOfMembers)Activator.CreateInstance(builtType);
Assert.That(instance[17], Is.EqualTo("17"));
instance[18] = "foo";
}
