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 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)); } }
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 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; }