Ejemplo n.º 1
1
 /// <summary>
 /// Injects the introduced field.
 /// </summary>
 /// <param name="advice">The advice.</param>
 /// <param name="adviceMemberInfo">The member information.</param>
 /// <param name="advisedType">Type of the advised.</param>
 /// <exception cref="System.InvalidOperationException">Internal error, can not find matching introduced field</exception>
 private static void InjectIntroducedField(IAdvice advice, MemberInfo adviceMemberInfo, Type advisedType)
 {
     adviceMemberInfo.SetValue(advice, Activator.CreateInstance(adviceMemberInfo.GetMemberType(), advice, adviceMemberInfo));
 }
Ejemplo n.º 2
0
        public AppliedAdvice(IAdvice advice, IPointcut pointcut)
        {
            Guard.ArgumentIsNotNull(() => advice, () => pointcut);

            Advice    = advice;
            _pointcut = pointcut;
        }
        /// <summary>
        /// Returns an <see cref="Oragon.Spring.Aop.IAdvisor"/> wrapping the supplied
        /// <paramref name="advice"/>.
        /// </summary>
        /// <param name="advice">
        /// The object that should be an advice, such as
        /// <see cref="Oragon.Spring.Aop.IBeforeAdvice"/> or
        /// <see cref="Oragon.Spring.Aop.IThrowsAdvice"/>.
        /// </param>
        /// <returns>
        /// An <see cref="Oragon.Spring.Aop.IAdvisor"/> wrapping the supplied
        /// <paramref name="advice"/>. Never returns <cref lang="null"/>. If
        /// the <paramref name="advice"/> parameter is an
        /// <see cref="Oragon.Spring.Aop.IAdvisor"/>, it will simply be returned.
        /// </returns>
        /// <exception cref="UnknownAdviceTypeException">
        /// If no registered
        /// <see cref="Oragon.Spring.Aop.Framework.Adapter.IAdvisorAdapter"/> can wrap
        /// the supplied <paramref name="advice"/>.
        /// </exception>
        public virtual IAdvisor Wrap(object advice)
        {
            if (advice is IAdvisor)
            {
                return((IAdvisor)advice);
            }
            if (!(advice is IAdvice))
            {
                throw new UnknownAdviceTypeException(advice);
            }
            IAdvice adviceObject = (IAdvice)advice;

            if (adviceObject is IInterceptor)
            {
                // so well-known it doesn't even need an adapter...
                return(new DefaultPointcutAdvisor(adviceObject));
            }
            foreach (IAdvisorAdapter adapter in this.adapters)
            {
                // check that it is supported...
                if (adapter.SupportsAdvice(adviceObject))
                {
                    return(new DefaultPointcutAdvisor(adviceObject));
                }
            }
            throw new UnknownAdviceTypeException(advice);
        }
Ejemplo n.º 4
0
        public async Task HandleUseAbilityAdvice(Unit unit, IAdvice advice)
        {
            var targetAndAbility = advice.ContextAccessor.GetContext() as AbilityWithTarget;

            if (targetAndAbility == null)
            {
                return;
            }

            var ability = unit.GetAbility(targetAndAbility.AbilityId);

            if (ability == null)
            {
                return;
            }

            var target = Level.GetUnitById(targetAndAbility.TargetUnitId);

            if (target == null)
            {
                return;
            }

            await UseAbilityOnTargetHandler.ExecutePhase(unit, target, ability);
        }
Ejemplo n.º 5
0
 /// <summary>
 /// Gets priority level from the specified advice.
 /// </summary>
 /// <param name="advice">The advice.</param>
 /// <returns></returns>
 public static int GetLevel(IAdvice advice)
 {
     var priorityAttribute = advice.GetType().GetCustomAttributes(typeof (Priority), true).Cast<Priority>().SingleOrDefault();
     if (priorityAttribute != null)
         return priorityAttribute.Level;
     return DefaultLevel;
 }
Ejemplo n.º 6
0
        public async Task HandleMovementFirstAdvice(Unit unit, IAdvice movementAdvice, IAdvice[] allAdvice)
        {
            await HandleMovementAdvice(unit, movementAdvice);

            var attackOrHealAdvice = allAdvice.FirstOrDefault(x =>
                                                              x.AdviceId == AdviceVariableTypes.HealSelf ||
                                                              x.AdviceId == AdviceVariableTypes.HealOther ||
                                                              x.AdviceId == AdviceVariableTypes.UseAbility);

            if (attackOrHealAdvice == null)
            {
                return;
            }

            if (attackOrHealAdvice.AdviceId == AdviceVariableTypes.HealSelf)
            {
                await HandleUseAbilityAdvice(unit, attackOrHealAdvice);
            }
            else if (attackOrHealAdvice.AdviceId == AdviceVariableTypes.HealOther)
            {
                var healTarget  = attackOrHealAdvice.ContextAccessor.GetContext() as Unit;
                var healAbility = unit.ActiveAbilities.First(x => x.DamageType == DamageTypes.LightDamage);
                await UseAbilityOnTargetHandler.ExecuteIfInRange(unit, healTarget, healAbility);
            }
            else
            {
                var targetAndAbility = attackOrHealAdvice.ContextAccessor.GetContext() as AbilityWithTarget;
                var targetUnit       = Level.GetUnitById(targetAndAbility.TargetUnitId);
                var ability          = unit.GetAbility(targetAndAbility.AbilityId);
                await UseAbilityOnTargetHandler.ExecuteIfInRange(unit, targetUnit, ability);
            }
        }
