private void SetCollectionObjectWithCollectionMember(ref object collection, CollectionMember collectionMember, Type collectionType)
{
if (collectionType.IsArray)
{
Array a;
Type elementType = collectionType.GetElementType();
var currentArray = collection as Array;
if (currentArray != null && currentArray.Length == collectionMember.Count)
{
a = currentArray;
}
else
{
a = Array.CreateInstance(elementType, collectionMember.Count);
}
for (int i = 0; i < collectionMember.Count; i++)
{
a.SetValue(collectionMember[i], i);
}
collection = a;
}
else
{
if (collection == null)
{
collection = ReflectionCreateObject(collectionType);
}
if (typeof(IList).IsAssignableFrom(collectionType))
{
foreach (var item in collectionMember)
{
((IList)collection).Add(item);
}
}
else
{
foreach (var item in collectionMember)
{
MethodInfo addMethod = collectionType.GetMethod("Add");
if (addMethod == null)
{
throw new InvalidOperationException("(addMethod == null)");
}
addMethod.Invoke(collection, new object[] { item });
}
}
}
}
private void WriteArray(ref object o, ArrayMapping arrayMapping, bool readOnly, bool isNullable, string defaultNamespace)
{
if (arrayMapping.IsSoap)
{
throw new PlatformNotSupportedException("arrayMapping.IsSoap");
}
else
{
if (!ReadNull())
{
MemberMapping memberMapping = new MemberMapping();
memberMapping.Elements = arrayMapping.Elements;
memberMapping.TypeDesc = arrayMapping.TypeDesc;
memberMapping.ReadOnly = readOnly;
Type collectionType = memberMapping.TypeDesc.Type;
if (o == null)
{
o = ReflectionCreateObject(memberMapping.TypeDesc.Type);
}
if (memberMapping.ChoiceIdentifier != null)
{
// #10588: To Support ArrayMapping Types Having ChoiceIdentifier
throw new NotImplementedException("memberMapping.ChoiceIdentifier != null");
}
var collectionMember = new CollectionMember();
if ((readOnly && o == null) || Reader.IsEmptyElement)
{
Reader.Skip();
}
else
{
Reader.ReadStartElement();
Reader.MoveToContent();
UnknownNodeAction unknownNode = UnknownNodeAction.ReadUnknownNode;
while (Reader.NodeType != XmlNodeType.EndElement && Reader.NodeType != XmlNodeType.None)
{
Member temp;
WriteMemberElements(ref o, collectionMember, out temp, new Member[] { new Member(memberMapping) }, unknownNode, unknownNode, null, null);
Reader.MoveToContent();
}
ReadEndElement();
}
SetCollectionObjectWithCollectionMember(ref o, collectionMember, collectionType);
}
}
}
private void WriteMemberElements(ref object o, CollectionMember collectionMember, out Member member, Member[] expectedMembers, UnknownNodeAction elementElseAction, UnknownNodeAction elseAction, Member anyElement, Member anyText, object masterObject = null)
{
if (Reader.NodeType == XmlNodeType.Element)
{
WriteMemberElementsIf(ref o, collectionMember, out member, expectedMembers, anyElement, elementElseAction, masterObject);
}
else if (anyText != null && anyText.Mapping != null && WriteMemberText(out o, anyText))
{
member = anyText;
}
else
{
member = null;
ProcessUnknownNode(elseAction);
}
}
private void WriteElement(ref object o, CollectionMember collectionMember, ElementAccessor element, ChoiceIdentifierAccessor choice, bool checkSpecified, bool checkForNull, bool readOnly, string defaultNamespace, object masterObject = null)
{
object value = null;
if (element.Mapping is ArrayMapping)
{
WriteArray(ref value, (ArrayMapping)element.Mapping, readOnly, element.IsNullable, defaultNamespace);
}
else if (element.Mapping is NullableMapping)
{
value = WriteNullableMethod((NullableMapping)element.Mapping, true, defaultNamespace);
}
else if (!element.Mapping.IsSoap && (element.Mapping is PrimitiveMapping))
{
if (element.IsNullable && ReadNull())
{
if (element.Mapping.TypeDesc.IsValueType)
{
value = ReflectionCreateObject(element.Mapping.TypeDesc.Type);
}
else
{
value = null;
}
}
else if ((element.Default != null && !Globals.IsDBNullValue(element.Default) && element.Mapping.TypeDesc.IsValueType) &&
(Reader.IsEmptyElement))
{
Reader.Skip();
}
else
{
if (element.Mapping.TypeDesc == QnameTypeDesc)
{
value = ReadElementQualifiedName();
}
else
{
if (element.Mapping.TypeDesc.FormatterName == "ByteArrayBase64")
{
value = ToByteArrayBase64(false);
}
else if (element.Mapping.TypeDesc.FormatterName == "ByteArrayHex")
{
value = ToByteArrayHex(false);
}
else
{
Func <string> readFunc = () => Reader.ReadElementContentAsString();
value = WritePrimitive(element.Mapping, readFunc);
}
}
}
}
else if (element.Mapping is StructMapping || (element.Mapping.IsSoap && element.Mapping is PrimitiveMapping))
{
TypeMapping mapping = element.Mapping;
if (mapping.IsSoap)
{
throw new PlatformNotSupportedException();
}
else
{
if (checkForNull && o == null)
{
Reader.Skip();
}
else
{
value = WriteStructMethod(
mapping: (StructMapping)mapping,
isNullable: mapping.TypeDesc.IsNullable && element.IsNullable,
checkType: true,
defaultNamespace: defaultNamespace
);
}
}
}
else if (element.Mapping is SpecialMapping)
{
SpecialMapping special = (SpecialMapping)element.Mapping;
switch (special.TypeDesc.Kind)
{
case TypeKind.Node:
bool isDoc = special.TypeDesc.FullName == typeof(XmlDocument).FullName;
if (isDoc)
{
value = ReadXmlDocument(!element.Any);
}
else
{
value = ReadXmlNode(!element.Any);
}
break;
case TypeKind.Serializable:
SerializableMapping sm = (SerializableMapping)element.Mapping;
// check to see if we need to do the derivation
bool flag = true;
if (sm.DerivedMappings != null)
{
XmlQualifiedName tser = GetXsiType();
if (tser == null || QNameEqual(tser, sm.XsiType.Name, sm.XsiType.Namespace, defaultNamespace))
{
}
else
{
flag = false;
}
}
if (flag)
{
bool isWrappedAny = !element.Any && IsWildcard(sm);
value = ReadSerializable((IXmlSerializable)ReflectionCreateObject(sm.TypeDesc.Type), isWrappedAny);
}
if (sm.DerivedMappings != null)
{
// #10587: To Support SpecialMapping Types Having DerivedMappings
throw new NotImplementedException("sm.DerivedMappings != null");
//WriteDerivedSerializable(sm, sm, source, isWrappedAny);
//WriteUnknownNode("UnknownNode", "null", null, true);
}
break;
default:
throw new InvalidOperationException(SR.Format(SR.XmlInternalError));
}
}
else
{
throw new InvalidOperationException(SR.Format(SR.XmlInternalError));
}
if (choice != null && masterObject != null)
{
foreach (var name in choice.MemberIds)
{
if (name == element.Name)
{
object choiceValue = Enum.Parse(choice.Mapping.TypeDesc.Type, name);
SetOrAddValueToMember(masterObject, choiceValue, choice.MemberInfo);
break;
}
}
}
if (collectionMember != null)
{
collectionMember.Add(value);
}
else
{
o = value;
}
}
private void WriteMemberElementsIf(ref object o, CollectionMember collectionMember, out Member member, Member[] expectedMembers, Member anyElementMember, UnknownNodeAction elementElseAction, object masterObject = null)
{
bool isSequence = IsSequence(expectedMembers);
if (isSequence)
{
// #10586: Currently the reflection based method treat this kind of type as normal types.
// But potentially we can do some optimization for types that have ordered properties.
}
ElementAccessor e = null;
member = null;
bool foundElement = false;
foreach (var m in expectedMembers)
{
if (m.Mapping.Xmlns != null)
{
continue;
}
if (m.Mapping.Ignore)
{
continue;
}
if (isSequence && (m.Mapping.IsText || m.Mapping.IsAttribute))
{
continue;
}
foreach (var ele in m.Mapping.Elements)
{
if (ele.Name == Reader.LocalName && ele.Namespace == Reader.NamespaceURI)
{
e = ele;
member = m;
foundElement = true;
break;
}
}
if (foundElement)
{
break;
}
}
if (foundElement)
{
ChoiceIdentifierAccessor choice = member.Mapping.ChoiceIdentifier;
string ns = e.Form == XmlSchemaForm.Qualified ? e.Namespace : "";
bool isList = member.Mapping.TypeDesc.IsArrayLike && !member.Mapping.TypeDesc.IsArray;
WriteElement(ref o, collectionMember, e, choice, member.Mapping.CheckSpecified == SpecifiedAccessor.ReadWrite, isList && member.Mapping.TypeDesc.IsNullable, member.Mapping.ReadOnly, ns, masterObject);
}
else
{
if (anyElementMember != null && anyElementMember.Mapping != null)
{
var anyElement = anyElementMember.Mapping;
member = anyElementMember;
ChoiceIdentifierAccessor choice = member.Mapping.ChoiceIdentifier;
ElementAccessor[] elements = anyElement.Elements;
for (int i = 0; i < elements.Length; i++)
{
ElementAccessor element = elements[i];
if (element.Any && element.Name.Length == 0)
{
string ns = element.Form == XmlSchemaForm.Qualified ? element.Namespace : "";
WriteElement(ref o, collectionMember, element, choice, anyElement.CheckSpecified == SpecifiedAccessor.ReadWrite, false, false, ns, masterObject: masterObject);
break;
}
}
}
else
{
member = null;
ProcessUnknownNode(elementElseAction);
}
}
}
public Member(MemberMapping mapping, CollectionMember collectionMember) : this(mapping)
{
Collection = collectionMember;
}
