public void IsSubclassable()
{
Assert.That(SubclassFilterUtility.IsSubclassable(typeof(string)), Is.False);
Assert.That(SubclassFilterUtility.IsSubclassable(typeof(IDisposable)), Is.False);
Assert.That(SubclassFilterUtility.IsSubclassable(typeof(TypeWithoutVisibleCtor)), Is.False);
Assert.That(SubclassFilterUtility.IsSubclassable(typeof(object)), Is.True);
}
private MethodInfo GetBaseMethod(MutableType declaringType, string name, MethodSignature signature, bool isVirtual, bool isNewSlot)
{
if (declaringType.IsInterface || !isVirtual || isNewSlot)
{
return(null);
}
var baseMethod = _relatedMethodFinder.GetMostDerivedVirtualMethod(name, signature, declaringType.BaseType);
if (baseMethod != null && baseMethod.IsFinal)
{
Assertion.IsNotNull(baseMethod.DeclaringType);
var message = string.Format("Cannot override final method '{0}.{1}'.", baseMethod.DeclaringType.Name, baseMethod.Name);
throw new NotSupportedException(message);
}
if (baseMethod != null && !SubclassFilterUtility.IsVisibleFromSubclass(baseMethod))
{
Assertion.IsNotNull(baseMethod.DeclaringType);
var message = string.Format(
"Cannot override method '{0}.{1}' as it is not visible from the proxy.", baseMethod.DeclaringType.Name, baseMethod.Name);
throw new NotSupportedException(message);
}
return(baseMethod);
}
private void CheckVisibility(MethodInfo baseMethod)
{
if (!SubclassFilterUtility.IsVisibleFromSubclass(baseMethod))
{
Assertion.IsNotNull(baseMethod.DeclaringType);
var message = string.Format("Base method '{0}.{1}' is not accessible from proxy type.", baseMethod.DeclaringType.Name, baseMethod.Name);
throw new MemberAccessException(message);
}
}
public MutableMethodInfo GetOrCreateImplementation(MutableType declaringType, MethodInfo interfaceMethod, out bool isNewlyCreated)
{
ArgumentUtility.CheckNotNull("declaringType", declaringType);
ArgumentUtility.CheckNotNull("interfaceMethod", interfaceMethod);
Assertion.IsNotNull(interfaceMethod.DeclaringType);
if (!interfaceMethod.DeclaringType.IsInterface)
{
throw new ArgumentException("The specified method is not an interface method.", "interfaceMethod");
}
CheckIsNotMethodInstantiation(interfaceMethod, "interfaceMethod");
// ReSharper disable PossibleUnintendedReferenceComparison
if (!interfaceMethod.DeclaringType.IsTypePipeAssignableFrom(declaringType))
// ReSharper restore PossibleUnintendedReferenceComparison
{
Assertion.IsNotNull(interfaceMethod.DeclaringType);
var message = string.Format(
"Method is declared by an interface that is not implemented by the proxy: '{0}'.", interfaceMethod.DeclaringType.Name);
throw new ArgumentException(message, "interfaceMethod");
}
var baseImplementation = GetOrCreateImplementationMethod(declaringType, interfaceMethod, out isNewlyCreated);
if (baseImplementation is MutableMethodInfo)
{
return((MutableMethodInfo)baseImplementation);
}
Assertion.IsTrue(baseImplementation.IsVirtual, "It is not possible to get an interface implementation that is not virtual (in verifiable code).");
// Re-implement if final.
if (baseImplementation.IsFinal)
{
if (!SubclassFilterUtility.IsVisibleFromSubclass(baseImplementation))
{
Assertion.IsNotNull(baseImplementation.DeclaringType);
var message = string.Format(
"Cannot re-implement interface method '{0}' because its base implementation on '{1}' is not accessible.",
interfaceMethod.Name,
baseImplementation.DeclaringType.Name);
throw new NotSupportedException(message);
}
declaringType.AddInterface(interfaceMethod.DeclaringType, throwIfAlreadyImplemented: false);
var attributes = interfaceMethod.Attributes.Unset(MethodAttributes.Abstract);
Func <MethodBodyCreationContext, Expression> bodyProvider = ctx => ctx.DelegateToBase(baseImplementation);
isNewlyCreated = true;
return(CreateMethod(declaringType, interfaceMethod, interfaceMethod.Name, attributes, bodyProvider));
}
return(GetOrCreateOverride(declaringType, baseImplementation, out isNewlyCreated));
}
private bool ShortCircuitTypeAssembly(Type requestedType)
{
var isNonSubclassable = !SubclassFilterUtility.IsSubclassable(requestedType);
if (isNonSubclassable)
{
foreach (var participant in _participants)
{
participant.HandleNonSubclassableType(requestedType);
}
}
return(isNonSubclassable);
}
public MethodCallExpression CallBaseConstructor(IEnumerable <Expression> arguments)
{
ArgumentUtility.CheckNotNull("arguments", arguments);
EnsureNotStatic();
var args = arguments.ToList();
var constructor = GetConstructor(DeclaringType.BaseType, args);
if (!SubclassFilterUtility.IsVisibleFromSubclass(constructor))
{
throw new MemberAccessException("The matching constructor is not visible from the proxy type.");
}
return(CallConstructor(constructor, args));
}
