private object WriteLiteralStructMethod(StructMapping structMapping, bool isNullable, bool checkType, string defaultNamespace)
{
XmlQualifiedName xsiType = checkType ? GetXsiType() : null;
bool isNull = false;
if (isNullable)
{
isNull = ReadNull();
}
if (checkType)
{
if (structMapping.TypeDesc.IsRoot && isNull)
{
if (xsiType != null)
{
return(ReadTypedNull(xsiType));
}
else
{
if (structMapping.TypeDesc.IsValueType)
{
return(ReflectionCreateObject(structMapping.TypeDesc.Type));
}
else
{
return(null);
}
}
}
object o = null;
if (xsiType == null || (!structMapping.TypeDesc.IsRoot && QNameEqual(xsiType, structMapping.TypeName, structMapping.Namespace, defaultNamespace)))
{
if (structMapping.TypeDesc.IsRoot)
{
return(ReadTypedPrimitive(new XmlQualifiedName(Soap.UrType, XmlSchemaConstants.Namespace)));
}
}
else if (WriteDerivedTypes(out o, structMapping, xsiType, defaultNamespace, checkType, isNullable))
{
return(o);
}
else if (structMapping.TypeDesc.IsRoot && WriteEnumAndArrayTypes(out o, structMapping, xsiType, defaultNamespace))
{
return(o);
}
else
{
if (structMapping.TypeDesc.IsRoot)
{
return(ReadTypedPrimitive(xsiType));
}
else
{
throw CreateUnknownTypeException(xsiType);
}
}
}
if (structMapping.TypeDesc.IsNullable && isNull)
{
return(null);
}
else if (structMapping.TypeDesc.IsAbstract)
{
throw CreateAbstractTypeException(structMapping.TypeName, structMapping.Namespace);
}
else
{
if (structMapping.TypeDesc.Type != null && typeof(XmlSchemaObject).IsAssignableFrom(structMapping.TypeDesc.Type))
{
// #10589: To Support Serializing XmlSchemaObject
throw new NotImplementedException("typeof(XmlSchemaObject)");
}
object o = ReflectionCreateObject(structMapping.TypeDesc.Type);
MemberMapping[] mappings = TypeScope.GetSettableMembers(structMapping);
MemberMapping anyText = null;
MemberMapping anyElement = null;
MemberMapping anyAttribute = null;
Member anyElementMember = null;
Member anyTextMember = null;
bool isSequence = structMapping.HasExplicitSequence();
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.
}
var allMembersList = new List <Member>(mappings.Length);
var allMemberMappingList = new List <MemberMapping>(mappings.Length);
for (int i = 0; i < mappings.Length; i++)
{
MemberMapping mapping = mappings[i];
if (mapping.Text != null)
{
anyText = mapping;
}
if (mapping.Attribute != null && mapping.Attribute.Any)
{
anyAttribute = mapping;
}
if (!isSequence)
{
// find anyElement if present.
for (int j = 0; j < mapping.Elements.Length; j++)
{
if (mapping.Elements[j].Any && (mapping.Elements[j].Name == null || mapping.Elements[j].Name.Length == 0))
{
anyElement = mapping;
break;
}
}
}
else if (mapping.IsParticle && !mapping.IsSequence)
{
StructMapping declaringMapping;
structMapping.FindDeclaringMapping(mapping, out declaringMapping, structMapping.TypeName);
throw new InvalidOperationException(SR.Format(SR.XmlSequenceHierarchy, structMapping.TypeDesc.FullName, mapping.Name, declaringMapping.TypeDesc.FullName, "Order"));
}
var member = new Member(mapping);
if (mapping.TypeDesc.IsArrayLike)
{
if (mapping.TypeDesc.IsArrayLike && !(mapping.Elements.Length == 1 && mapping.Elements[0].Mapping is ArrayMapping))
{
member.Collection = new CollectionMember();
}
else if (!mapping.TypeDesc.IsArray)
{
}
}
allMemberMappingList.Add(mapping);
allMembersList.Add(member);
if (mapping == anyElement)
{
anyElementMember = member;
}
else if (mapping == anyText)
{
anyTextMember = member;
}
}
var allMembers = allMembersList.ToArray();
var allMemberMappings = allMemberMappingList.ToArray();
Action <object> unknownNodeAction = (n) => UnknownNode(n);
WriteAttributes(allMemberMappings, anyAttribute, unknownNodeAction, ref o);
Reader.MoveToElement();
if (Reader.IsEmptyElement)
{
Reader.Skip();
return(o);
}
Reader.ReadStartElement();
bool IsSequenceAllMembers = IsSequence(allMembers);
if (IsSequenceAllMembers)
{
// #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.
}
UnknownNodeAction unknownNode = UnknownNodeAction.ReadUnknownNode;
WriteMembers(ref o, allMembers, unknownNode, unknownNode, anyElementMember, anyTextMember);
ReadEndElement();
return(o);
}
}