Ejemplo n.º 7
0
        /*----------------------------------------------------------------------------------------*/
        /// <summary>
        /// Begins a static interception definition.
        /// </summary>
        /// <param name="method">The method to intercept.</param>
        /// <returns>An advice builder.</returns>
        protected virtual TAdviceBuilder DoIntercept(MethodInfo method)
        {
            IAdvice advice = Kernel.Components.AdviceFactory.Create(method);

            Kernel.Components.AdviceRegistry.Register(advice);

            return(CreateAdviceBuilder(advice));
        }
Ejemplo n.º 8
0
        /*----------------------------------------------------------------------------------------*/
        /// <summary>
        /// Begins a dynamic interception definition.
        /// </summary>
        /// <param name="condition">The condition to evaluate to determine if a request should be intercepted.</param>
        /// <returns>An advice builder.</returns>
        protected virtual TAdviceBuilder DoIntercept(ICondition <IRequest> condition)
        {
            IAdvice advice = Kernel.Components.AdviceFactory.Create(condition);

            Kernel.Components.AdviceRegistry.Register(advice);

            return(CreateAdviceBuilder(advice));
        }
Ejemplo n.º 9
0
        /// <summary>
        /// Begins a dynamic interception definition.
        /// </summary>
        /// <param name="kernel"></param>
        /// <param name="condition">The condition to evaluate to determine if a request should be intercepted.</param>
        /// <returns>An advice builder.</returns>
        private static IAdviceTargetSyntax DoIntercept(IKernel kernel, Predicate <IContext> condition)
        {
            IAdvice advice = kernel.Components.Get <IAdviceFactory>().Create(condition);

            kernel.Components.Get <IAdviceRegistry>().Register(advice);

            return(CreateAdviceBuilder(advice));
        }
Ejemplo n.º 10
0
        /// <summary>
        /// Creates a proxy around the given interface, and injects the given advice at all levels.
        /// </summary>
        /// <param name="advice">The advice.</param>
        /// <param name="interfaceType">Type of the interface.</param>
        /// <param name="referenceAssembly">The reference assembly.</param>
        /// <param name="referenceType">Type of the reference.</param>
        /// <returns>An object implementing the requested interface</returns>
        public static object Handle(this IAdvice advice, Type interfaceType, Assembly referenceAssembly = null, Type referenceType = null)
        {
            var implementationType = GetImplementationType(interfaceType, referenceAssembly, referenceType);
            var implementation     = (AdvisedInterface)Activator.CreateInstance(implementationType);

            implementation.Advice = advice;
            return(implementation);
        }
Ejemplo n.º 11
0
        /// <summary>
        /// Begins a dynamic interception definition.
        /// </summary>
        /// <param name="kernel">The kernel.</param>
        /// <param name="condition">The condition to evaluate to determine if a request should be intercepted.</param>
        /// <param name="methodPredicate">The condition to evaluate if a method call should be intercepted.</param>
        /// <returns>An advice builder.</returns>
        public static IAdviceTargetSyntax Intercept(this IKernel kernel, Predicate <IContext> condition, Predicate <MethodInfo> methodPredicate)
        {
            IAdvice advice = kernel.Components.Get <IAdviceFactory>().Create(condition, methodPredicate);

            kernel.Components.Get <IAdviceRegistry>().Register(advice);

            return(CreateAdviceBuilder(advice));
        }
Ejemplo n.º 12
0
        /// <summary>
        /// Creates a proxy around the given interface, and injects the given advice at all levels.
        /// </summary>
        /// <param name="advice">The advice.</param>
        /// <param name="interfaceType">Type of the interface.</param>
        /// <returns></returns>
        private static object Handle(this IAdvice advice, Type interfaceType)
        {
            var implementationType = GetImplementationType(interfaceType);
            var implementation     = (AdvisedInterface)Activator.CreateInstance(implementationType);

            implementation.Advice = advice;
            return(implementation);
        }
Ejemplo n.º 13
0
 /// <summary>
 /// Injects the introduced fields to advice.
 /// Allows null advices (and does nothing)
 /// </summary>
 /// <param name="advice">The advice.</param>
 /// <param name="advisedType">Type of the advised.</param>
 private static void SafeInjectIntroducedFields(IAdvice advice, Type advisedType)
 {
     // shame, but easy here
     if (advice is null)
     {
         return;
     }
     InjectIntroducedFields(advice, advisedType, null);
 }
        /// <summary>
        /// Constructs the interception advice to trigger according to the binding used.
        /// </summary>
        /// <param name="binding">The binding.</param>
        /// <returns>
        ///     An <see cref="IAdviceTargetSyntax"/> instance which allows the attachment of an <see cref="IInterceptor"/>.
        /// </returns>
        private static IAdviceTargetSyntax DoIntercept(IBindingSyntax binding)
        {
            IKernel kernel = binding.Kernel;
            IAdvice advice = kernel.Components.Get <IAdviceFactory>()
                             .Create(context => ReferenceEquals(binding.BindingConfiguration, context.Binding.BindingConfiguration));

            kernel.Components.Get <IAdviceRegistry>().Register(advice);

            return(new AdviceBuilder(advice));
        }
Ejemplo n.º 15
0
        private Type GetNonLazyType(IAdvice advice)
        {
            var type = advice.GetType();

            if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(LazyAdvice <>))
            {
                return(type.GetGenericArguments()[0]);
            }
            return(type);
        }
