void DefineMethodOverride(MethodGen methodBody, MethodInfo methodDeclaration)
{
foreach (InterfaceImplEntry iie in implementations)
{
if (iie.InterfaceMethod.Member == methodDeclaration)
{
iie.Bind(methodBody);
return;
}
}
}
public MethodGen RemoveMethod(string parameterName)
{
if (remover == null)
{
remover = new MethodGen(owner, "remove_" + name, attrs | MethodAttributes.SpecialName, typeof(void), 0);
remover.Parameter(type, parameterName);
eb.SetRemoveOnMethod(remover.GetMethodBuilder());
}
return(remover);
}
public MethodGen AddMethod(string parameterName)
{
if (adder == null)
{
adder = new MethodGen(owner, "add_" + name, attrs | MethodAttributes.SpecialName, typeof(void), 0);
adder.Parameter(type, parameterName);
eb.SetAddOnMethod(adder.GetMethodBuilder());
}
return(adder);
}
public MethodGen AddMethod(string parameterName)
{
if (_adder == null)
{
LockSignature();
_adder = new MethodGen(_owner, "add_" + Name, _attrs | MethodAttributes.SpecialName, TypeMapper.MapType(typeof(void)), 0);
_adder.ImplementedInterface = ImplementedInterface;
_adder.Parameter(_type, parameterName);
_eb.SetAddOnMethod(_adder.GetMethodBuilder());
}
return(_adder);
}
public MethodGen Getter()
{
if (_getter == null)
{
LockSignature();
_getter = new MethodGen(_owner, "get_" + Name, _attrs | MethodAttributes.SpecialName, _type, 0);
_getter.ImplementedInterface = ImplementedInterface;
_getter.CopyParameters(_indexParameters);
_pb.SetGetMethod(_getter.GetMethodBuilder());
}
return(_getter);
}
public MethodGen Getter()
{
if (getter == null)
{
LockSignature();
getter = new MethodGen(owner, "get_" + name, attrs | MethodAttributes.SpecialName, type, 0);
getter.ImplementedInterface = interfaceType;
getter.CopyParameters(indexParameters);
pb.SetGetMethod(getter.GetMethodBuilder());
}
return(getter);
}
public MethodGen MethodImplementation(Type interfaceType, Type returnType, string name)
{
if (tb.IsInterface)
{
throw new InvalidOperationException("Interface cannot contain explicit interface implementations");
}
MethodGen mg = new MethodGen(this, name,
MethodAttributes.Public | MethodAttributes.NewSlot | MethodAttributes.Virtual | MethodAttributes.Final,
returnType, 0);
mg.ImplementedInterface = interfaceType;
return(mg);
}
public MethodGen Setter()
{
if (_setter == null)
{
LockSignature();
_setter = new MethodGen(_owner, "set_" + Name, _attrs | MethodAttributes.SpecialName, TypeMapper.MapType(typeof(void)), 0);
_setter.ImplementedInterface = ImplementedInterface;
_setter.CopyParameters(_indexParameters);
_setter.UncheckedParameter(_type, "value");
_pb.SetSetMethod(_setter.GetMethodBuilder());
}
return(_setter);
}
public MethodGen Setter()
{
if (setter == null)
{
LockSignature();
setter = new MethodGen(owner, "set_" + name, attrs | MethodAttributes.SpecialName, typeof(void), 0);
setter.ImplementedInterface = interfaceType;
setter.CopyParameters(indexParameters);
setter.UncheckedParameter(type, "value");
pb.SetSetMethod(setter.GetMethodBuilder());
}
return(setter);
}
public MethodGen MethodImplementation(Type interfaceType, Type returnType, string name)
{
if (tb.IsInterface)
{
throw new InvalidOperationException(Properties.Messages.ErrInterfaceNoExplicitImpl);
}
MethodGen mg = new MethodGen(this, name,
MethodAttributes.Private | MethodAttributes.NewSlot | MethodAttributes.Virtual | MethodAttributes.Final,
returnType, 0);
mg.ImplementedInterface = interfaceType;
return(mg);
}
public MethodGen Method(Type returnType, string name)
{
if (mthVis == 0)
{
mthVis |= MethodAttributes.Private;
}
if (tb.IsInterface)
{
mthVirt |= MethodAttributes.Virtual | MethodAttributes.Abstract;
}
MethodGen mg = new MethodGen(this, name, mthVis | mthVirt | mthFlags, returnType, implFlags);
ResetAttrs();
return(mg);
}
public MethodGen CommonConstructor()
{
if (TypeBuilder.IsValueType)
{
throw new InvalidOperationException(Messages.ErrStructNoDefaultCtor);
}
if (TypeBuilder.IsInterface)
{
throw new InvalidOperationException(Messages.ErrInterfaceNoCtor);
}
if (_commonCtor == null)
{
_commonCtor = new MethodGen(this, "$$ctor", 0, TypeMapper.MapType(typeof(void)), 0).LockSignature();
}
return(_commonCtor);
}
public MethodGen CommonConstructor()
{
if (tb.IsValueType)
{
throw new InvalidOperationException(Properties.Messages.ErrStructNoDefaultCtor);
}
if (tb.IsInterface)
{
throw new InvalidOperationException(Properties.Messages.ErrInterfaceNoCtor);
}
if (commonCtor == null)
{
commonCtor = new MethodGen(this, "$$ctor", 0, typeof(void), 0).LockSignature();
}
return(commonCtor);
}
public MethodGen CommonConstructor()
{
if (tb.IsValueType)
{
throw new InvalidOperationException("Value types cannot have default constructors");
}
if (tb.IsInterface)
{
throw new InvalidOperationException("Interface cannot define a constructor");
}
if (commonCtor == null)
{
commonCtor = new MethodGen(this, "$$ctor", 0, typeof(void), 0).LockSignature();
}
return(commonCtor);
}
internal MethodAttributes PreprocessAttributes(MethodGen mg, MethodAttributes attrs)
{
bool requireVirtual = false;
foreach (InterfaceImplEntry implEntry in implementations)
{
if (!implEntry.IsBound && implEntry.Match(mg))
{
implEntry.Bind(mg);
requireVirtual = true;
}
}
if (requireVirtual && ((attrs & MethodAttributes.Virtual) == 0))
{
// create an exclusive VTable entry for the method
attrs |= MethodAttributes.Virtual | MethodAttributes.NewSlot | MethodAttributes.Final;
}
return(attrs);
}
public void Bind(MethodGen implementation)
{
BoundMethod = implementation;
}
public void Bind(MethodGen implementation)
{
this.implementation = implementation;
}
public bool Match(MethodGen candidate)
{
return(candidate.Name == interfaceMethod.Name &&
candidate.ReturnType == interfaceMethod.ReturnType &&
ArrayUtils.Equals(candidate.ParameterTypes, interfaceMethod.ParameterTypes));
}
public void setImplementation2(MethodGen mg)
{
implementations.ToArray()[1].Bind(mg);
}
