/// <summary>
/// Performs some basic screening and invokes the <see cref="IProxyGenerationHook"/>
/// to select methods.
/// </summary>
/// <param name="method"></param>
/// <param name="onlyVirtuals"></param>
/// <param name="hook"></param>
/// <returns></returns>
protected bool AcceptMethod(MethodInfo method, bool onlyVirtuals, IProxyGenerationHook hook)
{
// we can never intercept a sealed (final) method
if (method.IsFinal)
{
Logger.Debug("Excluded sealed method {0} on {1} because it cannot be intercepted.", method.Name, method.DeclaringType.FullName);
return(false);
}
bool isInternalsAndNotVisibleToDynamicProxy = InternalsHelper.IsInternal(method);
if (isInternalsAndNotVisibleToDynamicProxy)
{
isInternalsAndNotVisibleToDynamicProxy = InternalsHelper.IsInternalToDynamicProxy(method.DeclaringType.Assembly) ==
false;
}
if (isInternalsAndNotVisibleToDynamicProxy)
{
return(false);
}
if (onlyVirtuals && !method.IsVirtual)
{
#if SILVERLIGHT
if (method.DeclaringType != typeof(object))
#else
if (method.DeclaringType != typeof(object) && method.DeclaringType != typeof(MarshalByRefObject))
#endif
{
Logger.Debug("Excluded non-virtual method {0} on {1} because it cannot be intercepted.", method.Name, method.DeclaringType.FullName);
hook.NonVirtualMemberNotification(type, method);
}
return(false);
}
//can only proxy methods that are public or protected (or internals that have already been checked above)
if ((method.IsPublic || method.IsFamily || method.IsAssembly || method.IsFamilyOrAssembly) == false)
{
return(false);
}
if (method.DeclaringType == typeof(object))
{
return(false);
}
#if !SILVERLIGHT
if (method.DeclaringType == typeof(MarshalByRefObject))
{
return(false);
}
#endif
return(hook.ShouldInterceptMethod(type, method));
}
/// <summary>
/// Performs some basic screening and invokes the <see cref = "IProxyGenerationHook" />
/// to select methods.
/// </summary>
/// <param name = "method"></param>
/// <param name = "onlyVirtuals"></param>
/// <param name = "hook"></param>
/// <returns></returns>
protected bool AcceptMethod(MethodInfo method, bool onlyVirtuals, IProxyGenerationHook hook)
{
if (IsInternalAndNotVisibleToDynamicProxy(method))
{
return(false);
}
var isOverridable = method.IsVirtual && !method.IsFinal;
if (onlyVirtuals && !isOverridable)
{
if (
#if !SILVERLIGHT
method.DeclaringType != typeof(MarshalByRefObject) &&
#endif
method.IsGetType() == false &&
method.IsMemberwiseClone() == false)
{
Logger.DebugFormat("Excluded non-overridable method {0} on {1} because it cannot be intercepted.", method.Name,
method.DeclaringType.FullName);
hook.NonProxyableMemberNotification(type, method);
}
return(false);
}
// we can never intercept a sealed (final) method
if (method.IsFinal)
{
Logger.DebugFormat("Excluded sealed method {0} on {1} because it cannot be intercepted.", method.Name,
method.DeclaringType.FullName);
return(false);
}
//can only proxy methods that are public or protected (or internals that have already been checked above)
if ((method.IsPublic || method.IsFamily || method.IsAssembly || method.IsFamilyOrAssembly) == false)
{
return(false);
}
#if !SILVERLIGHT
if (method.DeclaringType == typeof(MarshalByRefObject))
{
return(false);
}
#endif
if (method.IsFinalizer())
{
return(false);
}
return(hook.ShouldInterceptMethod(type, method));
}
public bool ShouldInterceptMethod(Type type, MethodInfo methodInfo)
{
if (IsChannelHolderMethod(methodInfo))
{
return(false);
}
if (hook != null)
{
return(hook.ShouldInterceptMethod(type, methodInfo));
}
return(true);
}
public bool ShouldInterceptMethod(Type type, MethodInfo methodInfo)
{
// NOTE: This is fixed now. This code can be uncommented and Selector does not have to have this responsibility anymore
// BUG: Due to... illogical behavior of DP this will produce illformed proxy types.
// We have to move this piece of logic to InterceptorSelector, and move it back when the bug gets fixed.
//if (IsChannelHolderMethod(methodInfo))
//{
// return false;
//}
if (hook != null)
{
return(hook.ShouldInterceptMethod(type, methodInfo));
}
return(true);
}
protected override MetaMethod GetMethodToGenerate(MethodInfo method, IProxyGenerationHook hook, bool isStandalone)
{
if (ProxyUtil.IsAccessibleMethod(method) == false)
{
return(null);
}
var interceptable = AcceptMethodPreScreen(method, true, hook);
if (!interceptable)
{
//we don't need to do anything...
return(null);
}
var accepted = hook.ShouldInterceptMethod(type, method);
return(new MetaMethod(method, method, isStandalone, accepted, hasTarget: true));
}
/// <summary>
/// Performs some basic screening and invokes the <see cref = "IProxyGenerationHook" />
/// to select methods.
/// </summary>
/// <param name = "method"></param>
/// <param name = "onlyVirtuals"></param>
/// <param name = "hook"></param>
/// <returns></returns>
protected bool AcceptMethod(MethodInfo method, bool onlyVirtuals, IProxyGenerationHook hook)
{
// we can never intercept a sealed (final) method
if (method.IsFinal)
{
Logger.DebugFormat("Excluded sealed method {0} on {1} because it cannot be intercepted.", method.Name,
method.DeclaringType.FullName);
return false;
}
if (IsInternalAndNotVisibleToDynamicProxy(method))
{
return false;
}
if (onlyVirtuals && !method.IsVirtual)
{
if (
#if !SILVERLIGHT
method.DeclaringType != typeof(MarshalByRefObject) &&
#endif
method.IsGetType() == false &&
method.IsMemberwiseClone() == false)
{
Logger.DebugFormat("Excluded non-virtual method {0} on {1} because it cannot be intercepted.", method.Name,
method.DeclaringType.FullName);
hook.NonProxyableMemberNotification(type, method);
}
return false;
}
//can only proxy methods that are public or protected (or internals that have already been checked above)
if ((method.IsPublic || method.IsFamily || method.IsAssembly || method.IsFamilyOrAssembly) == false)
{
return false;
}
#if !SILVERLIGHT
if (method.DeclaringType == typeof(MarshalByRefObject))
{
return false;
}
#endif
if (method.IsFinalizer())
{
return false;
}
return hook.ShouldInterceptMethod(type, method);
}
/// <summary>
/// Performs some basic screening and invokes the <see cref="IProxyGenerationHook"/>
/// to select methods.
/// </summary>
/// <param name="method"></param>
/// <param name="onlyVirtuals"></param>
/// <param name="hook"></param>
/// <returns></returns>
protected bool AcceptMethod(MethodInfo method, bool onlyVirtuals, IProxyGenerationHook hook)
{
// we can never intercept a sealed (final) method
if (method.IsFinal)
{
Logger.Debug("Excluded sealed method {0} on {1} because it cannot be intercepted.", method.Name, method.DeclaringType.FullName);
return false;
}
bool isInternalsAndNotVisibleToDynamicProxy = InternalsHelper.IsInternal(method);
if (isInternalsAndNotVisibleToDynamicProxy)
{
isInternalsAndNotVisibleToDynamicProxy = InternalsHelper.IsInternalToDynamicProxy(method.DeclaringType.Assembly) ==
false;
}
if (isInternalsAndNotVisibleToDynamicProxy)
return false;
if (onlyVirtuals && !method.IsVirtual)
{
#if SILVERLIGHT
if (method.DeclaringType != typeof(object))
#else
if (method.DeclaringType != typeof(object) && method.DeclaringType != typeof(MarshalByRefObject))
#endif
{
Logger.Debug("Excluded non-virtual method {0} on {1} because it cannot be intercepted.", method.Name, method.DeclaringType.FullName);
hook.NonVirtualMemberNotification(type, method);
}
return false;
}
//can only proxy methods that are public or protected (or internals that have already been checked above)
if ((method.IsPublic || method.IsFamily || method.IsAssembly || method.IsFamilyOrAssembly) == false)
return false;
if (method.DeclaringType == typeof (object))
{
return false;
}
#if !SILVERLIGHT
if (method.DeclaringType == typeof (MarshalByRefObject))
{
return false;
}
#endif
return hook.ShouldInterceptMethod(type, method);
}
public override bool ShouldInterceptMethod(Type type, MethodInfo methodInfo)
{
return(_episerverInternalHook.ShouldInterceptMethod(type, methodInfo) || IsEPiProperty(type, methodInfo));
}
/// <summary>
/// Performs some basic screening and invokes the <see cref = "IProxyGenerationHook" />
/// to select methods.
/// </summary>
protected bool AcceptMethod(MethodInfo method, bool onlyVirtuals, IProxyGenerationHook hook)
{
return(AcceptMethodPreScreen(method, onlyVirtuals, hook) && hook.ShouldInterceptMethod(type, method));
}
