private static void AddXmlElementsPrint(XmlElementAttributes atts, StringBuilder printBuilder)
{
if (null != atts)
{
foreach (XmlElementAttribute att in atts)
{
printBuilder.Append(att.DataType);
printBuilder.Append("/");
printBuilder.Append(att.ElementName);
printBuilder.Append("/");
printBuilder.Append(att.Form);
printBuilder.Append("/");
printBuilder.Append(att.IsNullable);
printBuilder.Append("/");
printBuilder.Append(att.Namespace);
printBuilder.Append("/");
if (null != att.Type)
{
printBuilder.Append(att.Type.AssemblyQualifiedName);
}
printBuilder.Append("::");
}
}
printBuilder.Append("%%");
}
private void WriteMember(XmlWriter writer, object component, object obj, MemberMapping memberMapping, string name, string ns)
{
if (!ShouldSerializeValue(component, obj, memberMapping))
{
return;
}
XmlElementAttributes xmlElements = memberMapping.XmlAttributes.XmlElements;
if (xmlElements.Count > 0)
{
Type serializationType = GetSerializationType(obj);
foreach (XmlElementAttribute item in xmlElements)
{
if (serializationType == item.Type)
{
if (!string.IsNullOrEmpty(item.ElementName))
{
name = item.ElementName;
}
if (!string.IsNullOrEmpty(item.Namespace))
{
ns = item.Namespace;
}
break;
}
}
}
WriteObjectContent(writer, component, obj, name, ns, memberMapping, 0);
}
public LiteralAttributes(MemberInfo memberInfo, XmlAttributes xmlAtts) :
this(memberInfo)
{
if (xmlAtts == null)
{
return;
}
Ignore = xmlAtts.XmlIgnore;
if (!Ignore)
{
XmlChoiceIdentifier = xmlAtts.XmlChoiceIdentifier;
XmlAttribute = xmlAtts.XmlAttribute;
XmlArray = xmlAtts.XmlArray;
XmlText = xmlAtts.XmlText;
XmlEnum = xmlAtts.XmlEnum;
DefaultValue = (xmlAtts.XmlDefaultValue == null) ?
null :
new DefaultValueAttribute(xmlAtts.XmlDefaultValue);
Xmlns = xmlAtts.Xmlns;
if (Xmlns)
{
object[] attrs = memberInfo.GetCustomAttributes(s_nsDeclType, false).ToArray();
XmlNamespaceDeclaration = (XmlNamespaceDeclarationsAttribute)(attrs.Length > 0 ? attrs[0] : null);
}
else
{
XmlNamespaceDeclaration = null;
}
// Use if statements here so that the XmlElements collection populated by reflection
// is eliminated only if the app developer has provided substitute XmlElementAttribute's.
// Ditto for the XmlArrayItems and XmlAnyElements.
if (xmlAtts.XmlElements.Count > 0)
{
XmlElements = xmlAtts.XmlElements;
}
if (xmlAtts.XmlArrayItems.Count > 0)
{
XmlArrayItems = xmlAtts.XmlArrayItems;
}
XmlAnyAttribute = xmlAtts.XmlAnyAttribute;
if (xmlAtts.XmlAnyElements.Count > 0)
{
XmlAnyElements = xmlAtts.XmlAnyElements;
}
}
}
void Reflect(Type type, string propertyName, XmlElementAttributes xmlElements)
{
PropertyInfo property = type.GetProperty(propertyName);
object[] attributes = property.GetCustomAttributes(true);
for (int i = 0; i < attributes.Length; ++i)
{
XmlElementAttribute element = attributes[i] as XmlElementAttribute;
if (element != null)
{
xmlElements.Add(element);
}
}
}
private void ReadStructContent(object obj, StructMapping mapping)
{
this.m_reader.MoveToContent();
string name = this.m_reader.Name;
string namespaceURI = this.m_reader.NamespaceURI;
this.ReadStructAttributes(obj, mapping);
if (this.m_reader.IsEmptyElement)
{
this.m_reader.Skip();
}
else
{
this.m_reader.ReadStartElement();
this.m_reader.MoveToContent();
while (this.m_reader.NodeType != XmlNodeType.EndElement && this.m_reader.NodeType != 0)
{
string localName = this.m_reader.LocalName;
string namespaceURI2 = this.m_reader.NamespaceURI;
namespaceURI2 = ((namespaceURI == namespaceURI2) ? string.Empty : namespaceURI2);
MemberMapping memberMapping = mapping.GetElement(localName, namespaceURI2);
Type type = null;
if (memberMapping != null)
{
type = memberMapping.Type;
}
else
{
List <MemberMapping> typeNameElements = mapping.GetTypeNameElements();
if (typeNameElements != null)
{
bool flag = false;
for (int i = 0; i < typeNameElements.Count; i++)
{
memberMapping = typeNameElements[i];
XmlElementAttributes xmlElements = memberMapping.XmlAttributes.XmlElements;
if (base.XmlOverrides != null)
{
XmlAttributes xmlAttributes = base.XmlOverrides[obj.GetType()];
if (xmlAttributes == null)
{
xmlAttributes = base.XmlOverrides[memberMapping.Type];
}
if (xmlAttributes != null && xmlAttributes.XmlElements != null)
{
xmlElements = xmlAttributes.XmlElements;
}
}
foreach (XmlElementAttribute item in xmlElements)
{
if (item.ElementName == localName && item.Type != null)
{
type = item.Type;
flag = true;
break;
}
}
if (flag)
{
break;
}
}
}
}
if (type != null)
{
if (memberMapping.ChildAttributes != null)
{
foreach (MemberMapping childAttribute in memberMapping.ChildAttributes)
{
this.ReadChildAttribute(obj, mapping, childAttribute);
}
}
if (memberMapping.IsReadOnly)
{
if (!TypeMapper.IsPrimitiveType(type))
{
object value = memberMapping.GetValue(obj);
if (value != null)
{
this.ReadObjectContent(value, memberMapping, 0);
}
else
{
this.m_reader.Skip();
}
}
else
{
this.m_reader.Skip();
}
}
else
{
object obj2 = this.ReadObject(type, memberMapping, 0);
if (obj2 != null)
{
memberMapping.SetValue(obj, obj2);
}
}
}
else
{
if (namespaceURI2 != string.Empty && this.m_validNamespaces.Contains(namespaceURI2))
{
IXmlLineInfo xmlLineInfo = (IXmlLineInfo)this.m_reader;
string message = RDLValidatingReaderStrings.rdlValidationInvalidMicroVersionedElement(this.m_reader.Name, name, xmlLineInfo.LineNumber.ToString(CultureInfo.InvariantCulture.NumberFormat), xmlLineInfo.LinePosition.ToString(CultureInfo.InvariantCulture.NumberFormat));
throw new XmlException(message);
}
this.m_reader.Skip();
}
this.m_reader.MoveToContent();
}
this.m_reader.ReadEndElement();
}
}
private object ReadArrayContent(object array, ArrayMapping mapping, MemberMapping member, int nestingLevel)
{
IList list = (IList)array;
if (this.m_reader.IsEmptyElement)
{
this.m_reader.Skip();
}
else
{
this.m_reader.ReadStartElement();
this.m_reader.MoveToContent();
while (this.m_reader.NodeType != XmlNodeType.EndElement && this.m_reader.NodeType != 0)
{
if (this.m_reader.NodeType == XmlNodeType.Element)
{
string localName = this.m_reader.LocalName;
string namespaceURI = this.m_reader.NamespaceURI;
Type type = null;
bool flag = false;
if (member != null && member.XmlAttributes.XmlArrayItems.Count > nestingLevel)
{
if (localName == member.XmlAttributes.XmlArrayItems[nestingLevel].ElementName)
{
XmlArrayItemAttribute xmlArrayItemAttribute = member.XmlAttributes.XmlArrayItems[nestingLevel];
type = xmlArrayItemAttribute.Type;
flag = xmlArrayItemAttribute.IsNullable;
}
}
else
{
XmlElementAttributes xmlElementAttributes = null;
if (base.XmlOverrides != null)
{
XmlAttributes xmlAttributes = base.XmlOverrides[mapping.ItemType];
if (xmlAttributes != null && xmlAttributes.XmlElements != null)
{
xmlElementAttributes = xmlAttributes.XmlElements;
}
}
if (xmlElementAttributes == null)
{
mapping.ElementTypes.TryGetValue(localName, out type);
}
else
{
foreach (XmlElementAttribute item in xmlElementAttributes)
{
if (localName == item.ElementName)
{
type = item.Type;
break;
}
}
}
}
if (type != null)
{
object value;
if (flag && this.m_reader.GetAttribute("nil", "http://www.w3.org/2001/XMLSchema-instance") == "true")
{
this.m_reader.Skip();
value = null;
}
else
{
value = this.ReadObject(type, member, nestingLevel + 1);
}
list.Add(value);
}
else
{
this.m_reader.Skip();
}
}
else
{
this.m_reader.Skip();
}
this.m_reader.MoveToContent();
}
this.m_reader.ReadEndElement();
}
return(array);
}
public LiteralAttributes(MemberInfo memberInfo)
{
foreach (object attr in memberInfo.GetCustomAttributes(false))
{
Type type = attr.GetType();
if (type == s_ignoreType)
{
Debug.Assert(false == Ignore, "Too many ignores");
Ignore = true;
}
else if (type == s_choiceType)
{
Debug.Assert(XmlChoiceIdentifier == null, "Too many XCIA");
XmlChoiceIdentifier = (XmlChoiceIdentifierAttribute)attr;
}
else if (type == s_elementType)
{
if (XmlElements == null)
{
XmlElements = new XmlElementAttributes();
}
XmlElements.Add((XmlElementAttribute)attr);
}
else if (type == s_attributeType)
{
Debug.Assert(XmlAttribute == null, "Too many XAAs");
XmlAttribute = (XmlAttributeAttribute)attr;
}
else if (type == s_arrayType)
{
Debug.Assert(XmlArray == null, "Too many XAAs");
XmlArray = (XmlArrayAttribute)attr;
}
else if (type == s_arrayItemType)
{
if (XmlArrayItems == null)
{
XmlArrayItems = new XmlArrayItemAttributes();
}
XmlArrayItems.Add((XmlArrayItemAttribute)attr);
}
else if (type == s_nsDeclType)
{
Debug.Assert(XmlNamespaceDeclaration == null, "Too many XNDAs");
XmlNamespaceDeclaration = (XmlNamespaceDeclarationsAttribute)attr;
Xmlns = true;
}
else if (type == s_textType)
{
Debug.Assert(XmlText == null, "Too many XTAs");
XmlText = (XmlTextAttribute)attr;
}
else if (type == s_anyAttrType)
{
Debug.Assert(XmlAnyAttribute == null, "Too many XAAAs");
XmlAnyAttribute = (XmlAnyAttributeAttribute)attr;
}
else if (type == s_anyEltType)
{
if (XmlAnyElements == null)
{
XmlAnyElements = new XmlAnyElementAttributes();
}
XmlAnyElements.Add((XmlAnyElementAttribute)attr);
}
else if (type == s_enumType)
{
XmlEnum = (XmlEnumAttribute)attr;
}
else
{
base.processAttribute(attr);
}
}
}
