public void TestIgnoreExeptionReturnValue()
{
//Create and mock the interceptor.
MockRepository mock = new MockRepository();
IAspect hmock = mock.StrictMock <IAspect>();
Expect.Call(hmock.PreCall(null))
.Return(MethodVoteOptions.Continue)
.IgnoreArguments();
Expect.Call(() => hmock.PostCall(null, null))
.IgnoreArguments();
Expect.Call(() => hmock.OnException(null, null, null))
.Callback(delegate(CastleIInvocation ii, Exception e, AspectExceptionAction action)
{
action.IgnoreException = true;
return(true);
});
mock.ReplayAll();
using (TestContainer container = new TestContainer(@"Concrete\Castle\AOP\TestSuite1\Configs\ConfigSample2.config"))
{
//Set the mock into the kernel.
container.Kernel.RemoveComponent("interceptor");
container.Kernel.AddComponentInstance("interceptor", hmock);
ISomething something = container.Resolve <ISomething>("throwclass");
String retvalue = something.OtherMethod("1", "2");
Assert.That(retvalue, Is.Null); //Default value is returned
}
mock.VerifyAll();
}
public override bool Visible(IAspect aspect)
{
if (_sensors == null)
{
this.SyncChildSensors();
}
if (_sensors.Length == 0)
{
return(false);
}
if (_mustBeVisibleByAll && _sensors.Length > 1)
{
for (int i = 0; i < _sensors.Length; i++)
{
if (!_sensors[i].Visible(aspect))
{
return(false);
}
}
return(true);
}
else
{
for (int i = 0; i < _sensors.Length; i++)
{
if (_sensors[i].Visible(aspect))
{
return(true);
}
}
}
return(false);
}
public void TestOverrideReturnValue()
{
//Create and mock the interceptor.
MockRepository mock = new MockRepository();
IAspect hmock = mock.StrictMock <IAspect>();
Expect.Call(hmock.PreCall(null))
.Return(MethodVoteOptions.Continue)
.IgnoreArguments();
hmock.PostCall(null, null);
LastCall.Callback(delegate(CastleIInvocation ii, AspectReturnValue retval)
{
retval.WrappedReturnValue = "1234567890";
return(retval.Original.Equals("12"));
});
mock.ReplayAll();
using (TestContainer container = new TestContainer(@"Concrete\Castle\AOP\TestSuite1\Configs\ConfigSample2.config"))
{
//Set the mock into the kernel.
container.Kernel.RemoveComponent("interceptor");
container.Kernel.AddComponentInstance("interceptor", hmock);
ISomething something = container.Resolve <ISomething>();
String retvalue = something.OtherMethod("1", "2");
Assert.That(retvalue, Is.EqualTo("1234567890"));
}
mock.VerifyAll();
}
public override bool Visible(IAspect aspect)
{
var colAspect = aspect as ColliderAspect;
if (colAspect == null || colAspect.Collider == null)
{
return(false);
}
if (_radius > 0f)
{
var c = colAspect.Collider;
var hits = this.GetAllHits();
foreach (var h in hits)
{
if (h.collider == c)
{
return(true);
}
}
return(false);
}
else
{
var t = this.transform;
var ray = new Ray(t.position, t.GetAxis(_axis));
RaycastHit hit;
return(colAspect.Collider.Raycast(ray, out hit, _distance));
}
}
internal PropertyInterceptionAspectsDefinition(IAspect aspect, Type aspectDeclaringType, PropertyInfo property, MemberInfo target)
{
Aspect = aspect;
Target = target;
Member = property;
AspectDeclaringType = aspectDeclaringType;
}
internal EventInterceptionAspectDefinition(IAspect aspect, Type aspectDeclaringType, EventInfo @event, MemberInfo target)
{
Aspect = aspect;
Member = @event;
Target = target;
AspectDeclaringType = aspectDeclaringType;
}
public void TestMultiplePointCut()
{
//Create and mock the interceptor.
MockRepository mock = new MockRepository();
IAspect hmock = mock.CreateMock <IAspect>();
Expect.Call(hmock.PreCall(null))
.Repeat.Twice()
.Return(MethodVoteOptions.Continue)
.IgnoreArguments();
Expect.Call(() => hmock.PostCall(null, null))
.Repeat.Twice()
.IgnoreArguments();
mock.ReplayAll();
using (TestContainer container = new TestContainer(@"Concrete\Castle\AOP\TestSuite1\Configs\ConfigSample3.config"))
{
//Set the mock into the kernel.
container.Kernel.RemoveComponent("interceptor");
container.Kernel.AddComponentInstance("interceptor", hmock);
ISomething something = container.Resolve <ISomething>();
something.AMethod("TEST");
something.OtherMethod("1", "2");
}
mock.VerifyAll();
}
internal PropertyInterceptionAspectsDefinition(IAspect aspect, Type aspectDeclaringType, PropertyInfo property, MemberInfo target)
{
Aspect = aspect;
Target = target;
Member = property;
AspectDeclaringType = aspectDeclaringType;
}
internal static bool IsMethodLevelAspect(this IAspect aspect)
{
var type = aspect.GetType();
return(typeof(OnMethodBoundaryAspectAttribute).IsAssignableFrom(type) ||
typeof(MethodInterceptionAspectAttribute).IsAssignableFrom(type));
}
public override bool Visible(IAspect aspect)
{
var vaspect = aspect as VisualAspect;
if (vaspect == null)
{
return(false);
}
if (!vaspect.isActiveAndEnabled)
{
return(false);
}
if (_aspectLayerMask != -1 && !_aspectLayerMask.Intersects(aspect.gameObject))
{
return(false);
}
if (!_aspectTagMask.Intersects(vaspect))
{
return(false);
}
if (!_canDetectSelf && vaspect.entityRoot == this.entityRoot)
{
return(false);
}
return(this.TestVisibility(vaspect));
}
public void SignalExitSiren(IAspect aspect)
{
var audible = aspect as AudibleAspect;
if (object.ReferenceEquals(audible, null) || _activeSirens == null || !_activeSirens.Contains(audible))
{
return;
}
_activeSirens.Remove(audible);
if (_activeSirens.Count == 0)
{
this.OnSensorSleep();
}
if (_signalEntity && !object.ReferenceEquals(_entity, null))
{
Messaging.Broadcast <IAudibleSirenResponder>(_entity.gameObject, (o) => o.OnSoundExit(aspect));
}
else
{
Messaging.Execute <IAudibleSirenResponder>(this.gameObject, (o) => o.OnSoundExit(aspect));
}
}
internal EventInterceptionAspectDefinition(IAspect aspect, Type aspectDeclaringType, EventInfo @event, MemberInfo target)
{
Aspect = aspect;
Member = @event;
Target = target;
AspectDeclaringType = aspectDeclaringType;
}
public void TestBasicInterceptionExceptionThrow()
{
//Create and mock the interceptor.
MockRepository mock = new MockRepository();
IAspect hmock = mock.CreateMock <IAspect>();
hmock.PreCall(null);
LastCall.Return(MethodVoteOptions.Continue)
.IgnoreArguments();
hmock.OnException(null, null, null);
LastCall.Constraints(
new Rhino.Mocks.Constraints.Anything(),
Rhino.Mocks.Constraints.Is.TypeOf(typeof(NullReferenceException)),
Rhino.Mocks.Constraints.Is.Anything());
mock.ReplayAll();
using (TestContainer container = new TestContainer(@"Concrete\Castle\AOP\TestSuite1\Configs\ConfigSample1.config")) {
container.Kernel.RemoveComponent("interceptor");
container.Kernel.AddComponentInstance("interceptor", hmock);
try {
container.Resolve <ISomething>().OtherMethod(null, null);
Assert.Fail("If reach here exception was not thrown");
}
catch (Exception) {
}
}
mock.VerifyAll();
}
/// <summary>
/// Initializes a new instance of the <see cref="BehaviorSettings" /> class.
/// </summary>
/// <param name="defaultInvoke">The default invocation behavior.</param>
public BehaviorSettings(IAspect defaultInvoke)
{
Guard.NotNull(() => defaultInvoke, defaultInvoke);
this.Before = new List<IAspect>();
this.Invoke = new List<IAspect> { defaultInvoke };
this.After = new List<IAspect>();
}
internal AbstractAspectDefinition(IAspect aspect, Type aspectDeclaringType, MemberInfo member)
{
Aspect = aspect;
Member = member;
AspectDeclaringType = aspectDeclaringType;
advices = new AdviceDefinitionCollection();
BulidAdvices();
}
internal static bool IsPropertyLevelAspect(this IAspect aspect)
{
var type = aspect.GetType();
return(typeof(PropertyInterceptionAspectAttribute).IsAssignableFrom(type) ||
typeof(GetPropertyInterceptionAspect).IsAssignableFrom(type) ||
typeof(SetPropertyInterceptionAspect).IsAssignableFrom(type));
}
/// <inheritdoc/>
public void AddAspect(string aspectName, IAspect aspect, IReadOnlyDictionary <JoinPoint, int> sequenceDict)
{
if (plannerBuilder == null)
{
throw new InvalidOperationException("The weaver can't accept aspect build any more.");
}
plannerBuilder.AddAspect(aspectName, aspect, sequenceDict);
}
public static T GetComponent <T>(this IAspect aspect) where T : class, IComponent
{
if (!aspect.Components.ContainsKey(typeof(T)))
{
throw new InvalidOperationException("Component type " + typeof(T).Name + "not found.");
}
return(aspect.Components[typeof(T)] as T);
}
/// <summary>
/// links an aspect to all methods of a certain type
/// </summary>
/// <param name="aspect">aspect to link</param>
/// <param name="iface">iface defining methods to link aspect to</param>
public void Add(IAspect aspect, Type iface)
{
MethodInfo[] methods = iface.GetMethods();
foreach (MethodInfo m in methods)
{
Add(aspect, m);
}
}
/// <summary>
/// Adds a new Warning message.
/// </summary>
/// <param name="aspect">The aspect writing the Warning message</param>
/// <param name="code">The 'code' of this specific message</param>
/// <param name="message">The message</param>
/// <param name="location">The location where the aspect applies to. Will show full signature.</param>
public static void RaiseWarning(this IAspect aspect, int code, string message, MethodBase location)
{
if (aspect == null || message == null)
{
return;
}
Message.Write(SeverityType.Warning, aspect.GetType().Name + "[" + code + "]",
location != null ? "[{0}] {1}".F(location.AsSignature(true), message) : "{0}".F(message));
}
/// <summary>
/// Initializes a new instance of the <see cref="BehaviorSettings" /> class.
/// </summary>
/// <param name="defaultInvoke">The default invocation behavior.</param>
public BehaviorSettings(IAspect defaultInvoke)
{
Guard.NotNull(() => defaultInvoke, defaultInvoke);
this.Before = new List <IAspect>();
this.Invoke = new List <IAspect> {
defaultInvoke
};
this.After = new List <IAspect>();
}
public T Create(IServiceCollection services, T service, IAspect aspect)
{
aspect.OnCreate(services.GetServiceType(service.GetType()));
var proxy = Create <T, AspectProxy <T> >();
(proxy as AspectProxy <T>)._service = service;
(proxy as AspectProxy <T>)._aspect = aspect;
return(proxy);
}
public static void ValidatePropertyAspect(IAspect aspect, PropertyInfo contractProperty, PropertyInfo implementationProperty)
{
MethodInfo[] overridenMethods = null;
var propertyName = contractProperty.Name;
if (contractProperty.Equals(implementationProperty))
{
return;
}
if ((contractProperty.CanRead != implementationProperty.CanRead ||
contractProperty.CanWrite != implementationProperty.CanWrite) &&
implementationProperty.DeclaringType.IsInterface)
{
var contractDeclaringType = contractProperty.DeclaringType;
var implementationDeclaringType = contractProperty.DeclaringType;
throw new PropertyAccessorsMismatchException(CoreResources.PropertiesAccessorsMismatach.Fmt(propertyName, contractDeclaringType.FullName, implementationDeclaringType.FullName));
}
if (!typeof(IPropertyInterceptionAspect).IsAssignableFrom(aspect.AspectType))
{
var argumentException = new ArgumentException(Resources.PropertyInterceptionAspectAttributeErrorInitialization, "aspectType");
throw new AspectAnnotationException(argumentException);
}
overridenMethods = aspect.AspectType.GetOverridenMethods().ToArray(method => method.Name.Equals("OnGetValue") || method.Name.Equals("OnSetValue"));
if (overridenMethods.Length == 0)
{
throw new AdviceNotFoundException(aspect.GetType());
}
overridenMethods.ForEach(overridenMethod => {
Type argumentsType = null;
Type[] genericArguments = null;
var aspectParameters = overridenMethod.GetParameters();
var aspectMethodIsFunction = overridenMethod.IsFunction();
if (aspectParameters.Length != 1 || aspectMethodIsFunction)
{
throw new AspectTypeMismatchException(Resources.AspectPropertyParameterMismatach.Fmt(propertyName));
}
argumentsType = aspectParameters[0].ParameterType;
genericArguments = argumentsType.GetGenericArguments();
if (!ValidateTypesAreEqual(contractProperty.PropertyType, genericArguments.FirstOrDefault()))
{
throw new AspectTypeMismatchException(Resources.AspectPropertyParameterMismatach.Fmt(propertyName));
}
});
}
public void SignalExitSiren(IAspect aspect)
{
if (_signalEntity && !object.ReferenceEquals(_entity, null))
{
Messaging.Broadcast <IAudibleSirenResponder>(_entity.gameObject, (o) => o.OnSoundExit(aspect));
}
else
{
Messaging.Execute <IAudibleSirenResponder>(this.gameObject, (o) => o.OnSoundExit(aspect));
}
}
public override bool Visible(IAspect aspect)
{
var colAspect = aspect as ColliderAspect;
if (colAspect == null)
{
return(false);
}
return(_intersectingColliders.Contains(colAspect.Collider));
}
protected void OnSensedAspect(IAspect aspect)
{
var d = this.SensedAspect;
if (d != null)
{
var ev = TempEventArgs.Create(aspect);
d(this, ev);
TempEventArgs.Release(ev);
}
}
private void AddAspectClaims(string aspectName, IContextMap contextMap, IDictionary <string, object> claims)
{
IAspect aspect = contextMap.Get(aspectName);
foreach (string propertyName in aspect.KeySet)
{
string claimName = $"{aspectName}.{propertyName}";
object claimValue = aspect.Get(propertyName);
claims.Add(claimName, claimValue);
}
}
/// <summary>
/// sets an aspect to be called instead of a certain method
/// </summary>
/// <param name="aspect">aspect with implementation</param>
/// <param name="iface">interface defining methods to be replaced</param>
/// <returns>true if aspect was set for all methods; false if for at least one method another aspect was already set</returns>
public bool SetInstead(IAspect aspect, Type iface)
{
MethodInfo[] methods = iface.GetMethods();
bool ret = true;
foreach (MethodInfo m in methods)
{
ret &= SetInstead(aspect, m);
}
return(ret);
}
public bool IsMatched(IAspect aspect)
{
if (aspect != null && AspectPathPatternMatcher != null)
{
IContext context = aspect.Context;
return(context != null &&
ContextPathPatternMatcher.IsMatched(context.Path) &&
AspectPathPatternMatcher.IsMatched(aspect.Path));
}
return(false);
}
/// <summary>
/// sets an aspect to be called instead of a certain method
/// </summary>
/// <param name="aspect">aspect with implementation</param>
/// <param name="method">method to replace</param>
/// <returns>true if aspect was set; false if there was already another one set</returns>
public bool SetInstead(IAspect aspect, MethodBase method)
{
string key = method.ToString();
if (insteadTable.Contains(key))
{
return(false);
}
insteadTable[key] = aspect;
return(true);
}
/// <summary>
/// Adds a new Error message.
/// </summary>
/// <param name="aspect">The aspect writing the Error message</param>
/// <param name="code">The 'code' of this specific message</param>
/// <param name="message">The message</param>
/// <param name="location">Where was the aspect applied on, can be null</param>
/// <returns>Always returns false</returns>
public static bool RaiseError(this IAspect aspect, int code, string message, string location)
{
if (aspect == null || message == null)
{
return(false);
}
Message.Write(SeverityType.Error, aspect.GetType().Name + "[" + code + "]",
location != null ? "[{0}] {1}".F(location, message) : "{0}".F(message));
return(false);
}
public AspectConfiguration AddAspect(IAspect aspect)
{
if (aspect is IBeforeAdvice before)
{
beforeAdvices.Add(before);
}
if (aspect is IAfterAdvice after)
{
afterAdvices.Insert(0, after);
}
return(this);
}
public static void ValidateAspect(IAspect aspect, MemberInfo memberInfo)
{
if (aspect.IsMethodLevelAspect())
{
if (memberInfo.MemberType != MemberTypes.Method)
{
throw new AspectAnnotationException(Resources.FunctionAspectMismatch);
}
AspectTypeMethodValidator.ValidateMethodAspect(aspect, memberInfo as MethodInfo);
}
}
public void Visit(MethodInfo method, IAspect aspect, AspectMap aspectMap)
{
AspectTypeValidator.ValidateMethodAspect(aspect, aspectMap);
}
public void Visit(PropertyInfo property, IAspect aspect, AspectMap aspectMap)
{
AspectTypeValidator.ValidatePropertyAspect(property, aspect, aspectMap);
}
public void Visit(EventInfo @event, IAspect aspect, AspectMap aspectMap)
{
AspectTypeValidator.ValidateEventAspect(aspect, aspectMap);
}
public MethodInterceptor(object service, IAspect aspect)
{
_service = service;
_aspect = aspect;
Console.WriteLine("Wiring {0} on {1}", aspect.GetType(), service.GetType());
}
public static void ValidateEventAspect(IAspect aspect, EventInfo @event)
{
var comparedTypes = Type.EmptyTypes;
var invokeMethod = @event.GetInvokeMethod();
var methodIsFunction = invokeMethod.IsFunction();
var methodParameters = invokeMethod.GetParameters();
var overridenMethods = aspect.AspectType
.GetOverridenMethods()
.ToArray(overridenMethod => {
return overridenMethod.Name.Equals("OnAddHandler") ||
overridenMethod.Name.Equals("OnInvokeHandler") ||
overridenMethod.Name.Equals("OnRemoveHandler");
});
if (!typeof(IEventInterceptionAspect).IsAssignableFrom(aspect.AspectType)) {
var argumentException = new ArgumentException(Resources.EventInterceptionAspectAttributeErrorInitialization, "aspectType");
throw new AspectAnnotationException(argumentException);
}
if (overridenMethods.Length == 0) {
throw new AdviceNotFoundException(aspect.GetType());
}
overridenMethods.ForEach(overridenMethod => {
Type argumentsType = null;
var eventName = @event.Name;
Type[] genericArguments = null;
var aspectParameters = overridenMethod.GetParameters();
var aspectMethodIsFunction = overridenMethod.IsFunction();
if (aspectParameters.Length != 1 || aspectMethodIsFunction) {
throw new AspectTypeMismatchException(Resources.AspectEventParametersMismatach.Fmt(eventName));
}
argumentsType = aspectParameters[0].ParameterType;
genericArguments = argumentsType.GetGenericArguments();
if (methodIsFunction) {
var argumentsLength = 0;
Type aspectReturnType = null;
if (typeof(IEventActionInterceptionArgs).IsAssignableFrom(argumentsType)) {
throw new AspectAnnotationException(Resources.EventActionInterceptionAspcetMismatch);
}
if (genericArguments.Length == 0) {
throw new AspectTypeMismatchException(Resources.AspectReturnTypeMismatch.Fmt(eventName));
}
argumentsLength = genericArguments.Length - 1;
aspectReturnType = genericArguments[argumentsLength];
if (genericArguments.Length > 1) {
comparedTypes = genericArguments.Take(argumentsLength)
.ToArray();
}
if (!ValidateTypesAreEqual(invokeMethod.ReturnType, aspectReturnType)) {
throw new AspectTypeMismatchException(Resources.AspectReturnTypeMismatch.Fmt(eventName));
}
}
else {
comparedTypes = genericArguments;
if (typeof(IEventFunctionInterceptionArgs).IsAssignableFrom(argumentsType)) {
throw new AspectAnnotationException(Resources.EventActionInterceptionAspcetMismatch);
}
}
if (!ValidateParameters(methodParameters, comparedTypes)) {
throw new AspectTypeMismatchException(Resources.AspectEventParametersMismatach.Fmt(eventName));
}
});
}
public static void ValidatePropertyAspect(IAspect aspect, PropertyInfo contractProperty, PropertyInfo implementationProperty)
{
MethodInfo[] overridenMethods = null;
var propertyName = contractProperty.Name;
if (contractProperty.Equals(implementationProperty)) {
return;
}
if ((contractProperty.CanRead != implementationProperty.CanRead ||
contractProperty.CanWrite != implementationProperty.CanWrite) &&
implementationProperty.DeclaringType.IsInterface) {
var contractDeclaringType = contractProperty.DeclaringType;
var implementationDeclaringType = contractProperty.DeclaringType;
throw new PropertyAccessorsMismatchException(CoreResources.PropertiesAccessorsMismatach.Fmt(propertyName, contractDeclaringType.FullName, implementationDeclaringType.FullName));
}
if (!typeof(IPropertyInterceptionAspect).IsAssignableFrom(aspect.AspectType)) {
var argumentException = new ArgumentException(Resources.PropertyInterceptionAspectAttributeErrorInitialization, "aspectType");
throw new AspectAnnotationException(argumentException);
}
overridenMethods = aspect.AspectType.GetOverridenMethods().ToArray(method => method.Name.Equals("OnGetValue") || method.Name.Equals("OnSetValue"));
if (overridenMethods.Length == 0) {
throw new AdviceNotFoundException(aspect.GetType());
}
overridenMethods.ForEach(overridenMethod => {
Type argumentsType = null;
Type[] genericArguments = null;
var aspectParameters = overridenMethod.GetParameters();
var aspectMethodIsFunction = overridenMethod.IsFunction();
if (aspectParameters.Length != 1 || aspectMethodIsFunction) {
throw new AspectTypeMismatchException(Resources.AspectPropertyParameterMismatach.Fmt(propertyName));
}
argumentsType = aspectParameters[0].ParameterType;
genericArguments = argumentsType.GetGenericArguments();
if (!ValidateTypesAreEqual(contractProperty.PropertyType, genericArguments.FirstOrDefault())) {
throw new AspectTypeMismatchException(Resources.AspectPropertyParameterMismatach.Fmt(propertyName));
}
});
}
public static void ValidateEventAspect(IAspect aspect, AspectMap aspectMap)
{
ValidateEventAspect(aspect, (EventInfo)aspectMap.Target);
}
public static void ValidatePropertyAspect(PropertyInfo target, IAspect aspect, AspectMap aspectMap)
{
ValidatePropertyAspect(aspect, (PropertyInfo)aspectMap.Contract, target);
}
public static void ValidateMethodAspect(IAspect aspect, MethodInfo method)
{
var methodName = method.Name;
var comparedTypes = Type.EmptyTypes;
MethodInfo[] overridenMethods = null;
var methodIsFunction = method.IsFunction();
var methodParameters = method.GetParameters();
if (aspect.Is<OnMethodBoundaryAspectAttribute>()) {
if (!typeof(IOnMethodBoundaryAspect).IsAssignableFrom(aspect.AspectType)) {
var argumentException = new ArgumentException(Resources.OnMethodBoundaryAspectAttributeErrorInitialization, "aspectType");
throw new AspectAnnotationException(argumentException);
}
overridenMethods = aspect.AspectType.GetOverridenMethods()
.ToArray(overridenMethod => {
return overridenMethod.Name.Equals("OnExit") ||
overridenMethod.Name.Equals("OnEntry") ||
overridenMethod.Name.Equals("OnSuccess") ||
overridenMethod.Name.Equals("OnException");
});
}
else if (aspect.Is<MethodInterceptionAspectAttribute>()) {
if (!typeof(IMethodInterceptionAspect).IsAssignableFrom(aspect.AspectType)) {
var argumentException = new ArgumentException(Resources.MethodInterceptionAspectAttributeErrorInitialization, "aspectType");
throw new AspectAnnotationException(argumentException);
}
overridenMethods = aspect.AspectType.GetOverridenMethods()
.ToArray(overridenMethod => overridenMethod.Name.Equals("OnInvoke"));
}
if (overridenMethods.Length == 0) {
throw new AdviceNotFoundException(aspect.GetType());
}
overridenMethods.ForEach(overridenMethod => {
Type argumentsType = null;
Type[] genericArguments = null;
var aspectParameters = overridenMethod.GetParameters();
var aspectMethodIsFunction = overridenMethod.IsFunction();
if (aspectParameters.Length != 1 || aspectMethodIsFunction) {
throw new AspectTypeMismatchException(Resources.AspectMethodParametersMismatach.Fmt(methodName));
}
argumentsType = aspectParameters[0].ParameterType;
genericArguments = argumentsType.GetGenericArguments();
if (methodIsFunction) {
var argumentsLength = 0;
Type aspectReturnType = null;
if (typeof(IActionExecutionArgs).IsAssignableFrom(argumentsType) || typeof(IActionInterceptionArgs).IsAssignableFrom(argumentsType)) {
throw new AspectAnnotationException(Resources.OnActionBoundaryAspcetMismatch);
}
if (genericArguments.Length == 0) {
throw new AspectTypeMismatchException(Resources.AspectReturnTypeMismatch.Fmt(methodName));
}
argumentsLength = genericArguments.Length - 1;
aspectReturnType = genericArguments[argumentsLength];
if (genericArguments.Length > 1) {
comparedTypes = genericArguments.Take(argumentsLength)
.ToArray();
}
if (!ValidateTypesAreEqual(method.ReturnType, aspectReturnType)) {
throw new AspectTypeMismatchException(Resources.AspectReturnTypeMismatch.Fmt(methodName));
}
}
else {
comparedTypes = genericArguments;
if (typeof(IFunctionExecutionArgs).IsAssignableFrom(argumentsType) || typeof(IFunctionInterceptionArgs).IsAssignableFrom(argumentsType)) {
throw new AspectAnnotationException(Resources.OnFunctionBoundaryAspcetMismatch);
}
}
if (!ValidateParameters(methodParameters, comparedTypes)) {
throw new AspectTypeMismatchException(Resources.AspectMethodParametersMismatach.Fmt(methodName));
}
});
}
public static void ValidateMethodAspect(IAspect aspect, AspectMap aspectMap)
{
ValidateMethodAspect(aspect, aspectMap.Method);
}
internal AbstractEventFragmentInterceptionAspectDefinition(IEventExpressionBuilder eventBuilder, IAspect aspect, Type aspectDeclaringType, EventInfo @event, MemberInfo target)
: base(aspect, aspectDeclaringType, @event, target)
{
EventBuilder = eventBuilder;
}
public static void Accept(this MemberInfo member, AspectValidatorVisitor visitor, IAspect aspect, AspectMap aspectMap)
{
visitor.Visit((dynamic)member, aspect, aspectMap);
}
public static void ValidateAspect(IAspect aspect, AspectMap aspectMap)
{
aspectMap.Aspects.ForEach(a => a.Target.Accept(visitor, aspect, aspectMap));
}
internal AbstractPropertyFragmentInterceptionAspectDefinition(IPropertyExpressionBuilder propertyBuilder, IAspect aspect, Type aspectDeclaringType, PropertyInfo property, MemberInfo target)
: base(aspect, aspectDeclaringType, property, target)
{
PropertyBuilder = propertyBuilder;
}