Ejemplo n.º 16
0
		/*----------------------------------------------------------------------------------------*/
		#region Public Methods
		/// <summary>
		/// Registers the specified advice.
		/// </summary>
		/// <param name="advice">The advice to register.</param>
		public void Register(IAdvice advice)
		{
			if (advice.IsDynamic)
			{
				HasDynamicAdvice = true;
				_cache.Clear();
			}

			_advice.Add(advice);
		}
		/// <summary>
		/// Creates a new instance of the
        /// <see cref="Spring.Transaction.Interceptor.DefaultTransactionAttributeSourceAdvisor"/> class.
		/// </summary>
        public DefaultTransactionAttributeSourceAdvisor(ITransactionAttributeSource transactionAttributeSource, IAdvice advice)
			: base( advice )
		{
            if (transactionAttributeSource == null)
			{
                throw new AopConfigException("Cannot construct a DefaultTransactionAttributeSourceAdvisor if " + 
					"TransactionAttributeSource is null.");
			}
            _transactionAttributeSource = transactionAttributeSource;
		}
Ejemplo n.º 18
0
        /// <summary>
        /// Gets priority level from the specified advice.
        /// </summary>
        /// <param name="advice">The advice.</param>
        /// <returns></returns>
        public static int GetLevel(IAdvice advice)
        {
            var priorityAttribute = advice.GetType().GetCustomAttributes(typeof(PriorityAttribute), true).Cast <PriorityAttribute>().SingleOrDefault();

            if (priorityAttribute != null)
            {
                return(priorityAttribute.Level);
            }
            return(DefaultLevel);
        }
Ejemplo n.º 19
0
        private ITestObject CreateProxy(object target, IAdvice interceptor, bool exposeProxy)
        {
            ProxyFactory pf = new ProxyFactory(target);

            pf.ExposeProxy = exposeProxy;
//            pf.Target = target;
            pf.AddAdvice(interceptor);

            return(pf.GetProxy() as ITestObject);
        }
Ejemplo n.º 20
0
        /*----------------------------------------------------------------------------------------*/
        #region Public Methods
        /// <summary>
        /// Registers the specified advice.
        /// </summary>
        /// <param name="advice">The advice to register.</param>
        public void Register(IAdvice advice)
        {
            if (advice.IsDynamic)
            {
                HasDynamicAdvice = true;
                _cache.Clear();
            }

            _advice.Add(advice);
        }
Ejemplo n.º 21
0
                public IAdvice Create()
                {
                    var _sequence = this.Sequence;
                    var _array    = new IAdvice[_sequence.Length];

                    for (var _index = 0; _index < _sequence.Length; _index++)
                    {
                        _array[_index] = _sequence[_index]();
                    }
                    return(new Advisor.Sequence(_array));
                }
Ejemplo n.º 22
0
        public async Task HandleMovementAdvice(Unit unit, IAdvice advice)
        {
            var bestLocation  = (Vector2)advice.ContextAccessor.GetContext();
            var newDirection  = unit.Position - bestLocation;
            var directionType = newDirection.GetDirection();

            var oldPosition  = unit.Position;
            var oldDirection = unit.FacingDirection;

            unit.Position        = bestLocation;
            unit.FacingDirection = directionType;
            EventSystem.Publish(new UnitMovingEvent(unit, oldPosition, oldDirection));
        }
Ejemplo n.º 23
0
        private ITestObject CreateProxyChain(IAdvice interceptor, bool exposeProxy)
        {
            ITestObject first      = new ChainableTestObject(null);
            ITestObject firstProxy = CreateProxy(first, interceptor, exposeProxy);

            Assert.IsNotNull(firstProxy);

            ITestObject second      = new ChainableTestObject(firstProxy);
            ITestObject secondProxy = CreateProxy(second, interceptor, exposeProxy);

            Assert.IsNotNull(secondProxy);
            return(secondProxy);
        }
        /// <summary>
        /// Registers static interceptors defined by attributes on the specified method.
        /// </summary>
        /// <param name="type">The type whose activation plan is being manipulated.</param>
        /// <param name="method">The method that may be intercepted.</param>
        /// <param name="attributes">The interception attributes that apply.</param>
        protected virtual void RegisterMethodInterceptors(Type type,
                                                          MethodInfo method,
                                                          ICollection <InterceptAttributeBase> attributes)
        {
            foreach (InterceptAttributeBase attribute in attributes)
            {
                IAdvice advice = AdviceFactory.Create(method);

                advice.Callback = attribute.CreateInterceptor;
                advice.Order    = attribute.Order;

                AdviceRegistry.Register(advice);
            }
        }
Ejemplo n.º 25
0
 /// <summary>
 /// Creates a new instance of the
 /// <see cref="Oragon.Spring.Aop.Support.DefaultIntroductionAdvisor"/> class using
 /// the supplied <paramref name="introduction"/>
 /// </summary>
 /// <param name="introduction">The introduction to use.</param>
 /// <param name="interfaces">
 /// The interfaces to introduce.
 /// </param>
 /// <exception cref="System.ArgumentNullException">
 /// If the supplied <paramref name="introduction"/> is <see langword="null"/>.
 /// </exception>
 public DefaultIntroductionAdvisor(IAdvice introduction, Type[] interfaces)
 {
     if (introduction == null)
     {
         throw new ArgumentNullException("introduction", "Introduction cannot be null");
     }
     _introduction = introduction;
     foreach (Type intf in interfaces)
     {
         if (intf != typeof(IAdvice))
         {
             AddInterface(intf);
         }
     }
 }
