public Interceptor[] GetPropertyInterceptors(Type interceptorType, PropertyInfo property, out MethodInfo[] methods)
{
if (_interceptorResolver == null)
{
throw new InvalidOperationException("Weld component manager is not yet deployed");
}
var resolvable = new InterceptorResolvable(interceptorType, property);
var interceptors = _interceptorResolver.Resolve(resolvable).ToArray();
if (interceptors.Any())
{
methods = new[] { property.SetMethod, property.GetMethod }.Where(x => x != null).ToArray();
foreach (var method in methods)
{
InterceptionValidator.ValidateInterceptableMethod(method, resolvable);
}
}
else
{
methods = new MethodInfo[0];
}
return(interceptors);
}
private static void ThrowNotInterceptableClassException(Type type, InterceptorResolvable resolvable,
string reason)
{
var msg = string.Format("Class [{0}] with interceptor-bindings [{1}] {2}", type,
string.Join(",", resolvable.Bindings.Cast <object>().ToArray()),
reason);
throw new NotInterceptableException(msg);
}
public static void ValidateInterceptableMethod(MethodInfo methodInfo, InterceptorResolvable resolvable)
{
if (methodInfo.IsStatic)
{
ThrowNotInterceptableMethodException(methodInfo, resolvable, "must not be static");
}
if (methodInfo.IsPrivate)
{
ThrowNotInterceptableMethodException(methodInfo, resolvable, "must not be private");
}
if (!TypeUtils.IsOveridable(methodInfo))
{
ThrowNotInterceptableMethodException(methodInfo, resolvable, "must be virtual");
}
}
public Interceptor[] GetMethodInterceptors(Type interceptorType, MethodInfo methodInfo)
{
if (_interceptorResolver == null)
{
throw new InvalidOperationException("Weld component manager is not yet deployed");
}
var resolvable = new InterceptorResolvable(interceptorType, methodInfo);
var interceptors = _interceptorResolver.Resolve(resolvable).ToArray();
if (interceptors.Any())
{
InterceptionValidator.ValidateInterceptableMethod(methodInfo, resolvable);
}
return(interceptors);
}
public Interceptor[] GetClassInterceptors(Type interceptorType, IComponent component, out MethodInfo[] methods)
{
if (_interceptorResolver == null)
{
throw new InvalidOperationException("Weld component manager is not yet deployed");
}
var intercetorResolvable = new InterceptorResolvable(interceptorType, component);
var interceptors = _interceptorResolver.Resolve(intercetorResolvable).ToArray();
var allowPartial = interceptors.All(x => x.AllowPartialInterception);
if (interceptors.Any())
{
InterceptionValidator.ValidateInterceptableClass(component.Type, intercetorResolvable, allowPartial, out methods);
}
else
{
methods = new MethodInfo[0];
}
return(interceptors);
}
public static void ValidateInterceptableClass(Type type, InterceptorResolvable resolvable, bool allowPartial, out MethodInfo[] methods)
{
var builder = new StringBuilder();
if (type.IsSealed)
{
builder.Append("class is sealed");
}
const BindingFlags flagsAll = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance;
methods = type.GetMethods(flagsAll)
.Union(type.GetProperties(flagsAll)
.SelectMany(x => new[] { x.SetMethod, x.GetGetMethod() }.Where(m => m != null)))
.Where(x => !x.IsPrivate).ToArray();
var nonVirtualMethods = methods.Where(x => !TypeUtils.IsOveridable(x) && x.DeclaringType != typeof(object)).ToArray();
if (nonVirtualMethods.Any())
{
if (allowPartial)
{
methods = methods.Except(nonVirtualMethods).ToArray();
}
else
{
builder.Append(
string.Format("These public members must be virtual: {0}",
string.Join(",/n", nonVirtualMethods.Select(x => x.ToString()))));
}
}
if (builder.Length > 0)
{
ThrowNotInterceptableClassException(type, resolvable, builder.ToString());
}
}
private static void ThrowNotInterceptableMethodException(MethodInfo methodInfo, InterceptorResolvable resolvable,
string reason)
{
var msg = string.Format("Method [{0}] with interceptor-bindings [{1}] {2}", methodInfo,
string.Join(",", resolvable.Bindings.Cast <object>().ToArray()),
reason);
throw new NotInterceptableException(msg);
}
