Qualifier for resolving autowire candidates. A bean definition that includes one or more such qualifiers enables fine-grained matching against annotations on a field or parameter to be autowired.
Inheritance: ObjectMetadataAttributeAccessor
 /// <summary>
 /// Register a qualifier to be used for autowire candidate resolution,
 /// keyed by the qualifier's type name.
 /// <see cref="AutowireCandidateQualifier"/>
 /// </summary>
 public void AddQualifier(AutowireCandidateQualifier qualifier)
 {
     qualifiers.Add(qualifier.TypeName, qualifier);
 }
 private void ParseQualifierProperties(QualifierAttribute attr, AutowireCandidateQualifier qualifier)
 {
     foreach (var property in attr.GetType().GetProperties())
     {
         if (!property.Name.Equals("TypeId") && !property.Name.Equals("Value"))
         {
             object value = property.GetValue(attr, null);
             if (value != null)
             {
                 var attribute = new ObjectMetadataAttribute(property.Name, value);
                 qualifier.AddMetadataAttribute(attribute);
             }
         }
     }
 }
 /// <summary>
 /// Register a qualifier to be used for autowire candidate resolution,
 /// keyed by the qualifier's type name.
 /// <see cref="AutowireCandidateQualifier"/>
 /// </summary>
 public void AddQualifier(AutowireCandidateQualifier qualifier)
 {
     qualifiers.Add(qualifier.TypeName, qualifier);
 }
        private void ParseQualifierAttribute()
        {
            var attr = Attribute.GetCustomAttribute(ObjectType, typeof(QualifierAttribute), true) as QualifierAttribute;
            if (attr != null)
            {
                var qualifier = new AutowireCandidateQualifier(attr.GetType());

                if (!string.IsNullOrEmpty(attr.Value))
                    qualifier.SetAttribute(AutowireCandidateQualifier.VALUE_KEY, attr.Value);

                ParseQualifierProperties(attr, qualifier);

                AddQualifier(qualifier);
            }
        }
        /// <summary>
        /// Parse a qualifier element.
        /// </summary>
        public void ParseQualifierElement(string name, XmlElement element, ParserContext parserContext, AbstractObjectDefinition od)
        {
            string typeName = GetAttributeValue(element, ObjectDefinitionConstants.TypeAttribute);
            string value = GetAttributeValue(element, ObjectDefinitionConstants.ValueAttribute);

            if (string.IsNullOrEmpty(typeName))
            {
                throw new ObjectDefinitionStoreException(
                                    parserContext.ReaderContext.Resource, name,
                                    "Tag 'qualifier' must have a 'type' attribute");
            }
            
            var qualifier = new AutowireCandidateQualifier(typeName);
            qualifier.Source = element;

            if (!string.IsNullOrEmpty(value))
                qualifier.SetAttribute(AutowireCandidateQualifier.VALUE_KEY, value);

            foreach (XmlNode node in this.SelectNodes(element, ObjectDefinitionConstants.AttributeElement))
            {
                var attributeEle = node as XmlElement;
                string attributeKey = GetAttributeValue(attributeEle, ObjectDefinitionConstants.KeyAttribute);
                string attributeValue = GetAttributeValue(attributeEle, ObjectDefinitionConstants.ValueAttribute);

                if (!string.IsNullOrEmpty(attributeKey) && !string.IsNullOrEmpty(attributeValue))
                {
                    var attribute = new ObjectMetadataAttribute(attributeKey, attributeValue);
                    attribute.Source = attributeEle;
                    qualifier.AddMetadataAttribute(attribute);
                }
                else
                {
                    throw new ObjectDefinitionStoreException(
                                        parserContext.ReaderContext.Resource, name,
                                        "Qualifier 'attribute' tag must have a 'key' and 'value'");
                }
            }
            od.AddQualifier(qualifier);
        }