Ejemplo n.º 26
0
 /// <summary>
 /// Finds the introduced field.
 /// </summary>
 /// <param name="advice">The advice.</param>
 /// <param name="adviceMemberInfo">The advice member information.</param>
 /// <param name="advisedType">Type of the advised.</param>
 /// <returns></returns>
 /// <exception cref="System.InvalidOperationException">Internal error, can not find matching introduced field</exception>
 internal static FieldInfo FindIntroducedField(IAdvice advice, MemberInfo adviceMemberInfo, Type advisedType)
 {
     var introducedFieldType = GetIntroducedType(adviceMemberInfo);
     var adviceType = advice.GetType();
     var introducedFieldName = IntroductionRules.GetName(adviceType.Namespace, adviceType.Name, adviceMemberInfo.Name);
     var linkID = string.Format("{0}:{1}", adviceType.AssemblyQualifiedName, adviceMemberInfo.Name);
     const BindingFlags bindingFlags = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static;
     var introducedField = FindIntroducedFieldByName(advisedType, introducedFieldName, linkID, bindingFlags)
              ?? FindIntroducedFieldByTypeAndAvailability(advisedType, introducedFieldType, adviceMemberInfo.IsStatic(), null, bindingFlags)
              ?? FindIntroducedFieldByTypeAndAvailability(advisedType, introducedFieldType, adviceMemberInfo.IsStatic(), linkID, bindingFlags);
     if (introducedField == null)
         throw new InvalidOperationException("Internal error, can not find matching introduced field");
     var introducedFieldAttribute = introducedField.GetCustomAttribute<IntroducedFieldAttribute>();
     introducedFieldAttribute.LinkID = linkID;
     return introducedField;
 }
Ejemplo n.º 27
0
        /*----------------------------------------------------------------------------------------*/
        /// <summary>
        /// Registers static interceptors defined by attributes on the specified method.
        /// </summary>
        /// <param name="binding">The binding that points at the type whose activation plan is being released.</param>
        /// <param name="type">The type whose activation plan is being manipulated.</param>
        /// <param name="plan">The activation plan that is being manipulated.</param>
        /// <param name="method">The method that may be intercepted.</param>
        /// <param name="attributes">The interception attributes that apply.</param>
        protected virtual void RegisterMethodInterceptors(IBinding binding, Type type, IActivationPlan plan,
                                                          MethodInfo method, ICollection <InterceptAttribute> attributes)
        {
            var factory  = binding.Components.AdviceFactory;
            var registry = binding.Components.AdviceRegistry;

            foreach (InterceptAttribute attribute in attributes)
            {
                IAdvice advice = factory.Create(method);

                advice.Callback = attribute.CreateInterceptor;
                advice.Order    = attribute.Order;

                registry.Register(advice);
            }
        }
Ejemplo n.º 28
0
        /// <summary>
        /// Indicates that instances associated with this binding will be proxied.
        /// Only methods that match the specified predicate will be intercepted.
        /// </summary>
        /// <typeparam name="T">The type associated with this binding.</typeparam>
        /// <param name="bindingSyntax">The binding syntax target.</param>
        /// <param name="methodPredicate">The method predicate that defines if a method shall be intercepted.</param>
        /// <param name="additionalInterfaces">The additional interfaces for the proxy.</param>
        /// <returns>An <see cref="IAdviceTargetSyntax" /> instance which allows the attachment of an <see cref="IInterceptor" />.</returns>
        public static IAdviceTargetSyntax Intercept <T>(this IBindingOnSyntax <T> bindingSyntax, Predicate <MethodInfo> methodPredicate, params Type[] additionalInterfaces)
        {
            IKernel kernel = bindingSyntax.Kernel;

            foreach (var additionalInterface in additionalInterfaces)
            {
                bindingSyntax.BindingConfiguration.Parameters.Add(new AdditionalInterfaceParameter(additionalInterface));
            }

            IAdvice advice = kernel.Components.Get <IAdviceFactory>()
                             .Create(context => ReferenceEquals(bindingSyntax.BindingConfiguration, context.Binding.BindingConfiguration), methodPredicate);

            kernel.Components.Get <IAdviceRegistry>().Register(advice);

            return(new AdviceBuilder(advice));
        }
        /// <summary>
        /// Returns an <see cref="AopAlliance.Intercept.IInterceptor"/> to
        /// allow the use of the supplied <paramref name="advisor"/> in an
        /// interception-based framework.
        /// </summary>
        /// <param name="advisor">The advisor to find an interceptor for.</param>
        /// <returns>
        /// An interceptor to expose this advisor's behaviour.
        /// </returns>
        /// <exception cref="UnknownAdviceTypeException">
        /// If the advisor type is not understood by any registered
        /// <see cref="Oragon.Spring.Aop.Framework.Adapter.IAdvisorAdapter"/>.
        /// </exception>
        public virtual IInterceptor GetInterceptor(IAdvisor advisor)
        {
            IAdvice advice = advisor.Advice;

            if (advice is IInterceptor)
            {
                return((IInterceptor)advice);
            }
            foreach (IAdvisorAdapter adapter in this.adapters)
            {
                if (adapter.SupportsAdvice(advice))
                {
                    return(adapter.GetInterceptor(advisor));
                }
            }
            throw new UnknownAdviceTypeException(advice);
        }
