internal PreVerbExecutionContext(
Method method,
object target,
ParameterAndValue[] parameters)
: base(method, target, parameters, new Dictionary<object, object>())
{
}
protected UserVerbExecutionContext(
Method method,
object target,
ParameterAndValue[] parameters,
Dictionary<object, object> userContext)
{
Method = method;
Target = target;
Parameters = parameters;
UserContext = userContext;
}
internal PostVerbExecutionContext(
Method method,
object target,
ParameterAndValue[] parameters,
bool cancelled,
Exception exception,
Dictionary<object, object> userContext)
: base(method, target, parameters, userContext)
{
Cancelled = cancelled;
Exception = exception;
}
private PreVerbExecutionContext PreInterception(
object target,
Method method,
ParameterAndValue[] parameters)
{
var preVerbExecutionContext = new PreVerbExecutionContext(method, target, parameters);
// registered interceptors get top priority
//
if (m_registration.RegisteredPreVerbInterceptor != null)
{
m_registration.RegisteredPreVerbInterceptor(preVerbExecutionContext);
}
else
{
// try a defined verb interceptor
//
var preInterceptionMethods = Type.GetMethodsWith<PreVerbExecutionAttribute>();
if (preInterceptionMethods.Any())
{
Debug.Assert(preInterceptionMethods.Count() == 1);
var preInterceptionMethod = preInterceptionMethods.First();
MethodInvoker.Invoke(preInterceptionMethod, target, new[] { preVerbExecutionContext });
}
else
{
// try a defined interceptor type
//
if (Type.HasAttribute<VerbInterception>())
{
var interception = Type.GetAttribute<VerbInterception>();
var interceptor = (IPreVerbInterceptor)Activator.CreateInstance(interception.InterceptorType);
interceptor.BeforeVerbExecution(preVerbExecutionContext);
}
}
}
return preVerbExecutionContext;
}
private void PostInterception(
object target,
Method method,
ParameterAndValue[] parameters,
PreVerbExecutionContext preVerbExecutionContext,
Exception verbException)
{
var postVerbExecutionContext = new PostVerbExecutionContext(
method,
target,
parameters,
preVerbExecutionContext.Cancel,
verbException,
preVerbExecutionContext.UserContext);
// registered interceptors get top priority
//
if (m_registration.RegisteredPostVerbInterceptor != null)
{
m_registration.RegisteredPostVerbInterceptor(postVerbExecutionContext);
}
else
{
var postInterceptionMethods = Type.GetMethodsWith<PostVerbExecutionAttribute>();
// try a defined interceptor type
//
if (postInterceptionMethods.Any())
{
Debug.Assert(postInterceptionMethods.Count() == 1);
var postInterceptionMethod = postInterceptionMethods.First();
MethodInvoker.Invoke(postInterceptionMethod, target, new[] { postVerbExecutionContext });
}
else
{
// try a defined interceptor type
//
if (Type.HasAttribute<VerbInterception>())
{
var interception = Type.GetAttribute<VerbInterception>();
var interceptor = (IPostVerbInterceptor)Activator.CreateInstance(interception.InterceptorType);
interceptor.AfterVerbExecution(postVerbExecutionContext);
}
}
}
}
private int Execute(
object target,
Method method,
ParameterAndValue[] parameters)
{
// pre-interception
//
var preVerbExecutionContext = PreInterception(target, method, parameters);
Exception verbException = null;
try
{
// actual verb execution
//
if (!preVerbExecutionContext.Cancel)
{
// invoke the method with the list of parameters
//
MethodInvoker.Invoke(method.MethodInfo, target, parameters.Select(p => p.Value).ToArray());
}
}
catch (TargetInvocationException tex)
{
PreserveStackTrace(tex.InnerException);
verbException = tex.InnerException;
}
catch (Exception ex)
{
verbException = ex;
}
finally
{
try
{
PostInterception(target, method, parameters, preVerbExecutionContext, verbException);
}
finally
{
if (verbException != null)
{
var rethrow = HandleError(verbException, target);
if (rethrow)
{
throw verbException;
}
}
}
}
return verbException == null ? MultiParser.SuccessCode : MultiParser.ErrorCode;
}