Пример #1
0
        private IEnumerable <InjectionInfo> ParseInjectionAttributes(IReadOnlyList <CustomAttribute> injectionAttrs, IMemberDefinition debugRef)
        {
            var parsedInfos = new List <InjectionInfo>();

            foreach (var injectionAttr in injectionAttrs)
            {
                var aspectRef = injectionAttr.GetConstructorValue <TypeReference>(0);
                var aspect    = _aspectReader.Read(aspectRef.Resolve());
                if (aspect == null)
                {
                    _log.Log(InjectionRules.InjectionMustReferToAspect, debugRef, aspectRef.Name);
                    continue;
                }

                var priority = injectionAttr.GetPropertyValue <ushort>(nameof(Injection.Priority));

                var propagation = injectionAttr.GetPropertyValue <PropagateTo>(nameof(Injection.Propagation));
                if (propagation == 0)
                {
                    propagation = PropagateTo.Members | PropagateTo.Types;
                }
                if (propagation > PropagateTo.Everything)
                {
                    _log.Log(GeneralRules.UnknownCompilationOption, debugRef, GeneralRules.Literals.UnknownPropagationStrategy(propagation.ToString()));
                }


                var   propagationFilter = injectionAttr.GetPropertyValue <string>(nameof(Injection.PropagationFilter));
                Regex propagationRegex  = null;
                if (propagationFilter != null)
                {
                    try
                    {
                        propagationRegex = new Regex(propagationFilter, RegexOptions.CultureInvariant);
                    }
                    catch (Exception)
                    {
                        _log.Log(GeneralRules.UnknownCompilationOption, debugRef, GeneralRules.Literals.InvalidPropagationFilter(propagationFilter));
                    }
                }

                parsedInfos.Add(new InjectionInfo(aspect, priority, propagation, propagationRegex));
            }

            return(parsedInfos);
        }
Пример #2
0
        private IEnumerable <InjectionDefinition> ParseInjectionAttribute(ICustomAttributeProvider target, CustomAttribute trigger, IReadOnlyList <CustomAttribute> injectionAttrs)
        {
            var injections = Enumerable.Empty <InjectionDefinition>();

            foreach (var injectionAttr in injectionAttrs)
            {
                var aspectRef = injectionAttr.GetConstructorValue <TypeReference>(0);
                var aspect    = _aspectReader.Read(aspectRef.Resolve());
                if (aspect == null)
                {
                    _log.Log(InjectionRules.InjectionMustReferToAspect, target, aspectRef.Name);
                    continue;
                }

#pragma warning disable S1854 // Unused assignments should be removed
                var priority = injectionAttr.GetPropertyValue <ushort>(nameof(Injection.Priority));
#pragma warning restore S1854 // Unused assignments should be removed

                var propagation = injectionAttr.GetPropertyValue <PropagateTo>(nameof(Injection.Propagation));
                if (propagation == 0)
                {
                    propagation = PropagateTo.Members | PropagateTo.Types;
                }
                if (propagation > PropagateTo.Everything)
                {
                    _log.Log(GeneralRules.UnknownCompilationOption, trigger.AttributeType.Resolve(), GeneralRules.Literals.UnknownPropagationStrategy(propagation.ToString()));
                }


                var   propagationFilter = injectionAttr.GetPropertyValue <string>(nameof(Injection.PropagationFilter));
                Regex propagationRegex  = null;
                if (propagationFilter != null)
                {
                    try
                    {
#pragma warning disable S1854 // Unused assignments should be removed
                        propagationRegex = new Regex(propagationFilter, RegexOptions.CultureInvariant);
#pragma warning restore S1854 // Unused assignments should be removed
                    }
                    catch (Exception)
                    {
                        _log.Log(GeneralRules.UnknownCompilationOption, trigger.AttributeType.Resolve(), GeneralRules.Literals.InvalidPropagationFilter(propagationFilter));
                    }
                }

                var injectionInfo = (aspect, priority, propagation, propagationRegex);

                injections = injections.Concat(FindApplicableMembers(target, injectionInfo, trigger));
            }

            return(injections);
        }
Пример #3
0
        private IEnumerable <InjectionDefinition> ParseInjectionAttribute(ICustomAttributeProvider target, CustomAttribute trigger, CustomAttribute[] injectionAttrs)
        {
            var injections = Enumerable.Empty <InjectionDefinition>();

            foreach (var injectionAttr in injectionAttrs)
            {
                var aspectRef = injectionAttr.GetConstructorValue <TypeReference>(0);
                var aspect    = _aspectReader.Read(aspectRef.Resolve());

                if (aspect == null)
                {
                    _log.Log(InjectionRules.InjectionMustReferToAspect, target, aspectRef.Name);
                    continue;
                }

                var priority = injectionAttr.GetPropertyValue <ushort>(nameof(Broker.Injection.Priority));

                injections = injections.Concat(FindApplicableMembers(target, aspect, priority, trigger));
            }

            return(injections);
        }
Пример #4
0
        private IEnumerable <Injection> ParseInjectionAttribute(ICustomAttributeProvider target, CustomAttribute attr)
        {
            var aspectRef = attr.GetConstructorValue <TypeReference>(0);
            var aspect    = _aspectReader.Read(aspectRef.Resolve());

            if (aspect == null)
            {
                _weaver.LogError($"Type {aspectRef.FullName} should be an aspect class.");
                return(Enumerable.Empty <Injection>());
            }

            ushort priority = /* attr.GetPropertyValue<Broker.Inject, ushort>(i => i.Priority)*/ 0;

            // var childFilter = attr.GetPropertyValue<Broker.Inject, InjectionChildFilter>(i => i.Filter);

            var injections = FindApplicableMembers(target, aspect, priority /*, childFilter*/);

            return(injections);
        }