Ejemplo n.º 30
0
        private AopProxyFactory()
        {
            Config = AopProxyConfig.Load();
            if (Config == null)
            {
                Config = new AopProxyConfig();
            }

            TypeMap = new Dictionary <Type, IAdvice>();
            foreach (var advConfig in Config.Advisors)
            {
                Type    pointCutType = AopProxyFactory.LoadType(advConfig.PointCutType);
                Type    adviceType   = AopProxyFactory.LoadType(advConfig.AdviseType);
                IAdvice advice       = Activator.CreateInstance(adviceType) as IAdvice;

                TypeMap[pointCutType] = advice;
            }
        }
Ejemplo n.º 31
0
        public async Task HandleHealOtherAdvice(Unit unit, IAdvice advice)
        {
            var target = advice.ContextAccessor.GetContext() as Unit;

            if (target == null)
            {
                return;
            }

            var ability = unit.ActiveAbilities.FirstOrDefault(x => x.DamageType == DamageTypes.LightDamage);

            if (ability == null)
            {
                return;
            }

            await UseAbilityOnTargetHandler.ExecutePhase(unit, target, ability);
        }
Ejemplo n.º 32
0
        /// <summary>
        /// Injects the introduced fields to advice.
        /// </summary>
        /// <param name="advice">The advice.</param>
        /// <param name="advisedType">Type of the advised.</param>
        private static void InjectIntroducedFields(IAdvice advice, Type advisedType)
        {
            // shame, but easy here
            if (advice == null)
            {
                return;
            }
            const BindingFlags adviceMembersBindingFlags = BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static;

            foreach (var memberInfo in advice.GetType().GetFieldsAndProperties(adviceMembersBindingFlags).Where(IsIntroduction))
            {
                var memberValue = memberInfo.GetValue(advice);
                if (memberValue == null)
                {
                    InjectIntroducedField(advice, memberInfo, advisedType);
                }
            }
        }
Ejemplo n.º 33
0
 /// <summary>
 /// Injects the introduced fields to advice.
 /// </summary>
 /// <param name="advice">The advice.</param>
 /// <param name="advisedType">Type of the advised.</param>
 /// <param name="introducedFields">The introduced fields.</param>
 private static void InjectIntroducedFields(IAdvice advice, Type advisedType, IList <MemberInfo> introducedFields)
 {
     if (introducedFields is null)
     {
         introducedFields = AdviceInfo.GetIntroducedFields(advice);
     }
     if (introducedFields.Count == 0)
     {
         return;
     }
     foreach (var memberInfo in introducedFields)
     {
         var memberValue = memberInfo.GetValue(advice);
         if (memberValue == null)
         {
             InjectIntroducedField(advice, memberInfo, advisedType);
         }
     }
 }
Ejemplo n.º 34
0
        /// <summary>
        /// Finds the introduced field.
        /// </summary>
        /// <param name="advice">The advice.</param>
        /// <param name="adviceMemberInfo">The advice member information.</param>
        /// <param name="advisedType">Type of the advised.</param>
        /// <param name="advisedMemberName">Name of the advised member.</param>
        /// <returns></returns>
        /// <exception cref="InvalidOperationException">Internal error, can not find matching introduced field</exception>
        /// <exception cref="System.InvalidOperationException">Internal error, can not find matching introduced field</exception>
        internal static FieldInfo FindIntroducedField(IAdvice advice, MemberInfo adviceMemberInfo, Type advisedType, string advisedMemberName)
        {
            var introducedFieldType         = GetIntroducedType(adviceMemberInfo);
            var adviceType                  = advice.GetType();
            var introducedFieldName         = IntroductionRules.GetName(adviceType.Namespace, adviceType.Name, advisedMemberName, adviceMemberInfo.Name);
            const BindingFlags bindingFlags = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static;
            var introducedField             = FindIntroducedFieldByName(advisedType, introducedFieldName, introducedFieldName, bindingFlags)
                                              ?? FindIntroducedFieldByTypeAndAvailability(advisedType, introducedFieldType, adviceMemberInfo.IsStatic(), null, bindingFlags)
                                              ?? FindIntroducedFieldByTypeAndAvailability(advisedType, introducedFieldType, adviceMemberInfo.IsStatic(), introducedFieldName, bindingFlags);

            if (introducedField is null)
            {
                throw new InvalidOperationException("Internal error, can not find matching introduced field");
            }
            var introducedFieldAttribute = introducedField.GetAttributes <IntroducedFieldAttribute>().Single();

            introducedFieldAttribute.LinkID = introducedFieldName;
            return(introducedField);
        }
Ejemplo n.º 35
0
        public void InterceptorsAreReturnedInAscendingOrder()
        {
            var module = new InlineModule(m => m.Bind <ObjectWithMethodInterceptor>().ToSelf());

            using (var kernel = new StandardKernel(module))
            {
                kernel.Components.Connect <IProxyFactory>(new DummyProxyFactory());

                var factory  = kernel.Components.AdviceFactory;
                var registry = kernel.Components.AdviceRegistry;

                IAdvice advice = factory.Create(new PredicateCondition <IRequest>(r => r.Method.Name.Equals("Foo")));

                advice.Callback = r => r.Kernel.Get <FlagInterceptor>();
                advice.Order    = -1;

                registry.Register(advice);

                var obj = kernel.Get <ObjectWithMethodInterceptor>();

                IContext context = kernel.Components.ContextFactory.Create(typeof(ObjectWithMethodInterceptor));

                IRequest request = new StandardRequest(
                    context,
                    obj,
                    typeof(ObjectWithMethodInterceptor).GetMethod("Foo"),
                    new object[0],
                    Type.EmptyTypes
                    );

                ICollection <IInterceptor> interceptors = registry.GetInterceptors(request);
                Assert.That(interceptors.Count, Is.EqualTo(2));

                IEnumerator <IInterceptor> enumerator = interceptors.GetEnumerator();

                enumerator.MoveNext();
                Assert.That(enumerator.Current, Is.InstanceOfType(typeof(FlagInterceptor)));

                enumerator.MoveNext();
                Assert.That(enumerator.Current, Is.InstanceOfType(typeof(CountInterceptor)));
            }
        }
