internal MemberMapping FindDeclaringMapping(MemberMapping member, out StructMapping declaringMapping, string parent)
{
declaringMapping = null;
if (this.BaseMapping != null)
{
MemberMapping mapping = this.BaseMapping.FindDeclaringMapping(member, out declaringMapping, parent);
if (mapping != null)
{
return mapping;
}
}
if (this.members != null)
{
for (int i = 0; i < this.members.Length; i++)
{
if (this.members[i].Name == member.Name)
{
if (this.members[i].TypeDesc != member.TypeDesc)
{
throw new InvalidOperationException(Res.GetString("XmlHiddenMember", new object[] { parent, member.Name, member.TypeDesc.FullName, base.TypeName, this.members[i].Name, this.members[i].TypeDesc.FullName }));
}
if (!this.members[i].Match(member))
{
throw new InvalidOperationException(Res.GetString("XmlInvalidXmlOverride", new object[] { parent, member.Name, base.TypeName, this.members[i].Name }));
}
declaringMapping = this;
return this.members[i];
}
}
}
return null;
}
internal Member(XmlSerializationReaderILGen outerClass, string source, string arraySource, string arrayName, int i, MemberMapping mapping, bool multiRef, string choiceSource) {
this.source = source;
this.arrayName = arrayName + "_" + i.ToString(CultureInfo.InvariantCulture);
this.choiceArrayName = "choice_" + this.arrayName;
this.choiceSource = choiceSource;
if (mapping.TypeDesc.IsArrayLike) {
if (arraySource != null)
this.arraySource = arraySource;
else
this.arraySource = outerClass.GetArraySource(mapping.TypeDesc, this.arrayName, multiRef);
isArray = mapping.TypeDesc.IsArray;
isList = !isArray;
if (mapping.ChoiceIdentifier != null) {
this.choiceArraySource = outerClass.GetArraySource(mapping.TypeDesc, this.choiceArrayName, multiRef);
string a = choiceArrayName;
string c = "c" + a;
string choiceTypeFullName = mapping.ChoiceIdentifier.Mapping.TypeDesc.CSharpName;
string castString = "(" + choiceTypeFullName + "[])";
string init = a + " = " + castString +
"EnsureArrayIndex(" + a + ", " + c + ", " + outerClass.RaCodeGen.GetStringForTypeof(choiceTypeFullName) + ");";
this.choiceArraySource = init + outerClass.RaCodeGen.GetStringForArrayMember(a, c + "++", mapping.ChoiceIdentifier.Mapping.TypeDesc);
}
else {
this.choiceArraySource = this.choiceSource;
}
}
else {
this.arraySource = arraySource == null ? source : arraySource;
this.choiceArraySource = this.choiceSource;
}
this.mapping = mapping;
}
private int FindXmlnsIndex(MemberMapping[] members)
{
for (int i = 0; i < members.Length; i++)
{
if (members[i].Xmlns != null)
{
return i;
}
}
return -1;
}
private void AddMemberMetadata(CodeAttributeDeclarationCollection metadata, MemberMapping member, bool forceUseMemberName)
{
if (member.Elements.Length != 0)
{
ElementAccessor accessor = member.Elements[0];
TypeMapping mapping = accessor.Mapping;
string str = Accessor.UnescapeName(accessor.Name);
bool flag = (str == member.Name) && !forceUseMemberName;
if ((!flag || mapping.TypeDesc.IsAmbiguousDataType) || accessor.IsNullable)
{
this.AddElementMetadata(metadata, flag ? null : str, mapping.TypeDesc.IsAmbiguousDataType ? mapping.TypeDesc : null, accessor.IsNullable);
}
}
}
private static void AddUniqueAccessor(MemberMapping member, INameScope elements, INameScope attributes, bool isSequence)
{
if (member.Attribute != null)
{
AddUniqueAccessor(attributes, member.Attribute);
}
else if ((!isSequence && (member.Elements != null)) && (member.Elements.Length > 0))
{
for (int i = 0; i < member.Elements.Length; i++)
{
AddUniqueAccessor(elements, member.Elements[i]);
}
}
}
private bool WriteMemberText(out object o, Member anyText)
{
MemberMapping anyTextMapping = anyText.Mapping;
if ((Reader.NodeType == XmlNodeType.Text ||
Reader.NodeType == XmlNodeType.CDATA ||
Reader.NodeType == XmlNodeType.Whitespace ||
Reader.NodeType == XmlNodeType.SignificantWhitespace))
{
TextAccessor text = anyTextMapping.Text;
if (text.Mapping is SpecialMapping)
{
// #10592: To Support text.Mapping being SpecialMapping
throw new NotImplementedException("text.Mapping is SpecialMapping");
}
else
{
if (anyTextMapping.TypeDesc.IsArrayLike)
{
if (text.Mapping.TypeDesc.CollapseWhitespace)
{
o = CollapseWhitespace(ReadString());
}
else
{
o = ReadString();
}
}
else
{
if (text.Mapping.TypeDesc == StringTypeDesc || text.Mapping.TypeDesc.FormatterName == "String")
{
o = ReadString(null, text.Mapping.TypeDesc.CollapseWhitespace);
}
else
{
o = WritePrimitive(text.Mapping, () => ReadString());
}
}
}
return(true);
}
o = null;
return(false);
}
MemberMapping ImportFieldMapping(FieldModel model, SoapAttributes a, string ns)
{
if (a.SoapIgnore)
{
return(null);
}
MemberMapping member = new MemberMapping();
member.IsSoap = true;
member.Name = model.Name;
member.CheckShouldPersist = model.CheckShouldPersist;
member.CheckSpecified = model.CheckSpecified;
member.ReadOnly = model.ReadOnly || !model.FieldTypeDesc.HasDefaultConstructor;
ImportAccessorMapping(member, model, a, ns, XmlSchemaForm.Unqualified);
return(member);
}
void AddMemberMetadata(CodeAttributeDeclarationCollection metadata, MemberMapping member, bool forceUseMemberName)
{
if (member.Elements.Length == 0)
{
return;
}
ElementAccessor element = member.Elements[0];
TypeMapping mapping = (TypeMapping)element.Mapping;
string elemName = Accessor.UnescapeName(element.Name);
bool sameName = ((elemName == member.Name) && !forceUseMemberName);
if (!sameName || mapping.TypeDesc.IsAmbiguousDataType || element.IsNullable)
{
AddElementMetadata(metadata, sameName ? null : elemName, mapping.TypeDesc.IsAmbiguousDataType ? mapping.TypeDesc : null, element.IsNullable);
}
}
private MemberMapping ImportFieldMapping(FieldModel model, SoapAttributes a, string ns, RecursionLimiter limiter)
{
if (a.SoapIgnore)
{
return(null);
}
MemberMapping accessor = new MemberMapping {
IsSoap = true,
Name = model.Name,
CheckShouldPersist = model.CheckShouldPersist,
CheckSpecified = model.CheckSpecified,
ReadOnly = model.ReadOnly
};
this.ImportAccessorMapping(accessor, model, a, ns, XmlSchemaForm.Unqualified, limiter);
return(accessor);
}
private MembersMapping ImportMembersMapping(XmlReflectionMember[] xmlReflectionMembers, string ns, bool hasWrapperElement, bool writeAccessors, bool validateWrapperElement, RecursionLimiter limiter)
{
MembersMapping mapping = new MembersMapping {
TypeDesc = this.typeScope.GetTypeDesc(typeof(object[]))
};
MemberMapping[] mappingArray = new MemberMapping[xmlReflectionMembers.Length];
for (int i = 0; i < mappingArray.Length; i++)
{
try
{
XmlReflectionMember xmlReflectionMember = xmlReflectionMembers[i];
MemberMapping mapping2 = this.ImportMemberMapping(xmlReflectionMember, ns, xmlReflectionMembers, hasWrapperElement ? XmlSchemaForm.Unqualified : XmlSchemaForm.Qualified, limiter);
if (xmlReflectionMember.IsReturnValue && writeAccessors)
{
if (i > 0)
{
throw new InvalidOperationException(Res.GetString("XmlInvalidReturnPosition"));
}
mapping2.IsReturnValue = true;
}
mappingArray[i] = mapping2;
}
catch (Exception exception)
{
if (((exception is ThreadAbortException) || (exception is StackOverflowException)) || (exception is OutOfMemoryException))
{
throw;
}
throw this.ReflectionException(xmlReflectionMembers[i].MemberName, exception);
}
}
mapping.Members = mappingArray;
mapping.HasWrapperElement = hasWrapperElement;
if (hasWrapperElement)
{
mapping.ValidateRpcWrapperElement = validateWrapperElement;
}
mapping.WriteAccessors = writeAccessors;
mapping.IsSoap = true;
if (hasWrapperElement && !writeAccessors)
{
mapping.Namespace = ns;
}
return(mapping);
}
MembersMapping ImportMembersMapping(XmlReflectionMember[] xmlReflectionMembers, string ns, bool hasWrapperElement, bool writeAccessors, bool validateWrapperElement)
{
MembersMapping members = new MembersMapping();
members.TypeDesc = typeScope.GetTypeDesc(typeof(object[]));
MemberMapping[] mappings = new MemberMapping[xmlReflectionMembers.Length];
for (int i = 0; i < mappings.Length; i++)
{
try {
XmlReflectionMember member = xmlReflectionMembers[i];
MemberMapping mapping = ImportMemberMapping(member, ns, xmlReflectionMembers, hasWrapperElement ? XmlSchemaForm.Unqualified : XmlSchemaForm.Qualified);
if (member.IsReturnValue && writeAccessors) // no special treatment for return values with doc/enc
{
if (i > 0)
{
throw new InvalidOperationException(Res.GetString(Res.XmlInvalidReturnPosition));
}
mapping.IsReturnValue = true;
}
mappings[i] = mapping;
}
catch (Exception e) {
if (e is ThreadAbortException || e is StackOverflowException || e is OutOfMemoryException)
{
throw;
}
throw ReflectionException(xmlReflectionMembers[i].MemberName, e);
}
catch {
throw ReflectionException(xmlReflectionMembers[i].MemberName, null);
}
}
members.Members = mappings;
members.HasWrapperElement = hasWrapperElement;
if (hasWrapperElement)
{
members.ValidateRpcWrapperElement = validateWrapperElement;
}
members.WriteAccessors = writeAccessors;
members.IsSoap = true;
if (hasWrapperElement && !writeAccessors)
{
members.Namespace = ns;
}
return(members);
}
/// <include file='doc\SoapSchemaImporter.uex' path='docs/doc[@for="SoapSchemaImporter.ImportMembersMapping3"]/*' />
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public XmlMembersMapping ImportMembersMapping(string name, string ns, SoapSchemaMember[] members, bool hasWrapperElement, Type baseType, bool baseTypeCanBeIndirect)
{
XmlSchemaComplexType type = new XmlSchemaComplexType();
XmlSchemaSequence seq = new XmlSchemaSequence();
type.Particle = seq;
foreach (SoapSchemaMember member in members)
{
XmlSchemaElement element = new XmlSchemaElement();
element.Name = member.MemberName;
element.SchemaTypeName = member.MemberType;
seq.Items.Add(element);
}
CodeIdentifiers identifiers = new CodeIdentifiers();
identifiers.UseCamelCasing = true;
MembersMapping mapping = new MembersMapping();
mapping.TypeDesc = Scope.GetTypeDesc(typeof(object[]));
mapping.Members = ImportTypeMembers(type, ns, identifiers);
mapping.HasWrapperElement = hasWrapperElement;
if (baseType != null)
{
for (int i = 0; i < mapping.Members.Length; i++)
{
MemberMapping member = mapping.Members[i];
if (member.Accessor.Mapping is StructMapping)
{
MakeDerived((StructMapping)member.Accessor.Mapping, baseType, baseTypeCanBeIndirect);
}
}
}
ElementAccessor accessor = new ElementAccessor();
accessor.IsSoap = true;
accessor.Name = name;
accessor.Namespace = ns;
accessor.Mapping = mapping;
accessor.IsNullable = false;
accessor.Form = XmlSchemaForm.Qualified;
return(new XmlMembersMapping(Scope, accessor, XmlMappingAccess.Read | XmlMappingAccess.Write));
}
public int Compare(object o1, object o2)
{
MemberMapping m1 = (MemberMapping)o1;
MemberMapping m2 = (MemberMapping)o2;
bool m1Text = m1.IsText;
if (m1Text)
{
if (m2.IsText)
{
return(0);
}
return(1);
}
else if (m2.IsText)
{
return(-1);
}
if (m1.SequenceId < 0 && m2.SequenceId < 0)
{
return(0);
}
if (m1.SequenceId < 0)
{
return(1);
}
if (m2.SequenceId < 0)
{
return(-1);
}
if (m1.SequenceId < m2.SequenceId)
{
return(-1);
}
if (m1.SequenceId > m2.SequenceId)
{
return(1);
}
return(0);
}
void ExportMember(CodeTypeDeclaration codeClass, MemberMapping member)
{
string fieldType = member.GetTypeName(CodeProvider);
CodeMemberField field = new CodeMemberField(fieldType, member.Name);
field.Attributes = (field.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
field.Comments.Add(new CodeCommentStatement(Res.GetString(Res.XmlRemarks), true));
codeClass.Members.Add(field);
AddMemberMetadata(field.CustomAttributes, member, false);
if (member.CheckSpecified != SpecifiedAccessor.None)
{
field = new CodeMemberField(typeof(bool).FullName, member.Name + "Specified");
field.Attributes = (field.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
field.Comments.Add(new CodeCommentStatement(Res.GetString(Res.XmlRemarks), true));
CodeAttributeDeclaration attribute = new CodeAttributeDeclaration(typeof(SoapIgnoreAttribute).FullName);
field.CustomAttributes.Add(attribute);
codeClass.Members.Add(field);
}
}
void ExportMember(CodeTypeDeclaration codeClass, MemberMapping member, string ns)
{
CodeAttributeDeclarationCollection metadata = new CodeAttributeDeclarationCollection();
CodeMemberField field = new CodeMemberField(member.TypeDesc.FullName, member.Name);
field.Attributes = (field.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
field.Comments.Add(new CodeCommentStatement("<remarks/>", true));
codeClass.Members.Add(field);
AddMemberMetadata(field, metadata, member, ns, false);
field.CustomAttributes = metadata;
if (member.CheckSpecified)
{
field = new CodeMemberField(typeof(bool).FullName, member.Name + "Specified");
field.Attributes = (field.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
field.CustomAttributes = new CodeAttributeDeclarationCollection();
field.Comments.Add(new CodeCommentStatement("<remarks/>", true));
CodeAttributeDeclaration attribute = new CodeAttributeDeclaration(typeof(XmlIgnoreAttribute).FullName);
field.CustomAttributes.Add(attribute);
codeClass.Members.Add(field);
}
}
MemberMapping ImportMemberMapping(XmlReflectionMember xmlReflectionMember, string ns, XmlSchemaForm form)
{
SoapAttributes a = xmlReflectionMember.SoapAttributes;
if (a.SoapIgnore)
{
return(null);
}
MemberMapping member = new MemberMapping();
member.IsSoap = true;
member.Name = xmlReflectionMember.MemberName;
FieldModel model = new FieldModel(xmlReflectionMember.MemberName, xmlReflectionMember.MemberType, typeScope.GetTypeDesc(xmlReflectionMember.MemberType), false, false);
member.ReadOnly = model.ReadOnly || !model.FieldTypeDesc.HasDefaultConstructor;
ImportAccessorMapping(member, model, a, ns, form);
if (xmlReflectionMember.OverrideIsNullable)
{
member.Elements[0].IsNullable = false;
}
return(member);
}
public XmlMembersMapping ImportMembersMapping(string name, string ns, SoapSchemaMember[] members, bool hasWrapperElement, Type baseType, bool baseTypeCanBeIndirect)
{
XmlSchemaComplexType type = new XmlSchemaComplexType();
XmlSchemaSequence sequence = new XmlSchemaSequence();
type.Particle = sequence;
foreach (SoapSchemaMember member in members)
{
XmlSchemaElement item = new XmlSchemaElement {
Name = member.MemberName,
SchemaTypeName = member.MemberType
};
sequence.Items.Add(item);
}
CodeIdentifiers identifiers = new CodeIdentifiers {
UseCamelCasing = true
};
MembersMapping mapping = new MembersMapping {
TypeDesc = base.Scope.GetTypeDesc(typeof(object[])),
Members = this.ImportTypeMembers(type, ns, identifiers),
HasWrapperElement = hasWrapperElement
};
if (baseType != null)
{
for (int i = 0; i < mapping.Members.Length; i++)
{
MemberMapping mapping2 = mapping.Members[i];
if (mapping2.Accessor.Mapping is StructMapping)
{
base.MakeDerived((StructMapping)mapping2.Accessor.Mapping, baseType, baseTypeCanBeIndirect);
}
}
}
return(new XmlMembersMapping(base.Scope, new ElementAccessor {
IsSoap = true, Name = name, Namespace = ns, Mapping = mapping, IsNullable = false, Form = XmlSchemaForm.Qualified
}, XmlMappingAccess.Write | XmlMappingAccess.Read));
}
private object GenerateTypeElement(XmlTypeMapping xmlTypeMapping)
{
ElementAccessor element = xmlTypeMapping.Accessor;
TypeMapping mapping = element.Mapping;
Reader.MoveToContent();
MemberMapping member = new MemberMapping();
member.TypeDesc = mapping.TypeDesc;
member.Elements = new ElementAccessor[] { element };
UnknownNodeAction elementElseAction = UnknownNodeAction.CreateUnknownNodeException;
UnknownNodeAction elseAction = UnknownNodeAction.ReadUnknownNode;
object o = null;
Member tempMember = null;
var currentMember = new Member(member);
WriteMemberElements(ref o, null /*collectionMember*/, out tempMember, new Member[] { currentMember }, elementElseAction, elseAction, element.Any ? currentMember : null, null, xmlTypeMapping);
return(o);
}
private void ExportMember(CodeTypeDeclaration codeClass, MemberMapping member, string ns, CodeConstructor ctor)
{
CodeMemberField field;
field = new CodeMemberField(member.GetTypeName(base.CodeProvider), member.Name)
{
Attributes = (field.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public
};
field.Comments.Add(new CodeCommentStatement(Res.GetString("XmlRemarks"), true));
codeClass.Members.Add(field);
this.AddMemberMetadata(field, field.CustomAttributes, member, ns, false, field.Comments, ctor);
if (member.CheckSpecified != SpecifiedAccessor.None)
{
field = new CodeMemberField(typeof(bool).FullName, member.Name + "Specified")
{
Attributes = (field.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public
};
field.Comments.Add(new CodeCommentStatement(Res.GetString("XmlRemarks"), true));
CodeAttributeDeclaration declaration = new CodeAttributeDeclaration(typeof(XmlIgnoreAttribute).FullName);
field.CustomAttributes.Add(declaration);
codeClass.Members.Add(field);
}
}
public int Compare(object o1, object o2)
{
MemberMapping mapping = (MemberMapping) o1;
MemberMapping mapping2 = (MemberMapping) o2;
if (mapping.IsText)
{
if (mapping2.IsText)
{
return 0;
}
return 1;
}
if (mapping2.IsText)
{
return -1;
}
if ((mapping.SequenceId >= 0) || (mapping2.SequenceId >= 0))
{
if (mapping.SequenceId < 0)
{
return 1;
}
if (mapping2.SequenceId < 0)
{
return -1;
}
if (mapping.SequenceId < mapping2.SequenceId)
{
return -1;
}
if (mapping.SequenceId > mapping2.SequenceId)
{
return 1;
}
}
return 0;
}
private void WriteMappingInfo(TypeMapping mapping, string typeVariable, Type type)
{
string cSharpName = mapping.TypeDesc.CSharpName;
if (mapping is StructMapping)
{
StructMapping mapping2 = mapping as StructMapping;
for (int i = 0; i < mapping2.Members.Length; i++)
{
MemberMapping mapping3 = mapping2.Members[i];
this.WriteMemberInfo(type, cSharpName, typeVariable, mapping3.Name);
if (mapping3.CheckShouldPersist)
{
string memberName = "ShouldSerialize" + mapping3.Name;
this.WriteMethodInfo(cSharpName, typeVariable, memberName, false, new string[0]);
}
if (mapping3.CheckSpecified != SpecifiedAccessor.None)
{
string str3 = mapping3.Name + "Specified";
this.WriteMemberInfo(type, cSharpName, typeVariable, str3);
}
if (mapping3.ChoiceIdentifier != null)
{
string str4 = mapping3.ChoiceIdentifier.MemberName;
this.WriteMemberInfo(type, cSharpName, typeVariable, str4);
}
}
}
else if (mapping is EnumMapping)
{
FieldInfo[] fields = type.GetFields();
for (int j = 0; j < fields.Length; j++)
{
this.WriteMemberInfo(type, cSharpName, typeVariable, fields[j].Name);
}
}
}
private void ExportTypeMembers(XmlSchemaComplexType type, MemberMapping[] members, string ns)
{
XmlSchemaGroupBase group = new XmlSchemaSequence();
for (int i = 0; i < members.Length; i++)
{
MemberMapping mapping = members[i];
if (mapping.Elements.Length > 0)
{
bool valueTypeOptional = ((mapping.CheckSpecified != SpecifiedAccessor.None) || mapping.CheckShouldPersist) || !mapping.TypeDesc.IsValueType;
this.ExportElementAccessors(group, mapping.Elements, false, valueTypeOptional, ns);
}
}
if (group.Items.Count > 0)
{
if (type.ContentModel != null)
{
if (type.ContentModel.Content is XmlSchemaComplexContentExtension)
{
((XmlSchemaComplexContentExtension)type.ContentModel.Content).Particle = group;
}
else
{
if (!(type.ContentModel.Content is XmlSchemaComplexContentRestriction))
{
throw new InvalidOperationException(Res.GetString("XmlInvalidContent", new object[] { type.ContentModel.Content.GetType().Name }));
}
((XmlSchemaComplexContentRestriction)type.ContentModel.Content).Particle = group;
}
}
else
{
type.Particle = group;
}
}
}
void ExportTypeMembers(XmlSchemaComplexType type, MemberMapping[] members, string ns)
{
XmlSchemaGroupBase seq = new XmlSchemaSequence();
for (int i = 0; i < members.Length; i++)
{
MemberMapping member = members[i];
if (member.Elements.Length > 0)
{
bool valueTypeOptional = member.CheckSpecified || member.CheckShouldPersist || !member.TypeDesc.IsValueType;
ExportElementAccessors(seq, member.Elements, false, valueTypeOptional, ns);
}
}
if (seq.Items.Count > 0)
{
if (type.ContentModel != null)
{
if (type.ContentModel.Content is XmlSchemaComplexContentExtension)
{
((XmlSchemaComplexContentExtension)type.ContentModel.Content).Particle = seq;
}
else if (type.ContentModel.Content is XmlSchemaComplexContentRestriction)
{
((XmlSchemaComplexContentRestriction)type.ContentModel.Content).Particle = seq;
}
else
{
throw new InvalidOperationException(Res.GetString(Res.XmlInvalidContent, type.ContentModel.Content.GetType().Name));
}
}
else
{
type.Particle = seq;
}
}
}
void WriteArray(string source, string arrayName, ArrayMapping arrayMapping, bool readOnly, bool isNullable, int fixupIndex) {
if (arrayMapping.IsSoap) {
Writer.Write("object rre = ");
Writer.Write(fixupIndex >= 0 ? "ReadReferencingElement" : "ReadReferencedElement");
Writer.Write("(");
WriteID(arrayMapping.TypeName);
Writer.Write(", ");
WriteID(arrayMapping.Namespace);
if (fixupIndex >= 0) {
Writer.Write(", ");
Writer.Write("out fixup.Ids[");
Writer.Write((fixupIndex).ToString(CultureInfo.InvariantCulture));
Writer.Write("]");
}
Writer.WriteLine(");");
TypeDesc td = arrayMapping.TypeDesc;
if (td.IsEnumerable || td.IsCollection) {
Writer.WriteLine("if (rre != null) {");
Writer.Indent++;
WriteAddCollectionFixup(td, readOnly, source, "rre");
Writer.Indent--;
Writer.WriteLine("}");
}
else {
Writer.WriteLine("try {");
Writer.Indent++;
WriteSourceBeginTyped(source, arrayMapping.TypeDesc);
Writer.Write("rre");
WriteSourceEnd(source);
Writer.WriteLine(";");
WriteCatchCastException(arrayMapping.TypeDesc, "rre", null);
}
}
else {
Writer.WriteLine("if (!ReadNull()) {");
Writer.Indent++;
MemberMapping memberMapping = new MemberMapping();
memberMapping.Elements = arrayMapping.Elements;
memberMapping.TypeDesc = arrayMapping.TypeDesc;
memberMapping.ReadOnly = readOnly;
Member member = new Member(this, source, arrayName, 0, memberMapping, false);
member.IsNullable = false;//Note, [....]: IsNullable is set to false since null condition (xsi:nil) is already handled by 'ReadNull()'
Member[] members = new Member[] { member };
WriteMemberBegin(members);
if (readOnly) {
Writer.Write("if (((object)(");
Writer.Write(member.ArrayName);
Writer.Write(") == null) || ");
}
else {
Writer.Write("if (");
}
Writer.WriteLine("(Reader.IsEmptyElement)) {");
Writer.Indent++;
Writer.WriteLine("Reader.Skip();");
Writer.Indent--;
Writer.WriteLine("}");
Writer.WriteLine("else {");
Writer.Indent++;
Writer.WriteLine("Reader.ReadStartElement();");
int loopIndex = WriteWhileNotLoopStart();
Writer.Indent++;
string unknownNode = "UnknownNode(null, " + ExpectedElements(members) + ");";
WriteMemberElements(members, unknownNode, unknownNode, null, null, null);
Writer.WriteLine("Reader.MoveToContent();");
WriteWhileLoopEnd(loopIndex);
Writer.Indent--;
Writer.WriteLine("ReadEndElement();");
Writer.WriteLine("}");
WriteMemberEnd(members, false);
Writer.Indent--;
Writer.WriteLine("}");
if (isNullable) {
Writer.WriteLine("else {");
Writer.Indent++;
member.IsNullable = true;
WriteMemberBegin(members);
WriteMemberEnd(members);
Writer.Indent--;
Writer.WriteLine("}");
}
}
}
string GenerateTypeElement(XmlTypeMapping xmlTypeMapping) {
ElementAccessor element = xmlTypeMapping.Accessor;
TypeMapping mapping = element.Mapping;
string methodName = NextMethodName(element.Name);
Writer.WriteLine();
Writer.Write("public object ");
Writer.Write(methodName);
Writer.WriteLine("() {");
Writer.Indent++;
Writer.WriteLine("object o = null;");
MemberMapping member = new MemberMapping();
member.TypeDesc = mapping.TypeDesc;
//member.ReadOnly = !mapping.TypeDesc.HasDefaultConstructor;
member.Elements = new ElementAccessor[] { element };
Member[] members = new Member[] { new Member(this,"o", "o", "a", 0, member) };
Writer.WriteLine("Reader.MoveToContent();");
string unknownNode = "UnknownNode(null, " + ExpectedElements(members) + ");";
WriteMemberElements(members, "throw CreateUnknownNodeException();", unknownNode, element.Any ? members[0] : null, null, null);
if (element.IsSoap) {
Writer.WriteLine("Referenced(o);");
Writer.WriteLine("ReadReferencedElements();");
}
Writer.WriteLine("return (object)o;");
Writer.Indent--;
Writer.WriteLine("}");
return methodName;
}
string GetChoiceIdentifierSource(MemberMapping mapping, string parent, TypeDesc parentTypeDesc) {
if (mapping.ChoiceIdentifier == null) return "";
CodeIdentifier.CheckValidIdentifier(mapping.ChoiceIdentifier.MemberName);
return RaCodeGen.GetStringForMember(parent, mapping.ChoiceIdentifier.MemberName, parentTypeDesc);
}
internal Member(XmlSerializationReaderCodeGen outerClass, string source, string arrayName, int i, MemberMapping mapping, bool multiRef)
: this(outerClass, source, null, arrayName, i, mapping, multiRef, null) {
}
internal XmlMemberMapping(MemberMapping mapping)
{
this.mapping = mapping;
}
void AddMemberMetadata(CodeAttributeDeclarationCollection metadata, MemberMapping member, bool forceUseMemberName) {
if (member.Elements.Length == 0) return;
ElementAccessor element = member.Elements[0];
TypeMapping mapping = (TypeMapping)element.Mapping;
string elemName = Accessor.UnescapeName(element.Name);
bool sameName = ((elemName == member.Name) && !forceUseMemberName);
if (!sameName || mapping.TypeDesc.IsAmbiguousDataType || element.IsNullable) {
AddElementMetadata(metadata, sameName ? null : elemName, mapping.TypeDesc.IsAmbiguousDataType ? mapping.TypeDesc : null, element.IsNullable);
}
}
MemberMapping ImportMemberMapping(XmlReflectionMember xmlReflectionMember, string ns, XmlReflectionMember[] xmlReflectionMembers, XmlSchemaForm form) {
SoapAttributes a = xmlReflectionMember.SoapAttributes;
if (a.SoapIgnore) return null;
MemberMapping member = new MemberMapping();
member.IsSoap = true;
member.Name = xmlReflectionMember.MemberName;
bool checkSpecified = XmlReflectionImporter.FindSpecifiedMember(xmlReflectionMember.MemberName, xmlReflectionMembers) != null;
FieldModel model = new FieldModel(xmlReflectionMember.MemberName, xmlReflectionMember.MemberType, typeScope.GetTypeDesc(xmlReflectionMember.MemberType), checkSpecified, false);
member.CheckShouldPersist = model.CheckShouldPersist;
member.CheckSpecified = model.CheckSpecified;
member.ReadOnly = model.ReadOnly; // || !model.FieldTypeDesc.HasDefaultConstructor;
ImportAccessorMapping(member, model, a, ns, form);
if (xmlReflectionMember.OverrideIsNullable)
member.Elements[0].IsNullable = false;
return member;
}
StructMapping ImportStructLikeMapping(StructModel model)
{
if (model.TypeDesc.Kind == TypeKind.Root)
{
return(GetRootMapping());
}
SoapAttributes a = GetAttributes(model.Type);
string typeNs = defaultNs;
if (a.SoapType != null && a.SoapType.Namespace != null)
{
typeNs = a.SoapType.Namespace;
}
string typeName = string.Empty;
if (a.SoapType != null)
{
typeName = a.SoapType.TypeName;
}
if (typeName.Length == 0)
{
typeName = model.TypeDesc.Name;
}
StructMapping mapping = (StructMapping)GetTypeMapping(typeName, typeNs, model.TypeDesc);
if (mapping == null)
{
mapping = new StructMapping();
mapping.IsSoap = true;
mapping.TypeDesc = model.TypeDesc;
mapping.Namespace = typeNs;
mapping.TypeName = typeName;
if (a.SoapType != null)
{
mapping.IncludeInSchema = a.SoapType.IncludeInSchema;
}
typeScope.AddTypeMapping(mapping);
types.Add(typeName, typeNs, mapping);
if (model.TypeDesc.BaseTypeDesc != null)
{
mapping.BaseMapping = ImportStructLikeMapping((StructModel)modelScope.GetTypeModel(model.Type.BaseType, false));
}
ArrayList members = new ArrayList();
foreach (MemberInfo memberInfo in model.GetMemberInfos())
{
SoapAttributes memberAttrs = GetAttributes(memberInfo);
if (memberAttrs.SoapIgnore)
{
continue;
}
FieldModel fieldModel = model.GetFieldModel(memberInfo);
if (fieldModel == null)
{
continue;
}
MemberMapping member = ImportFieldMapping(fieldModel, memberAttrs, mapping.Namespace);
if (member == null)
{
continue;
}
if (!member.TypeDesc.IsPrimitive && !member.TypeDesc.IsEnum)
{
if (model.TypeDesc.IsValueType)
{
throw new NotSupportedException(Res.GetString(Res.XmlRpcRefsInValueType, model.TypeDesc.FullName));
}
if (member.TypeDesc.IsValueType)
{
throw new NotSupportedException(Res.GetString(Res.XmlRpcNestedValueType, member.TypeDesc.FullName));
}
}
if (mapping.BaseMapping != null)
{
if (mapping.BaseMapping.Declares(member, mapping.TypeName))
{
continue;
}
}
members.Add(member);
}
mapping.Members = (MemberMapping[])members.ToArray(typeof(MemberMapping));
if (mapping.BaseMapping == null)
{
mapping.BaseMapping = GetRootMapping();
}
IncludeTypes(model.Type);
}
return(mapping);
}
private MemberMapping(MemberMapping mapping)
: base(mapping)
{
_name = mapping._name;
_checkShouldPersist = mapping._checkShouldPersist;
_checkSpecified = mapping._checkSpecified;
_isReturnValue = mapping._isReturnValue;
_readOnly = mapping._readOnly;
_sequenceId = mapping._sequenceId;
_memberInfo = mapping._memberInfo;
_checkSpecifiedMemberInfo = mapping._checkSpecifiedMemberInfo;
_checkShouldPersistMethodInfo = mapping._checkShouldPersistMethodInfo;
}
internal bool Declares(MemberMapping member, string parent)
{
StructMapping m;
return (FindDeclaringMapping(member, out m, parent) != null);
}
internal MemberMapping FindDeclaringMapping(MemberMapping member, out StructMapping declaringMapping, string parent)
{
declaringMapping = null;
if (BaseMapping != null)
{
MemberMapping baseMember = BaseMapping.FindDeclaringMapping(member, out declaringMapping, parent);
if (baseMember != null) return baseMember;
}
if (_members == null) return null;
for (int i = 0; i < _members.Length; i++)
{
if (_members[i].Name == member.Name)
{
if (_members[i].TypeDesc != member.TypeDesc)
throw new InvalidOperationException(SR.Format(SR.XmlHiddenMember, parent, member.Name, member.TypeDesc.FullName, this.TypeName, _members[i].Name, _members[i].TypeDesc.FullName));
else if (!_members[i].Match(member))
{
throw new InvalidOperationException(SR.Format(SR.XmlInvalidXmlOverride, parent, member.Name, this.TypeName, _members[i].Name));
}
declaringMapping = this;
return _members[i];
}
}
return null;
}
private void WriteStructMethod(StructMapping mapping, string n, string ns, object o, bool isNullable, bool needType, XmlMapping parentMapping = null)
{
if (mapping.IsSoap && mapping.TypeDesc.IsRoot)
{
return;
}
if (mapping.IsSoap)
{
}
else
{
if (o == null)
{
if (isNullable)
{
WriteNullTagLiteral(n, ns);
}
return;
}
if (!needType &&
o.GetType() != mapping.TypeDesc.Type)
{
if (WriteDerivedTypes(mapping, n, ns, o, isNullable))
{
return;
}
if (mapping.TypeDesc.IsRoot)
{
if (WriteEnumAndArrayTypes(mapping, o, n, ns, parentMapping))
{
return;
}
WriteTypedPrimitive(n, ns, o, true);
return;
}
throw CreateUnknownTypeException(o);
}
}
if (!mapping.TypeDesc.IsAbstract)
{
if (mapping.TypeDesc.Type != null && typeof(XmlSchemaObject).IsAssignableFrom(mapping.TypeDesc.Type))
{
EscapeName = false;
}
XmlSerializerNamespaces xmlnsSource = null;
MemberMapping[] members = TypeScope.GetAllMembers(mapping);
int xmlnsMember = FindXmlnsIndex(members);
if (xmlnsMember >= 0)
{
MemberMapping member = members[xmlnsMember];
xmlnsSource = (XmlSerializerNamespaces)GetMemberValue(o, member.Name);
}
if (!mapping.IsSoap)
{
WriteStartElement(n, ns, o, false, xmlnsSource);
if (!mapping.TypeDesc.IsRoot)
{
if (needType)
{
WriteXsiType(mapping.TypeName, mapping.Namespace);
}
}
}
else if (xmlnsSource != null)
{
WriteNamespaceDeclarations(xmlnsSource);
}
for (int i = 0; i < members.Length; i++)
{
MemberMapping m = members[i];
string memberName = m.Name;
object memberValue = GetMemberValue(o, memberName);
bool isSpecified = true;
bool shouldPersist = true;
if (m.CheckSpecified != SpecifiedAccessor.None)
{
string specifiedMemberName = m.Name + "Specified";
isSpecified = (bool)GetMemberValue(o, specifiedMemberName);
}
if (m.CheckShouldPersist)
{
string methodInvoke = "ShouldSerialize" + m.Name;
MethodInfo method = o.GetType().GetTypeInfo().GetDeclaredMethod(methodInvoke);
shouldPersist = (bool)method.Invoke(o, Array.Empty <object>());
}
if (m.Attribute != null)
{
if (isSpecified && shouldPersist)
{
WriteMember(memberValue, m.Attribute, m.TypeDesc, o);
}
}
}
for (int i = 0; i < members.Length; i++)
{
MemberMapping m = members[i];
string memberName = m.Name;
object memberValue = GetMemberValue(o, memberName);
bool isSpecified = true;
bool shouldPersist = true;
if (m.CheckSpecified != SpecifiedAccessor.None)
{
string specifiedMemberName = m.Name + "Specified";
isSpecified = (bool)GetMemberValue(o, specifiedMemberName);
}
if (m.CheckShouldPersist)
{
string methodInvoke = "ShouldSerialize" + m.Name;
MethodInfo method = o.GetType().GetTypeInfo().GetDeclaredMethod(methodInvoke);
shouldPersist = (bool)method.Invoke(o, Array.Empty <object>());
}
if (m.Xmlns != null)
{
continue;
}
bool checkShouldPersist = m.CheckShouldPersist && (m.Elements.Length > 0 || m.Text != null);
if (!checkShouldPersist)
{
shouldPersist = true;
}
object choiceSource = null;
if (m.ChoiceIdentifier != null)
{
choiceSource = GetMemberValue(o, m.ChoiceIdentifier.MemberName);
}
if (isSpecified && shouldPersist)
{
WriteMember(memberValue, choiceSource, m.ElementsSortedByDerivation, m.Text, m.ChoiceIdentifier, m.TypeDesc, true, parentMapping);
}
}
if (!mapping.IsSoap)
{
WriteEndElement(o);
}
}
}
void ExportMember(CodeTypeDeclaration codeClass, MemberMapping member) {
CodeAttributeDeclarationCollection metadata = new CodeAttributeDeclarationCollection();
CodeMemberField field = new CodeMemberField(member.TypeDesc.FullName, member.Name);
field.Attributes = (field.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
field.Comments.Add(new CodeCommentStatement("<remarks/>", true));
codeClass.Members.Add(field);
AddMemberMetadata(metadata, member, false);
field.CustomAttributes = metadata;
}
private static void PopulateMemberInfos(StructMapping structMapping, MemberMapping[] memberMappings, System.Collections.Generic.Dictionary<string, MemberInfo> memberInfos)
{
memberInfos.Clear();
for (int i = 0; i < memberMappings.Length; ++i)
{
memberInfos[memberMappings[i].Name] = memberMappings[i].MemberInfo;
if (memberMappings[i].ChoiceIdentifier != null)
memberInfos[memberMappings[i].ChoiceIdentifier.MemberName] = memberMappings[i].ChoiceIdentifier.MemberInfo;
if (memberMappings[i].CheckSpecifiedMemberInfo != null)
memberInfos[memberMappings[i].Name + "Specified"] = memberMappings[i].CheckSpecifiedMemberInfo;
}
// The scenario here is that user has one base class A and one derived class B and wants to serialize/deserialize an object of B.
// There's one virtual property defined in A and overrided by B. Without the replacing logic below, the code generated will always
// try to access the property defined in A, rather than B.
// The logic here is to:
// 1) Check current members inside memberInfos dictionary and figure out whether there's any override or new properties defined in the derived class.
// If so, replace the one on the base class with the one on the derived class.
// 2) Do the same thing for the memberMapping array. Note that we need to create a new copy of MemberMapping object since the old one could still be referenced
// by the StructMapping of the baseclass, so updating it directly could lead to other issues.
Dictionary<string, MemberInfo> replaceList = null;
MemberInfo replacedInfo = null;
foreach (KeyValuePair<string, MemberInfo> pair in memberInfos)
{
if (ShouldBeReplaced(pair.Value, structMapping.TypeDesc.Type, out replacedInfo))
{
if (replaceList == null)
{
replaceList = new Dictionary<string, MemberInfo>();
}
replaceList.Add(pair.Key, replacedInfo);
}
}
if (replaceList != null)
{
foreach (KeyValuePair<string, MemberInfo> pair in replaceList)
{
memberInfos[pair.Key] = pair.Value;
}
for (int i = 0; i < memberMappings.Length; i++)
{
MemberInfo mi;
if (replaceList.TryGetValue(memberMappings[i].Name, out mi))
{
MemberMapping newMapping = memberMappings[i].Clone();
newMapping.MemberInfo = mi;
memberMappings[i] = newMapping;
}
}
}
}
void ExportMember(CodeTypeDeclaration codeClass, MemberMapping member) {
string fieldType = member.GetTypeName(CodeProvider);
CodeMemberField field = new CodeMemberField(fieldType, member.Name);
field.Attributes = (field.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
field.Comments.Add(new CodeCommentStatement(Res.GetString(Res.XmlRemarks), true));
codeClass.Members.Add(field);
AddMemberMetadata(field.CustomAttributes, member, false);
if (member.CheckSpecified != SpecifiedAccessor.None) {
field = new CodeMemberField(typeof(bool).FullName, member.Name + "Specified");
field.Attributes = (field.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
field.Comments.Add(new CodeCommentStatement(Res.GetString(Res.XmlRemarks), true));
CodeAttributeDeclaration attribute = new CodeAttributeDeclaration(typeof(SoapIgnoreAttribute).FullName);
field.CustomAttributes.Add(attribute);
codeClass.Members.Add(field);
}
}
void ImportAccessorMapping(MemberMapping accessor, FieldModel model, SoapAttributes a, string ns, XmlSchemaForm form) {
Type accessorType = model.FieldType;
string accessorName = model.Name;
accessor.TypeDesc = typeScope.GetTypeDesc(accessorType);
if (accessor.TypeDesc.IsVoid) {
throw new InvalidOperationException(Res.GetString(Res.XmlInvalidVoid));
}
SoapAttributeFlags flags = a.SoapFlags;
if ((flags & SoapAttributeFlags.Attribute) == SoapAttributeFlags.Attribute) {
if (!accessor.TypeDesc.IsPrimitive && !accessor.TypeDesc.IsEnum)
throw new InvalidOperationException(Res.GetString(Res.XmlIllegalSoapAttribute, accessorName, accessor.TypeDesc.FullName));
if ((flags & SoapAttributeFlags.Attribute) != flags)
throw new InvalidOperationException(Res.GetString(Res.XmlInvalidElementAttribute));
AttributeAccessor attribute = new AttributeAccessor();
attribute.Name = Accessor.EscapeQName(a.SoapAttribute == null || a.SoapAttribute.AttributeName.Length == 0 ? accessorName : a.SoapAttribute.AttributeName);
attribute.Namespace = a.SoapAttribute == null || a.SoapAttribute.Namespace == null ? ns : a.SoapAttribute.Namespace;
attribute.Form = XmlSchemaForm.Qualified; // attributes are always qualified since they're only used for encoded soap headers
attribute.Mapping = ImportTypeMapping(modelScope.GetTypeModel(accessorType), (a.SoapAttribute == null ? String.Empty : a.SoapAttribute.DataType));
attribute.Default = GetDefaultValue(model.FieldTypeDesc, a);
accessor.Attribute = attribute;
accessor.Elements = new ElementAccessor[0];
}
else {
if ((flags & SoapAttributeFlags.Element) != flags)
throw new InvalidOperationException(Res.GetString(Res.XmlInvalidElementAttribute));
ElementAccessor element = new ElementAccessor();
element.IsSoap = true;
element.Name = XmlConvert.EncodeLocalName(a.SoapElement == null || a.SoapElement.ElementName.Length == 0 ? accessorName : a.SoapElement.ElementName);
element.Namespace = ns;
element.Form = form;
element.Mapping = ImportTypeMapping(modelScope.GetTypeModel(accessorType), (a.SoapElement == null ? String.Empty : a.SoapElement.DataType));
if (a.SoapElement != null)
element.IsNullable = a.SoapElement.IsNullable;
accessor.Elements = new ElementAccessor[] { element };
}
}
private void ExportTypeMembers(XmlSchemaComplexType type, MemberMapping[] members, string name, string ns, bool hasSimpleContent, bool openModel)
{
XmlSchemaGroupBase group = new XmlSchemaSequence();
TypeMapping mapping = null;
for (int i = 0; i < members.Length; i++)
{
MemberMapping mapping2 = members[i];
if (!mapping2.Ignore)
{
if (mapping2.Text != null)
{
if (mapping != null)
{
throw new InvalidOperationException(Res.GetString("XmlIllegalMultipleText", new object[] { name }));
}
mapping = mapping2.Text.Mapping;
}
if (mapping2.Elements.Length > 0)
{
bool repeats = mapping2.TypeDesc.IsArrayLike && ((mapping2.Elements.Length != 1) || !(mapping2.Elements[0].Mapping is ArrayMapping));
bool valueTypeOptional = (mapping2.CheckSpecified != SpecifiedAccessor.None) || mapping2.CheckShouldPersist;
this.ExportElementAccessors(group, mapping2.Elements, repeats, valueTypeOptional, ns);
}
}
}
if (group.Items.Count > 0)
{
if (type.ContentModel != null)
{
if (type.ContentModel.Content is XmlSchemaComplexContentRestriction)
{
((XmlSchemaComplexContentRestriction) type.ContentModel.Content).Particle = group;
}
else
{
if (!(type.ContentModel.Content is XmlSchemaComplexContentExtension))
{
throw new InvalidOperationException(Res.GetString("XmlInvalidContent", new object[] { type.ContentModel.Content.GetType().Name }));
}
((XmlSchemaComplexContentExtension) type.ContentModel.Content).Particle = group;
}
}
else
{
type.Particle = group;
}
}
if (mapping != null)
{
if (hasSimpleContent)
{
if ((mapping is PrimitiveMapping) && (group.Items.Count == 0))
{
PrimitiveMapping mapping3 = (PrimitiveMapping) mapping;
if (mapping3.IsList)
{
type.IsMixed = true;
}
else
{
if (mapping3.IsAnonymousType)
{
throw new InvalidOperationException(Res.GetString("XmlAnonymousBaseType", new object[] { mapping.TypeDesc.Name, mapping3.TypeDesc.Name, "AnonymousType", "false" }));
}
XmlSchemaSimpleContent content = new XmlSchemaSimpleContent();
XmlSchemaSimpleContentExtension extension = new XmlSchemaSimpleContentExtension();
content.Content = extension;
type.ContentModel = content;
extension.BaseTypeName = this.ExportPrimitiveMapping(mapping3, ns);
}
}
}
else
{
type.IsMixed = true;
}
}
bool flag3 = false;
for (int j = 0; j < members.Length; j++)
{
if (members[j].Attribute != null)
{
this.ExportAttributeAccessor(type, members[j].Attribute, (members[j].CheckSpecified != SpecifiedAccessor.None) || members[j].CheckShouldPersist, ns);
if (members[j].Attribute.Any)
{
flag3 = true;
}
}
}
if (openModel && !flag3)
{
AttributeAccessor accessor = new AttributeAccessor {
Any = true
};
this.ExportAttributeAccessor(type, accessor, false, ns);
}
}
internal bool Declares(MemberMapping member, string parent)
{
StructMapping m;
return(FindDeclaringMapping(member, out m, parent) != null);
}
private void WriteAttributes(MemberMapping[] members, MemberMapping anyAttribute, Action <object> elseCall, ref object o)
{
MemberMapping xmlnsMember = null;
var attributes = new List <AttributeAccessor>();
while (Reader.MoveToNextAttribute())
{
bool memberFound = false;
foreach (var member in members)
{
if (member.Xmlns != null)
{
xmlnsMember = member;
continue;
}
if (member.Ignore)
{
continue;
}
AttributeAccessor attribute = member.Attribute;
if (attribute == null)
{
continue;
}
if (attribute.Any)
{
continue;
}
attributes.Add(attribute);
if (attribute.IsSpecialXmlNamespace)
{
memberFound = XmlNodeEqual(Reader, attribute.Name, XmlReservedNs.NsXml);
}
else
{
memberFound = XmlNodeEqual(Reader, attribute.Name, attribute.Form == XmlSchemaForm.Qualified ? attribute.Namespace : "");
}
if (memberFound)
{
WriteAttribute(o, member);
memberFound = true;
break;
}
}
if (memberFound)
{
continue;
}
bool flag2 = false;
if (xmlnsMember != null)
{
if (IsXmlnsAttribute(Reader.Name))
{
if (GetMemberType(xmlnsMember.MemberInfo) == typeof(XmlSerializerNamespaces))
{
var xmlnsMemberSource = GetMemberValue(o, xmlnsMember.MemberInfo) as XmlSerializerNamespaces;
if (xmlnsMemberSource == null)
{
xmlnsMemberSource = new XmlSerializerNamespaces();
SetMemberValue(o, xmlnsMemberSource, xmlnsMember.MemberInfo);
}
xmlnsMemberSource.Add(Reader.Name.Length == 5 ? "" : Reader.LocalName, Reader.Value);
}
else
{
throw new InvalidOperationException("xmlnsMemberSource is not of type XmlSerializerNamespaces");
}
}
else
{
flag2 = true;
}
}
else if (!IsXmlnsAttribute(Reader.Name))
{
flag2 = true;
}
if (flag2)
{
if (anyAttribute != null)
{
var attr = Document.ReadNode(Reader) as XmlAttribute;
ParseWsdlArrayType(attr);
WriteAttribute(o, anyAttribute, attr);
}
else
{
elseCall(o);
}
}
}
}
internal Member(XmlSerializationReaderCodeGen outerClass, string source, string arraySource, string arrayName, int i, MemberMapping mapping, string choiceSource)
: this (outerClass, source, arraySource, arrayName, i, mapping, false, choiceSource) {
}
public Member(MemberMapping mapping)
{
Mapping = mapping;
}
string GetChoiceIdentifierSource(MemberMapping[] mappings, MemberMapping member) {
string choiceSource = null;
if (member.ChoiceIdentifier != null) {
for (int j = 0; j < mappings.Length; j++) {
if (mappings[j].Name == member.ChoiceIdentifier.MemberName) {
choiceSource = "p[" + j.ToString(CultureInfo.InvariantCulture) + "]";
break;
}
}
#if DEBUG
// use exception in the place of Debug.Assert to avoid throwing asserts from a server process such as aspnet_ewp.exe
if (choiceSource == null) throw new InvalidOperationException(Res.GetString(Res.XmlInternalErrorDetails, "Can not find " + member.ChoiceIdentifier.MemberName + " in the members mapping."));
#endif
}
return choiceSource;
}
public Member(MemberMapping mapping, CollectionMember collectionMember) : this(mapping)
{
Collection = collectionMember;
}
void InitializeValueTypes(string arrayName, MemberMapping[] mappings) {
for (int i = 0; i < mappings.Length; i++) {
if (!mappings[i].TypeDesc.IsValueType)
continue;
Writer.Write(arrayName);
Writer.Write("[");
Writer.Write(i.ToString(CultureInfo.InvariantCulture));
Writer.Write("] = ");
if (mappings[i].TypeDesc.IsOptionalValue && mappings[i].TypeDesc.BaseTypeDesc.UseReflection) {
Writer.Write("null");
}
else {
Writer.Write(RaCodeGen.GetStringForCreateInstance(mappings[i].TypeDesc.CSharpName, mappings[i].TypeDesc.UseReflection, false, false));
}
Writer.WriteLine(";");
}
}
MemberMapping(MemberMapping mapping)
: base(mapping)
{
this.name = mapping.name;
this.checkShouldPersist = mapping.checkShouldPersist;
this.checkSpecified = mapping.checkSpecified;
this.isReturnValue = mapping.isReturnValue;
this.readOnly = mapping.readOnly;
this.sequenceId = mapping.sequenceId;
this.memberInfo = mapping.memberInfo;
this.checkSpecifiedMemberInfo = mapping.checkSpecifiedMemberInfo;
this.checkShouldPersistMethodInfo = mapping.checkShouldPersistMethodInfo;
}
void WriteEnumAndArrayTypes() {
foreach (TypeScope scope in Scopes) {
foreach (Mapping m in scope.TypeMappings) {
if (m.IsSoap)
continue;
if (m is EnumMapping) {
EnumMapping mapping = (EnumMapping)m;
Writer.Write("else if (");
WriteQNameEqual("xsiType", mapping.TypeName, mapping.Namespace);
Writer.WriteLine(") {");
Writer.Indent++;
Writer.WriteLine("Reader.ReadStartElement();");
string methodName = ReferenceMapping(mapping);
#if DEBUG
// use exception in the place of Debug.Assert to avoid throwing asserts from a server process such as aspnet_ewp.exe
if (methodName == null) throw new InvalidOperationException(Res.GetString(Res.XmlInternalErrorMethod, mapping.TypeDesc.Name));
#endif
Writer.Write("object e = ");
Writer.Write(methodName);
Writer.WriteLine("(CollapseWhitespace(Reader.ReadString()));");
Writer.WriteLine("ReadEndElement();");
Writer.WriteLine("return e;");
Writer.Indent--;
Writer.WriteLine("}");
}
else if (m is ArrayMapping) {
ArrayMapping mapping = (ArrayMapping) m;
if (mapping.TypeDesc.HasDefaultConstructor) {
Writer.Write("else if (");
WriteQNameEqual("xsiType", mapping.TypeName, mapping.Namespace);
Writer.WriteLine(") {");
Writer.Indent++;
MemberMapping memberMapping = new MemberMapping();
memberMapping.TypeDesc = mapping.TypeDesc;
memberMapping.Elements = mapping.Elements;
Member member = new Member(this,"a", "z", 0, memberMapping);
TypeDesc td = mapping.TypeDesc;
string fullTypeName = mapping.TypeDesc.CSharpName;
if (td.UseReflection){
if (td.IsArray)
Writer.Write(typeof(Array).FullName);
else
Writer.Write("object");
}
else
Writer.Write(fullTypeName);
Writer.Write(" a = ");
if (mapping.TypeDesc.IsValueType) {
Writer.Write(RaCodeGen.GetStringForCreateInstance(fullTypeName, td.UseReflection, false, false));
Writer.WriteLine(";");
}
else
Writer.WriteLine("null;");
WriteArray(member.Source, member.ArrayName, mapping, false, false, -1);
Writer.WriteLine("return a;");
Writer.Indent--;
Writer.WriteLine("}");
}
}
}
}
}
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);
}
}
void AddMemberMetadata(CodeMemberField field, CodeAttributeDeclarationCollection metadata, MemberMapping member, string ns, bool forceUseMemberName)
{
if (member.Xmlns != null)
{
CodeAttributeDeclaration attribute = new CodeAttributeDeclaration(typeof(XmlNamespaceDeclarationsAttribute).FullName);
metadata.Add(attribute);
}
else if (member.Attribute != null)
{
AttributeAccessor attribute = member.Attribute;
if (attribute.Any)
{
ExportAnyAttribute(metadata);
}
else
{
TypeMapping mapping = (TypeMapping)attribute.Mapping;
string attrName = Accessor.UnescapeName(attribute.Name);
bool sameType = mapping.TypeDesc == member.TypeDesc ||
(member.TypeDesc.IsArrayLike && mapping.TypeDesc == member.TypeDesc.ArrayElementTypeDesc);
bool sameName = attrName == member.Name && !forceUseMemberName;
bool sameNs = attribute.Namespace == ns;
bool defaultForm = attribute.Form != XmlSchemaForm.Qualified;
ExportAttribute(metadata,
sameName ? null : attrName,
sameNs ? null : attribute.Namespace,
sameType ? null : mapping.TypeDesc,
mapping.TypeDesc,
defaultForm ? XmlSchemaForm.None : attribute.Form);
if (attribute.HasDefault)
{
AddDefaultValueAttribute(field, metadata, attribute.Default, mapping);
}
}
}
else
{
if (member.Text != null)
{
TypeMapping mapping = (TypeMapping)member.Text.Mapping;
bool sameType = mapping.TypeDesc == member.TypeDesc ||
(member.TypeDesc.IsArrayLike && mapping.TypeDesc == member.TypeDesc.ArrayElementTypeDesc);
ExportText(metadata, sameType ? null : mapping.TypeDesc, mapping.TypeDesc.IsAmbiguousDataType ? mapping.TypeDesc.DataType.Name : null);
}
if (member.Elements.Length == 1)
{
ElementAccessor element = member.Elements[0];
TypeMapping mapping = (TypeMapping)element.Mapping;
string elemName = Accessor.UnescapeName(element.Name);
bool sameName = ((elemName == member.Name) && !forceUseMemberName);
bool isArray = mapping is ArrayMapping;
bool sameNs = element.Namespace == ns;
bool defaultForm = element.Form != XmlSchemaForm.Unqualified;
if (element.Any)
{
ExportAnyElement(metadata, elemName, sameNs ? null : element.Namespace);
}
else if (isArray)
{
bool sameType = mapping.TypeDesc == member.TypeDesc;
ArrayMapping array = (ArrayMapping)mapping;
if (!sameName || !sameNs || element.IsNullable || !defaultForm)
{
ExportArray(metadata, sameName ? null : elemName, sameNs ? null : element.Namespace, element.IsNullable, defaultForm ? XmlSchemaForm.None : element.Form);
}
ExportArrayElements(metadata, array, ns, member.TypeDesc.ArrayElementTypeDesc, 0);
}
else
{
bool sameType = mapping.TypeDesc == member.TypeDesc ||
(member.TypeDesc.IsArrayLike && mapping.TypeDesc == member.TypeDesc.ArrayElementTypeDesc);
if (member.TypeDesc.IsArrayLike)
{
sameName = false;
}
if (member.TypeDesc.IsAmbiguousDataType || member.TypeDesc.IsArrayLike || !sameName || !sameType || !sameNs || element.IsNullable || !defaultForm)
{
ExportElement(metadata, sameName ? null : elemName, sameNs ? null : element.Namespace, sameType ? null : mapping.TypeDesc, mapping.TypeDesc, element.IsNullable, defaultForm ? XmlSchemaForm.None : element.Form);
}
}
if (element.HasDefault)
{
AddDefaultValueAttribute(field, metadata, element.Default, mapping);
}
}
else
{
for (int i = 0; i < member.Elements.Length; i++)
{
ElementAccessor element = member.Elements[i];
string elemName = Accessor.UnescapeName(element.Name);
bool sameNs = element.Namespace == ns;
if (element.Any)
{
ExportAnyElement(metadata, elemName, sameNs ? null : element.Namespace);
}
else
{
bool defaultForm = element.Form != XmlSchemaForm.Unqualified;
ExportElement(metadata, elemName, sameNs ? null : element.Namespace, ((TypeMapping)element.Mapping).TypeDesc, ((TypeMapping)element.Mapping).TypeDesc, element.IsNullable, defaultForm ? XmlSchemaForm.None : element.Form);
}
}
}
if (member.ChoiceIdentifier != null)
{
CodeAttributeDeclaration attribute = new CodeAttributeDeclaration(typeof(XmlChoiceIdentifierAttribute).FullName);
attribute.Arguments.Add(new CodeAttributeArgument(new CodePrimitiveExpression(member.ChoiceIdentifier.MemberName)));
metadata.Add(attribute);
}
if (member.Ignore)
{
CodeAttributeDeclaration attribute = new CodeAttributeDeclaration(typeof(XmlIgnoreAttribute).FullName);
metadata.Add(attribute);
}
}
}
void ExportTypeMembers(XmlSchemaComplexType type, MemberMapping[] members, string name, string ns, bool hasSimpleContent)
{
XmlSchemaGroupBase seq = new XmlSchemaSequence();
TypeMapping textMapping = null;
for (int i = 0; i < members.Length; i++)
{
MemberMapping member = members[i];
if (member.Ignore)
{
continue;
}
if (member.Text != null)
{
if (textMapping != null)
{
throw new InvalidOperationException(Res.GetString(Res.XmlIllegalMultipleText, name));
}
textMapping = member.Text.Mapping;
}
if (member.Elements.Length > 0)
{
bool repeats = member.TypeDesc.IsArrayLike &&
!(member.Elements.Length == 1 && member.Elements[0].Mapping is ArrayMapping);
bool valueTypeOptional = member.CheckSpecified || member.CheckShouldPersist;
ExportElementAccessors(seq, member.Elements, repeats, valueTypeOptional, ns);
}
}
if (seq.Items.Count > 0)
{
if (type.ContentModel != null)
{
if (type.ContentModel.Content is XmlSchemaComplexContentRestriction)
{
((XmlSchemaComplexContentRestriction)type.ContentModel.Content).Particle = seq;
}
else if (type.ContentModel.Content is XmlSchemaComplexContentExtension)
{
((XmlSchemaComplexContentExtension)type.ContentModel.Content).Particle = seq;
}
else
{
throw new InvalidOperationException(Res.GetString(Res.XmlInvalidContent, type.ContentModel.Content.GetType().Name));
}
}
else
{
type.Particle = seq;
}
}
if (textMapping != null)
{
if (hasSimpleContent)
{
if (textMapping is PrimitiveMapping && seq.Items.Count == 0)
{
PrimitiveMapping pm = (PrimitiveMapping)textMapping;
if (pm.IsList)
{
type.IsMixed = true;
}
else
{
// Create simpleContent
XmlSchemaSimpleContent model = new XmlSchemaSimpleContent();
XmlSchemaSimpleContentExtension ex = new XmlSchemaSimpleContentExtension();
model.Content = ex;
type.ContentModel = model;
ex.BaseTypeName = ExportPrimitiveMapping(pm, ns);
}
}
}
else
{
type.IsMixed = true;
}
}
for (int i = 0; i < members.Length; i++)
{
ExportAttributeAccessor(type, members[i].Attribute, members[i].CheckSpecified || members[i].CheckShouldPersist, ns);
}
}
internal XmlMemberMapping(MemberMapping mapping) {
this.mapping = mapping;
}
internal XmlMemberMapping(MemberMapping mapping)
{
_mapping = mapping;
}
MembersMapping ImportMembersMapping(XmlReflectionMember[] xmlReflectionMembers, string ns, bool hasWrapperElement, bool writeAccessors, bool validateWrapperElement) {
MembersMapping members = new MembersMapping();
members.TypeDesc = typeScope.GetTypeDesc(typeof(object[]));
MemberMapping[] mappings = new MemberMapping[xmlReflectionMembers.Length];
for (int i = 0; i < mappings.Length; i++) {
try {
XmlReflectionMember member = xmlReflectionMembers[i];
MemberMapping mapping = ImportMemberMapping(member, ns, xmlReflectionMembers, hasWrapperElement ? XmlSchemaForm.Unqualified : XmlSchemaForm.Qualified);
if (member.IsReturnValue && writeAccessors) { // no special treatment for return values with doc/enc
if (i > 0) throw new InvalidOperationException(Res.GetString(Res.XmlInvalidReturnPosition));
mapping.IsReturnValue = true;
}
mappings[i] = mapping;
}
catch (Exception e) {
if (e is ThreadAbortException || e is StackOverflowException || e is OutOfMemoryException) {
throw;
}
throw ReflectionException(xmlReflectionMembers[i].MemberName, e);
}
catch {
throw ReflectionException(xmlReflectionMembers[i].MemberName, null);
}
}
members.Members = mappings;
members.HasWrapperElement = hasWrapperElement;
if (hasWrapperElement) {
members.ValidateRpcWrapperElement = validateWrapperElement;
}
members.WriteAccessors = writeAccessors;
members.IsSoap = true;
if (hasWrapperElement && !writeAccessors)
members.Namespace = ns;
return members;
}
void ImportElementMember(XmlSchemaElement element, CodeIdentifiers members, string ns) {
ElementAccessor accessor;
if ((accessor = ImportArray(element, ns)) == null) {
accessor = ImportElement(element, ns);
}
MemberMapping member = new MemberMapping();
member.Name = CodeIdentifier.MakeValid(Accessor.UnescapeName(accessor.Name));
member.Name = members.AddUnique(member.Name, member);
if (member.Name.EndsWith("Specified", StringComparison.Ordinal)) {
string name = member.Name;
member.Name = members.AddUnique(member.Name, member);
members.Remove(name);
}
member.TypeDesc = ((TypeMapping)accessor.Mapping).TypeDesc;
member.Elements = new ElementAccessor[] { accessor };
if (element.IsMultipleOccurrence)
member.TypeDesc = member.TypeDesc.CreateArrayTypeDesc();
if (element.MinOccurs == 0 && member.TypeDesc.IsValueType && !member.TypeDesc.HasIsEmpty) {
member.CheckSpecified = true;
}
}
MemberMapping ImportFieldMapping(FieldModel model, SoapAttributes a, string ns) {
if (a.SoapIgnore) return null;
MemberMapping member = new MemberMapping();
member.IsSoap = true;
member.Name = model.Name;
member.CheckShouldPersist = model.CheckShouldPersist;
member.CheckSpecified = model.CheckSpecified;
member.ReadOnly = model.ReadOnly; // || !model.FieldTypeDesc.HasDefaultConstructor;
ImportAccessorMapping(member, model, a, ns, XmlSchemaForm.Unqualified);
return member;
}
private bool InitializeStructMembers(StructMapping mapping, StructModel model, RecursionLimiter limiter)
{
if (mapping.IsFullyInitialized)
{
return(true);
}
if (model.TypeDesc.BaseTypeDesc != null)
{
StructMapping baseMapping = ImportStructLikeMapping((StructModel)_modelScope.GetTypeModel(model.Type.BaseType, false), limiter);
// check to see if the import of the baseMapping was deferred
int baseIndex = limiter.DeferredWorkItems.IndexOf(mapping.BaseMapping);
if (baseIndex < 0)
{
mapping.BaseMapping = baseMapping;
}
else
{
// the import of the baseMapping was deferred, make sure that the derived mappings is deferred as well
if (!limiter.DeferredWorkItems.Contains(mapping))
{
limiter.DeferredWorkItems.Add(new ImportStructWorkItem(model, mapping));
}
// make sure that baseMapping get processed before the derived
int top = limiter.DeferredWorkItems.Count - 1;
if (baseIndex < top)
{
ImportStructWorkItem baseMappingWorkItem = limiter.DeferredWorkItems[baseIndex];
limiter.DeferredWorkItems[baseIndex] = limiter.DeferredWorkItems[top];
limiter.DeferredWorkItems[top] = baseMappingWorkItem;
}
return(false);
}
}
ArrayList members = new ArrayList();
foreach (MemberInfo memberInfo in model.GetMemberInfos())
{
if (!(memberInfo is FieldInfo) && !(memberInfo is PropertyInfo))
{
continue;
}
SoapAttributes memberAttrs = GetAttributes(memberInfo);
if (memberAttrs.SoapIgnore)
{
continue;
}
FieldModel fieldModel = model.GetFieldModel(memberInfo);
if (fieldModel == null)
{
continue;
}
MemberMapping member = ImportFieldMapping(fieldModel, memberAttrs, mapping.Namespace, limiter);
if (member == null)
{
continue;
}
if (!member.TypeDesc.IsPrimitive && !member.TypeDesc.IsEnum && !member.TypeDesc.IsOptionalValue)
{
if (model.TypeDesc.IsValueType)
{
throw new NotSupportedException(SR.Format(SR.XmlRpcRefsInValueType, model.TypeDesc.FullName));
}
if (member.TypeDesc.IsValueType)
{
throw new NotSupportedException(SR.Format(SR.XmlRpcNestedValueType, member.TypeDesc.FullName));
}
}
if (mapping.BaseMapping != null)
{
if (mapping.BaseMapping.Declares(member, mapping.TypeName))
{
continue;
}
}
members.Add(member);
}
mapping.Members = (MemberMapping[])members.ToArray(typeof(MemberMapping));
if (mapping.BaseMapping == null)
{
mapping.BaseMapping = GetRootMapping();
}
IncludeTypes(model.Type, limiter);
return(true);
}
int FindXmlnsIndex(MemberMapping[] members) {
for (int i = 0; i < members.Length; i++) {
if (members[i].Xmlns == null)
continue;
return i;
}
return -1;
}
void ExportProperty(CodeTypeDeclaration codeClass, MemberMapping member, CodeIdentifiers memberScope) {
string fieldName = memberScope.AddUnique(CodeExporter.MakeFieldName(member.Name), member);
string fieldType = member.GetTypeName(CodeProvider);
// need to create a private field
CodeMemberField field = new CodeMemberField(fieldType, fieldName);
field.Attributes = MemberAttributes.Private;
codeClass.Members.Add(field);
CodeMemberProperty prop = CreatePropertyDeclaration(field, member.Name, fieldType);
prop.Comments.Add(new CodeCommentStatement(Res.GetString(Res.XmlRemarks), true));
AddMemberMetadata(prop.CustomAttributes, member, false);
codeClass.Members.Add(prop);
if (member.CheckSpecified != SpecifiedAccessor.None) {
field = new CodeMemberField(typeof(bool).FullName, fieldName + "Specified");
field.Attributes = MemberAttributes.Private;
codeClass.Members.Add(field);
prop = CreatePropertyDeclaration(field, member.Name + "Specified", typeof(bool).FullName);
prop.Comments.Add(new CodeCommentStatement(Res.GetString(Res.XmlRemarks), true));
CodeAttributeDeclaration attribute = new CodeAttributeDeclaration(typeof(SoapIgnoreAttribute).FullName);
prop.CustomAttributes.Add(attribute);
codeClass.Members.Add(prop);
}
}