public static XmlPropertyAttributes GetAttributes(PropertyInfo propertyInfo)
        {
            if (propertyInfo == null)
            {
                throw new ArgumentNullException("propertyInfo");
            }

            var attributes = new XmlPropertyAttributes();

            foreach (var attribute in Attribute.GetCustomAttributes(propertyInfo))
            {
                if (attribute is XmlElementAttribute)
                {
                    if (attributes.Elements == null)
                    {
                        attributes.Elements = new List <XmlElementAttribute>();
                    }

                    attributes.Elements.Add((XmlElementAttribute)attribute);
                }
                else if (attribute is XmlAttributeAttribute)
                {
                    if (attributes.Attributes == null)
                    {
                        attributes.Attributes = new List <XmlAttributeAttribute>();
                    }

                    attributes.Attributes.Add((XmlAttributeAttribute)attribute);
                }
                else if (attribute is XmlArrayItemAttribute)
                {
                    if (attributes.ArrayItems == null)
                    {
                        attributes.ArrayItems = new List <XmlArrayItemAttribute>();
                    }

                    attributes.ArrayItems.Add((XmlArrayItemAttribute)attribute);
                }
                else if (attribute is XmlArrayAttribute)
                {
                    attributes.Array = (XmlArrayAttribute)attribute;
                }
                else if (attribute is XmlTextAttribute)
                {
                    attributes.Text = (XmlTextAttribute)attribute;
                }
                else if (attribute is DefaultValueAttribute)
                {
                    attributes.Default = (DefaultValueAttribute)attribute;
                }
                else if (attribute is XmlIgnoreAttribute)
                {
                    attributes.Ignore = (XmlIgnoreAttribute)attribute;
                }
            }

            return(attributes);
        }
Example #2
0
        private bool SetPropertyAttributes(XmlPropertyBuilder propertyBuilder)
        {
            if (ignoreSystemAttributes)
            {
                return(true);
            }

            var attributes = XmlPropertyAttributes.GetAttributes(propertyBuilder.PropertyInfo);

            if (attributes.Ignore != null)
            {
                return(false);
            }

            var propertyName = propertyBuilder.Name;
            var propertyType = propertyBuilder.PropertyInfo.PropertyType;
            var item         = ResolveItem(propertyType);

            if (attributes.Elements != null)
            {
                foreach (var attribute in attributes.Elements)
                {
                    var name = propertyName.Create(attribute.ElementName, attribute.Namespace);

                    if (attribute.Type == null || attribute.Type == propertyType)
                    {
                        propertyBuilder.SetName(name)
                        .SetMappingType(XmlMappingType.Element)
                        .SetNullable(attribute.IsNullable)
                        .SetOrder(attribute.Order);
                    }
                    else if (propertyType.IsAssignableFrom(attribute.Type))
                    {
                        propertyBuilder.SetKnownType(
                            attribute.Type,
                            x => x.SetName(name).SetNullable(attribute.IsNullable));
                    }

                    if (item != null)
                    {
                        name = item.Name.Create(attribute.ElementName, attribute.Namespace);

                        if (propertyBuilder.Item == null)
                        {
                            propertyBuilder.SetItem(item.ValueType, item.Name);
                        }

                        if (attribute.Type == null || attribute.Type == item.ValueType)
                        {
                            propertyBuilder.Item.SetName(name);
                        }
                        else if (item.ValueType.IsAssignableFrom(attribute.Type))
                        {
                            propertyBuilder.Item.SetKnownType(attribute.Type, name);
                        }

                        propertyBuilder.SetCollection();
                    }
                }
            }
            else if (attributes.Attributes != null)
            {
                foreach (var attribute in attributes.Attributes)
                {
                    if (attribute.Type == null || attribute.Type == propertyType)
                    {
                        var name = propertyName.Create(attribute.AttributeName, attribute.Namespace);
                        propertyBuilder.SetName(name).SetMappingType(XmlMappingType.Attribute);
                        break;
                    }
                }
            }
            else if (attributes.Text != null)
            {
                propertyBuilder.SetMappingType(XmlMappingType.InnerText);
            }
            else if (attributes.Array != null)
            {
                var name = propertyName.Create(attributes.Array.ElementName, attributes.Array.Namespace);
                propertyBuilder.SetName(name).SetNullable(attributes.Array.IsNullable).SetCollection(false);
            }

            if (attributes.Default != null)
            {
                propertyBuilder.SetDefaultValue(attributes.Default.Value);
            }

            if (attributes.ArrayItems != null && item != null && !propertyBuilder.IsCollection)
            {
                foreach (var attribute in attributes.ArrayItems)
                {
                    var name = item.Name.Create(attribute.ElementName, attribute.Namespace);

                    if (propertyBuilder.Item == null)
                    {
                        propertyBuilder.SetItem(item.ValueType, item.Name);
                    }

                    if (attribute.Type == null || attribute.Type == item.ValueType)
                    {
                        propertyBuilder.Item.SetName(name);
                    }
                    else if (item.ValueType.IsAssignableFrom(attribute.Type))
                    {
                        propertyBuilder.Item.SetKnownType(attribute.Type, name);
                    }
                }
            }

            return(true);
        }