Ejemplo n.º 36
0
 /// <summary>
 /// Injects the introduced fields to advice.
 /// </summary>
 /// <param name="advice">The advice.</param>
 /// <param name="advisedType">Type of the advised.</param>
 private static void InjectIntroducedFields(IAdvice advice, Type advisedType)
 {
     // shame, but easy here
     if (advice == null)
         return;
     const BindingFlags adviceMembersBindingFlags = BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static;
     foreach (var memberInfo in advice.GetType().GetFieldsAndProperties(adviceMembersBindingFlags).Where(IsIntroduction))
     {
         var memberValue = memberInfo.GetValue(advice);
         if (memberValue == null)
             InjectIntroducedField(advice, memberInfo, advisedType);
     }
 }
Ejemplo n.º 37
0
 /// <summary>
 /// Adds the supplied <paramref name="advice"/> to the end (or tail)
 /// of the advice (interceptor) chain.
 /// </summary>
 /// <param name="advice">
 /// The <see cref="AopAlliance.Aop.IAdvice"/> to be added.
 /// </param>
 /// <seealso cref="Spring.Aop.Support.DefaultPointcutAdvisor"/>
 /// <seealso cref="Spring.Aop.Framework.IAdvised.AddAdvice(int,IAdvice)"/>
 public void AddAdvice(IAdvice advice)
 {
     //int position = this._advisors != null ? this._advisors.Count : 0;
     AddAdvice(-1, advice);
 }
		/// <summary>
		/// Creates a new instance of the
		/// <see cref="Spring.Aop.Support.DefaultPointcutAdvisor"/>
		/// class for the supplied <paramref name="advice"/> and
		/// <paramref name="pointcut"/>.
		/// </summary>
		/// <param name="advice">
		/// The advice to use.
		/// </param>
		/// <param name="pointcut">
		/// The pointcut to use.
		/// </param>
		public DefaultPointcutAdvisor(IPointcut pointcut, IAdvice advice)
		{
			this.pointcut = pointcut;
			Advice = advice;
		}
Ejemplo n.º 39
0
        private ITestObject CreateProxy(object target, IAdvice interceptor, bool exposeProxy)
        {
            ProxyFactory pf = new ProxyFactory(target);
            pf.ExposeProxy = exposeProxy;
//            pf.Target = target;
            pf.AddAdvice(interceptor);

            return pf.GetProxy() as ITestObject;
        }
Ejemplo n.º 40
0
 /// <summary>
 /// Returns <see langword="true"/> if the supplied
 /// <paramref name="advice"/> is an instance of the
 /// <see cref="Spring.Aop.IThrowsAdvice"/> interface.
 /// </summary>
 /// <param name="advice">The advice to check.</param>
 /// <returns>
 /// <see langword="true"/> if the supplied <paramref name="advice"/> is
 /// an instance of the <see cref="Spring.Aop.IThrowsAdvice"/> interface;
 /// <see langword="false"/> if not or if the supplied
 /// <paramref name="advice"/> is <cref lang="null"/>.
 /// </returns>
 public virtual bool SupportsAdvice(IAdvice advice)
 {
     return advice is IThrowsAdvice;
 }
		/// <summary>
		/// Creates a new instance of the
		/// <see cref="AttributeMatchMethodPointcutAdvisor"/> class
		/// for the supplied <paramref name="advice"/>.
		/// </summary>
		/// <param name="advice">the advice to apply if the pointcut matches</param>
		public AttributeMatchMethodPointcutAdvisor(IAdvice advice)
		{
			this._advice = advice;
		}
 /// <summary>
 /// Returns <see langword="true"/> if the supplied
 /// <paramref name="advice"/> is an instance of the
 /// <see cref="Spring.Aop.IAfterReturningAdvice"/> interface.
 /// </summary>
 /// <param name="advice">The advice to check.</param>
 /// <returns>
 /// <see langword="true"/> if the supplied <paramref name="advice"/> is
 /// an instance of the <see cref="Spring.Aop.IAfterReturningAdvice"/> interface;
 /// <see langword="false"/> if not or if the supplied
 /// <paramref name="advice"/> is <cref lang="null"/>.
 /// </returns>
 public virtual bool SupportsAdvice(IAdvice advice)
 {
     return advice is IAfterReturningAdvice;
 }
Ejemplo n.º 43
0
 /// <summary> 
 /// Return the index (0 based) of the supplied
 /// <see cref="AopAlliance.Aop.IAdvice"/> in the interceptor
 /// (advice) chain for this proxy.
 /// </summary>
 /// <remarks>
 /// <p>
 /// The return value of this method can be used to index into
 /// the <see cref="Spring.Aop.Framework.AdvisedSupport.Advisors"/>
 /// list.
 /// </p>
 /// </remarks>
 /// <param name="advice">
 /// The <see cref="AopAlliance.Aop.IAdvice"/> to search for.
 /// </param>
 /// <returns>
 /// The zero (0) based index of this interceptor, or -1 if the
 /// supplied <paramref name="advice"/> is not an advice for this
 /// proxy.
 /// </returns>
 public virtual int IndexOf(IAdvice advice)
 {
     lock (this.SyncRoot)
     {
         return IndexOfInternal(advice);
     }
 }
