/*----------------------------------------------------------------------------------------*/ /// <summary> /// Creates a terminating condition that determines whether the subject is decorated /// with an attribute that matches the provided attribute. /// </summary> /// <typeparam name="T">The type of attribute to look for.</typeparam> /// <param name="attribute">The attribute to compare against.</param> /// <returns>A condition that terminates the chain.</returns> public TerminatingCondition <TRoot, TSubject> HasMatchingAttribute <T>(T attribute) where T : Attribute { #if !MONO return(Terminate(s => s.HasMatchingAttribute(attribute))); #else return(Terminate(s => ExtensionsForICustomAttributeProvider.HasMatchingAttribute(s, attribute))); #endif }
/*----------------------------------------------------------------------------------------*/ /// <summary> /// Executed to build the activation plan. /// </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> /// <returns> /// A value indicating whether to proceed or interrupt the strategy chain. /// </returns> public override StrategyResult Build(IBinding binding, Type type, IActivationPlan plan) { EventInfo[] events = type.GetEvents(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance); foreach (EventInfo evt in events) { #if !MONO PublishAttribute[] attributes = evt.GetAllAttributes <PublishAttribute>(); #else PublishAttribute[] attributes = ExtensionsForICustomAttributeProvider.GetAllAttributes <PublishAttribute>(evt); #endif foreach (PublishAttribute attribute in attributes) { plan.Directives.Add(new PublicationDirective(attribute.Channel, evt)); } } MethodInfo[] methods = type.GetMethods(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance); var injectorFactory = binding.Components.Get <IInjectorFactory>(); foreach (MethodInfo method in methods) { #if !MONO SubscribeAttribute[] attributes = method.GetAllAttributes <SubscribeAttribute>(); #else SubscribeAttribute[] attributes = ExtensionsForICustomAttributeProvider.GetAllAttributes <SubscribeAttribute>(method); #endif foreach (SubscribeAttribute attribute in attributes) { IMethodInjector injector = injectorFactory.GetInjector(method); plan.Directives.Add(new SubscriptionDirective(attribute.Channel, injector, attribute.Thread)); } } return(StrategyResult.Proceed); }
/// <summary> /// Reads whether the target represents an optional dependency. /// </summary> /// <returns><see langword="True"/> if it is optional; otherwise <see langword="false"/>.</returns> protected virtual bool ReadOptionalFromTarget() { return(ExtensionsForICustomAttributeProvider.HasAttribute(Site, typeof(OptionalAttribute))); }
/// <summary> /// Returns a value indicating whether an attribute of the specified type is defined on the target. /// </summary> /// <param name="attributeType">The type of attribute to search for.</param> /// <param name="inherit">Whether to look up the hierarchy chain for inherited custom attributes.</param> /// <returns><c>True</c> if such an attribute is defined; otherwise <c>false</c>.</returns> public bool IsDefined(Type attributeType, bool inherit) { return(ExtensionsForICustomAttributeProvider.IsDefined(Site, attributeType, inherit)); }
/// <summary> /// Returns an array of custom attributes defined on the target. /// </summary> /// <param name="inherit">Whether to look up the hierarchy chain for inherited custom attributes.</param> /// <returns>An array of custom attributes.</returns> public IEnumerable <Attribute> GetCustomAttributes(bool inherit) { return(ExtensionsForICustomAttributeProvider.GetCustomAttributes(Site, (inherit))); }
GetCustomAttributes(Type attributeType, bool inherit) { return(ExtensionsForICustomAttributeProvider.GetCustomAttributesExtended(Site, attributeType, inherit)); }