internal void EnsureValid()
{
IMethodEmitter addMethod = AddMethod; // cause generation of default method if none has been assigned
Assertion.IsNotNull(addMethod);
IMethodEmitter removeMethod = RemoveMethod; // cause generation of default method if none has been assigned
Assertion.IsNotNull(removeMethod);
}
public ExpressionReference(Type referenceType, Expression expression, IMethodEmitter methodEmitter)
: base(ArgumentUtility.CheckNotNull("referenceType", referenceType))
{
ArgumentUtility.CheckNotNull("expression", expression);
ArgumentUtility.CheckNotNull("methodEmitter", methodEmitter);
_referenceType = referenceType;
_methodEmitter = methodEmitter;
_expression = expression;
}
public override void SetUp()
{
base.SetUp();
_classEmitter = null;
_unsavedClassEmitter = null;
_methodEmitter = null;
_builtType = null;
_builtInstance = null;
_unsavedBuiltType = null;
}
private LocalReference CopyArgumentsToLocalVariable(IMethodEmitter overrider)
{
LocalReference argsLocal = overrider.DeclareLocal(typeof(object[]));
ArgumentReference[] argumentReferences = overrider.ArgumentReferences;
overrider.AddStatement(new AssignStatement(argsLocal, new NewArrayExpression(argumentReferences.Length, typeof(object))));
for (int i = 0; i < argumentReferences.Length; ++i)
{
Expression castArgument = new ConvertExpression(typeof(object), argumentReferences[i].Type, argumentReferences[i].ToExpression());
overrider.AddStatement(new AssignArrayStatement(argsLocal, i, castArgument));
}
return(argsLocal);
}
private IMethodEmitter CreatePublicMethodWrapper(MethodInfo methodToBeWrapped)
{
const MethodAttributes attributes = MethodAttributes.Public | MethodAttributes.HideBySig;
IMethodEmitter wrapper = CreateMethod("__wrap__" + methodToBeWrapped.Name, attributes, methodToBeWrapped);
wrapper.ImplementByDelegating(new TypeReferenceWrapper(SelfReference.Self, TypeBuilder), methodToBeWrapped);
var attributeBuilder = new CustomAttributeBuilder(s_generatedMethodWrapperAttributeCtor, new object[] { methodToBeWrapped.DeclaringType, methodToBeWrapped.Name, methodToBeWrapped.ToString() });
wrapper.AddCustomAttribute(attributeBuilder);
return(wrapper);
}
public IMethodEmitter GetMethodEmitter(bool isStatic, Type returnType, Type[] parameterTypes)
{
if (_methodEmitter == null)
{
MethodAttributes flags = MethodAttributes.Public;
if (isStatic)
{
flags |= MethodAttributes.Static;
}
_methodEmitter = ClassEmitter.CreateMethod("TestMethod", flags, returnType, parameterTypes);
}
return(_methodEmitter);
}
private void CreateRemoveMethod()
{
Assertion.IsNull(_removeMethod);
MethodAttributes flags = MethodAttributes.Public | MethodAttributes.SpecialName;
if (EventKind == EventKind.Static)
{
flags |= MethodAttributes.Static;
}
IMethodEmitter method = _declaringType.CreateMethod("remove_" + Name, flags, typeof(void), new [] { EventType });
RemoveMethod = method;
}
// TODO FS: Test for explicit interface implementation
public IMethodEmitter CreateGetMethod()
{
if (GetMethod != null)
{
throw new InvalidOperationException("This property already has a getter method.");
}
else
{
MethodAttributes flags = MethodAttributes.Public | MethodAttributes.SpecialName;
if (PropertyKind == PropertyKind.Static)
{
flags |= MethodAttributes.Static;
}
IMethodEmitter method = _declaringType.CreateMethod(BuildAccessorMethodName(Name, "get"), flags, PropertyType, IndexParameters);
GetMethod = method;
return(method);
}
}
public IMethodEmitter CreateMethodOverrideOrInterfaceImplementation(
MethodInfo baseOrInterfaceMethod,
bool keepName,
MethodAttributes visibilityFlags)
{
ArgumentUtility.CheckNotNull("baseOrInterfaceMethod", baseOrInterfaceMethod);
MethodAttributes methodDefinitionAttributes = MethodAttributes.HideBySig | MethodAttributes.Virtual | visibilityFlags;
if (baseOrInterfaceMethod.IsSpecialName)
{
methodDefinitionAttributes |= MethodAttributes.SpecialName;
}
string methodName = GetMemberOverrideName(baseOrInterfaceMethod, keepName);
IMethodEmitter methodDefinition = CreateMethod(methodName, methodDefinitionAttributes, baseOrInterfaceMethod);
TypeBuilder.DefineMethodOverride(methodDefinition.MethodBuilder, baseOrInterfaceMethod);
return(methodDefinition);
}
// TODO FS: Test for explicit interface implementation
public IMethodEmitter CreateSetMethod()
{
if (SetMethod != null)
{
throw new InvalidOperationException("This property already has a setter method.");
}
else
{
MethodAttributes flags = MethodAttributes.Public | MethodAttributes.SpecialName;
if (PropertyKind == PropertyKind.Static)
{
flags |= MethodAttributes.Static;
}
Type[] setterParameterTypes = new Type[IndexParameters.Length + 1];
IndexParameters.CopyTo(setterParameterTypes, 0);
setterParameterTypes[IndexParameters.Length] = PropertyType;
IMethodEmitter method = _declaringType.CreateMethod(BuildAccessorMethodName(Name, "set"), flags, typeof(void), setterParameterTypes);
SetMethod = method;
return(method);
}
}
protected object InvokeMethod(object instance, IMethodEmitter method, Type[] typeArguments, params object[] arguments)
{
var methodInfo = GetMethod(instance, method).MakeGenericMethod(typeArguments);
return(methodInfo.Invoke(instance, arguments));
}
// Implement method in proxy by forwarding call to proxied instance
private void ImplementForwardingMethod(MethodInfo methodInfo, IMethodEmitter methodEmitter)
{
methodEmitter.ImplementByDelegating(new TypeReferenceWrapper(_proxied, _proxiedType), methodInfo);
}
protected MethodInfo GetMethod(object instance, IMethodEmitter method)
{
return(GetMethod(instance.GetType(), method));
}
protected MethodInfo BuildTypeAndGetMethod(IMethodEmitter method)
{
Type builtType = _classEmitter.BuildType();
return(GetMethod(builtType, method));
}
public InitObjectExpression(IMethodEmitter method, Type type)
: this(ArgumentUtility.CheckNotNull("method", method).DeclareLocal(type), type)
{
}
protected object BuildInstanceAndInvokeMethod(IMethodEmitter method, Type[] typeArguments, params object[] arguments)
{
object instance = BuildInstance();
return(InvokeMethod(instance, method, typeArguments, arguments));
}
private MethodInfo GetMethod(Type builtType, IMethodEmitter method)
{
return(builtType.GetMethod(method.Name));
}
private object InvokeMethod(Type type, IMethodEmitter method, params object[] arguments)
{
var methodInfo = GetMethod(type, method);
return(methodInfo.Invoke(null, arguments));
}
protected object InvokeMethod(object instance, IMethodEmitter method, params object[] arguments)
{
var methodInfo = GetMethod(instance, method);
return(methodInfo.Invoke(instance, arguments));
}
protected object BuildTypeAndInvokeMethod(IMethodEmitter method, params object[] arguments)
{
Type builtType = _classEmitter.BuildType();
return(InvokeMethod(builtType, method, arguments));
}