Ejemplo n.º 44
0
 /// <summary> 
 /// Return the index (0 based) of the supplied
 /// <see cref="AopAlliance.Aop.IAdvice"/> in the interceptor
 /// (advice) chain for this proxy.
 /// </summary>
 /// <remarks>
 /// <p>Acces is not synchronized</p>
 /// <p>
 /// The return value of this method can be used to index into
 /// the <see cref="Spring.Aop.Framework.AdvisedSupport.Advisors"/>
 /// list.
 /// </p>
 /// </remarks>
 /// <param name="advice">
 /// The <see cref="AopAlliance.Aop.IAdvice"/> to search for.
 /// </param>
 /// <returns>
 /// The zero (0) based index of this interceptor, or -1 if the
 /// supplied <paramref name="advice"/> is not an advice for this
 /// proxy.
 /// </returns>
 private int IndexOfInternal(IAdvice advice)
 {
     if (this._advisors != null)
     {
         for (int i = 0; i < this._advisors.Count; ++i)
         {
             IAdvisor advisor = (IAdvisor)this._advisors[i];
             if (advisor.Advice == advice)
             {
                 return i;
             }
         }
     }
     return -1;
 }
Ejemplo n.º 45
0
 /// <summary>
 /// Removes the supplied <paramref name="advice"/> from the list
 /// of <see cref="Spring.Aop.Framework.IAdvised.Advisors"/>.
 /// </summary>
 /// <param name="advice">
 /// The <see cref="AopAlliance.Aop.IAdvice"/> to remove.
 /// </param>
 /// <returns>
 /// <see langword="true"/> if the supplied <paramref name="advice"/> was
 /// found in the list of <see cref="Spring.Aop.Framework.IAdvised.Advisors"/>
 /// and successfully removed.
 /// </returns>
 /// <exception cref="AopConfigException">
 /// If this proxy configuration is frozen and the
 /// <see cref="AopAlliance.Aop.IAdvice"/> cannot be removed.
 /// </exception>
 public bool RemoveAdvice(IAdvice advice)
 {
     lock (this.SyncRoot)
     {
         int index = IndexOf(advice);
         if (index == -1)
         {
             return false;
         }
         RemoveAdvisorInternal(index);
         return true;
     }
 }
Ejemplo n.º 46
0
        /// <summary>
        /// Adds the supplied <paramref name="advice"/> to the supplied
        /// <paramref name="position"/> in the advice (interceptor) chain.
        /// </summary>
        /// <param name="position">
        /// The zero (0) indexed position (from the head) at which the
        /// supplied <paramref name="advice"/> is to be inserted into the
        /// advice (interceptor) chain.
        /// </param>
        /// <param name="advice">
        /// The <see cref="AopAlliance.Aop.IAdvice"/> to be added.
        /// </param>
        /// <exception cref="Spring.Aop.Framework.AopConfigException">
        /// If the supplied <paramref name="advice"/> is <cref lang="null"/>;
        /// or is not an <see cref="AopAlliance.Intercept.IMethodInterceptor"/>
        /// reference; or if the supplied <paramref name="advice"/> is a
        /// <see cref="Spring.Aop.IIntroductionInterceptor"/>.
        /// </exception>
        /// <seealso cref="Spring.Aop.Support.DefaultPointcutAdvisor"/>
        /// <seealso cref="IAdvised.AddAdvice(IAdvice)"/>
        public void AddAdvice(int position, IAdvice advice)
        {
            if (advice is IInterceptor && !(advice is IMethodInterceptor))
            {
                throw new AopConfigException(
                    GetType().FullName + " can only handle AOP Alliance IMethodInterceptor advice.");
            }
            if (advice is IIntroductionInterceptor)
            {
                throw
                    new AopConfigException(
                        "IIntroductionInterceptors may only be added as part of IIntroductionAdvisor.");
            }

            AddAdvisor(position, new DefaultPointcutAdvisor(advice));
        }
Ejemplo n.º 47
0
 /// <summary>
 /// Injects the introduced fields to advice.
 /// Allows null advices (and does nothing)
 /// </summary>
 /// <param name="advice">The advice.</param>
 /// <param name="advisedType">Type of the advised.</param>
 private static void SafeInjectIntroducedFields(IAdvice advice, Type advisedType)
 {
     // shame, but easy here
     if (advice == null)
         return;
     InjectIntroducedFields(advice, advisedType);
 }
 /// <summary>
 /// Creates a new instance of the <see cref="RegularExpressionMethodPointcutAdvisor"/>
 /// class for the supplied <paramref name="advice"/>.
 /// </summary><param name="advice">
 /// The target advice.
 /// </param>
 public RegularExpressionMethodPointcutAdvisor(IAdvice advice)
 {
     Advice = advice;
     InitPointcut();
 }
		/// <summary>
		/// Creates a new instance of the
		/// <see cref="AttributeMatchMethodPointcutAdvisor"/> class
		/// for the supplied <paramref name="advice"/>.
		/// </summary>
        /// <param name="attribute">
        /// The <see cref="System.Attribute"/> to match.
        /// </param>
        /// <param name="inherit">
        /// Flag that controls whether or not the inheritance tree of the
        /// method to be included in the search for the <see cref="Attribute"/>?
        /// </param>
        /// <param name="advice">the advice to apply if the pointcut matches</param>
        public AttributeMatchMethodPointcutAdvisor(Type attribute, bool inherit, IAdvice advice)
            :base(attribute, inherit)
		{
			this._advice = advice;
		}
		/// <summary>
		/// Creates a new instance of the
		/// <see cref="Spring.Aop.Support.DefaultIntroductionAdvisor"/> class using
		/// the supplied <paramref name="introduction"/>
		/// </summary>
		/// <remarks>
		/// <p>
		/// This constructor adds all interfaces implemented by the supplied
		/// <paramref name="introduction"/> (except the
		/// <see cref="AopAlliance.Aop.IAdvice"/> interface) to the list of
		/// interfaces to introduce.
		/// </p>
		/// </remarks>
		/// <param name="introduction">The introduction to use.</param>
		public DefaultIntroductionAdvisor(IAdvice introduction)
			: this(introduction, introduction.GetType().GetInterfaces())
		{
		}
