private void ImplementBaseCallForOverridenMethodOnTarget(MethodDefinition methodDefinitionOnTarget)
{
Assertion.IsTrue(methodDefinitionOnTarget.DeclaringClass == _targetClassDefinition);
var attributes = MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.Virtual;
var md = MethodDeclaration.CreateEquivalent(methodDefinitionOnTarget.MethodInfo);
var methodOverride = _type.AddMethod(
methodDefinitionOnTarget.FullName,
attributes,
md,
ctx => _nextCallMethodGenerator.CreateBaseCallToNextInChain(ctx, methodDefinitionOnTarget));
_overriddenMethodToImplementationMap.Add(methodDefinitionOnTarget, methodOverride);
// If the base type of the emitter (object) already has the method being overridden (ToString, Equals, etc.), mixins could use the base
// implementation of the method rather than coming via the next call interface. Therefore, we need to override that base method and point it
// towards our next call above.
Assertion.IsTrue(
_type.BaseType == typeof(object),
"This code assumes that only non-generic methods could match on the base type, which holds for object.");
// Since object has no generic methods, we can use the exact parameter types to find the equivalent method.
var equivalentMethodOnProxyBase = _type.BaseType.GetMethod(
methodDefinitionOnTarget.Name,
BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance,
null,
methodOverride.GetParameters().Select(p => p.ParameterType).ToArray(),
null);
if (equivalentMethodOnProxyBase != null && equivalentMethodOnProxyBase.IsVirtual)
{
_type.GetOrAddOverride(equivalentMethodOnProxyBase)
.SetBody(ctx => ctx.DelegateTo(ctx.This, methodOverride));
}
}
private MutableMethodInfo ImplementMethodOverride(MethodDefinition method)
{
var proxyMethod = _nextCallProxy.GetProxyMethodForOverriddenMethod(method);
var methodOverride = _concreteTarget.GetOrAddOverride(method.MethodInfo);
methodOverride.SetBody(ctx => _expressionBuilder.CreateInitializingDelegation(ctx, _initializationMethod, _firstField, proxyMethod));
return(methodOverride);
}
public OverrideInterface GenerateOverrides()
{
var overrideInterfaceGenerator = OverrideInterfaceGenerator.CreateNestedGenerator(_type, "IOverriddenMethods");
var targetReference = GetTargetReference();
foreach (var method in _identifier.Overridden)
{
var methodOverride = _type.GetOrAddOverride(method);
var methodToCall = overrideInterfaceGenerator.AddOverriddenMethod(method);
AddCallToOverrider(methodOverride, targetReference, methodToCall);
}
return(new OverrideInterface(overrideInterfaceGenerator.Type, overrideInterfaceGenerator.InterfaceMethodsForOverriddenMethods));
}
public void Intercept(MutableType proxyType)
{
ArgumentUtility.CheckNotNull("proxyType", proxyType);
proxyType.GetOrAddOverride(_interceptedAccessorMethod).SetBody(ctx => WrapBody(CreateBody(ctx)));
}
private void OverrideGetPublicDomainObjectType(MutableType proxyType, Type publicDomainObjectType)
{
proxyType.GetOrAddOverride(s_getPublicDomainObjectTypeImplementation).SetBody(ctx => Expression.Constant(publicDomainObjectType));
}
private void OverridePerformConstructorCheck(MutableType proxyType)
{
proxyType.GetOrAddOverride(s_performConstructorCheck).SetBody(ctx => Expression.Empty());
}