Ejemplo n.º 51
0
 public MethodRewriter(IAdvice advice, BasePointCut pointCut)
 {
     this._advice = advice;
     this._pointCut = pointCut;
 }
		/// <summary>
		/// Creates a new instance of the
		/// <see cref="Spring.Aop.Support.DefaultIntroductionAdvisor"/> class using
		/// the supplied <paramref name="introduction"/>
		/// </summary>
		/// <param name="introduction">The introduction to use.</param>
		/// <param name="intf">
		/// The interface to introduce.
		/// </param>
		public DefaultIntroductionAdvisor(IAdvice introduction, Type intf)
			: this(introduction, new Type[] {intf})
		{
		}
Ejemplo n.º 53
0
        private ITestObject CreateProxyChain(IAdvice interceptor, bool exposeProxy)
        {
            ITestObject first = new ChainableTestObject(null);
            ITestObject firstProxy = CreateProxy(first, interceptor, exposeProxy);
            Assert.IsNotNull(firstProxy);

            ITestObject second = new ChainableTestObject(firstProxy);
            ITestObject secondProxy = CreateProxy(second, interceptor, exposeProxy);
            Assert.IsNotNull(secondProxy);
            return secondProxy;
        }
		/// <summary>
		/// Creates a new instance of the
		/// <see cref="Spring.Aop.Support.DefaultIntroductionAdvisor"/> class using
		/// the supplied <paramref name="introduction"/>
		/// </summary>
		/// <param name="introduction">The introduction to use.</param>
		/// <param name="interfaces">
		/// The interfaces to introduce.
		/// </param>
		/// <exception cref="System.ArgumentNullException">
		/// If the supplied <paramref name="introduction"/> is <see langword="null"/>.
		/// </exception>
		public DefaultIntroductionAdvisor(IAdvice introduction, Type[] interfaces)
		{
			if (introduction == null)
			{
				throw new ArgumentNullException("introduction", "Introduction cannot be null");
			}
			_introduction = introduction;
			foreach (Type intf in interfaces)
			{
				if (intf != typeof (IAdvice))
				{
					AddInterface(intf);
				}
			}
		}
		/// <summary>
		/// Creates a new instance of the
		/// <see cref="Spring.Aop.Support.DefaultPointcutAdvisor"/>
		/// class for the supplied <paramref name="advice"/>,
		/// </summary>
		/// <param name="advice">
		/// The advice to use.
		/// </param>
		public DefaultPointcutAdvisor(IAdvice advice)
			: this(TruePointcut.True, advice)
		{
		}
		/// <summary>
		/// Creates a new instance of the
		/// <see cref="Spring.Aop.Support.AbstractRegularExpressionMethodPointcut"/>
		/// class for the supplied <paramref name="advice"/>
		/// </summary>
		/// <remarks>
		/// <p>
		/// This is an abstract class, and as such has no publicly
		/// visible constructors.
		/// </p>
		/// </remarks>
		/// <param name="advice">
		/// The advice to use.
		/// </param>
		public StaticMethodMatcherPointcutAdvisor(IAdvice advice)
		{
			this._advice = advice;
		}
		public bool SupportsAdvice(IAdvice advice)
		{
			return advice is ISimpleBeforeAdvice;
		}
Ejemplo n.º 58
0
 /// <summary>
 /// Is the supplied <paramref name="advice"/> included in any
 /// advisor?
 /// </summary>
 /// <param name="advice">
 /// The <see cref="AopAlliance.Aop.IAdvice"/> to check for the
 /// inclusion of.
 /// </param>
 /// <returns>
 /// <see langword="true"/> if the supplied <paramref name="advice"/>
 /// could be run in an invocation (this does not imply that said
 /// <paramref name="advice"/> will be run).
 /// </returns>
 public bool AdviceIncluded(IAdvice advice)
 {
     return (IndexOf(advice) != -1);
 }
		/// <summary>
		/// Creates a new instance of the
		/// <see cref="NameMatchMethodPointcutAdvisor"/> class
		/// for the supplied <paramref name="advice"/>.
		/// </summary>
		/// <param name="advice"></param>
		public NameMatchMethodPointcutAdvisor(IAdvice advice)
		{
			Advice = advice;
        }
 bool IAdvised.RemoveAdvice(IAdvice advice)
 {
     return m_advised.RemoveAdvice(advice);
 }