System.Xml.Serialization.ClassMap.AddMember C# (CSharp) Method

		public void AddMember (XmlTypeMapMember member)
		{
			// If GlobalIndex has not been set, set it now
			if (member.GlobalIndex == -1)
				member.GlobalIndex = _allMembers.Count;
			
			_allMembers.Add (member);
			
			if (!(member.DefaultValue is System.DBNull) && member.DefaultValue != null) {
				if (_membersWithDefault == null) _membersWithDefault = new ArrayList ();
				_membersWithDefault.Add (member);
			}
			
			if (member.IsReturnValue)
				_returnMember = member;
			
			if (member is XmlTypeMapMemberAttribute)
			{
				XmlTypeMapMemberAttribute atm = (XmlTypeMapMemberAttribute)member;
				if (_attributeMembers == null) _attributeMembers = new Hashtable();
				string key = BuildKey (atm.AttributeName, atm.Namespace);
				if (_attributeMembers.ContainsKey (key))
					throw new InvalidOperationException ("The XML attribute named '" + atm.AttributeName + "' from namespace '" + atm.Namespace + "' is already present in the current scope. Use XML attributes to specify another XML name or namespace for the attribute.");
				member.Index = _attributeMembers.Count;
				_attributeMembers.Add (key, member);
				return;
			}
			else if (member is XmlTypeMapMemberFlatList)
			{
				RegisterFlatList ((XmlTypeMapMemberFlatList)member);
			}
			else if (member is XmlTypeMapMemberAnyElement)
			{
				XmlTypeMapMemberAnyElement mem = (XmlTypeMapMemberAnyElement) member;
				if (mem.IsDefaultAny) _defaultAnyElement = mem;
				if (mem.TypeData.IsListType) RegisterFlatList (mem);
			}
			else if (member is XmlTypeMapMemberAnyAttribute)
			{
				_defaultAnyAttribute = (XmlTypeMapMemberAnyAttribute) member;
				return;
			}
			else if (member is XmlTypeMapMemberNamespaces)
			{
				_namespaceDeclarations = (XmlTypeMapMemberNamespaces) member;
				return;
			}

			if (member is XmlTypeMapMemberElement && ((XmlTypeMapMemberElement)member).IsXmlTextCollector)
			{
				if (_xmlTextCollector != null) throw new InvalidOperationException ("XmlTextAttribute can only be applied once in a class");
				_xmlTextCollector = member;
			}

			if (_elementMembers == null) {
				_elementMembers = new ArrayList();
				_elements = new Hashtable();
			}

			member.Index = _elementMembers.Count;
			_elementMembers.Add (member);

			ICollection elemsInfo = ((XmlTypeMapMemberElement)member).ElementInfo;
			foreach (XmlTypeMapElementInfo elem in elemsInfo)
			{
				string key = BuildKey (elem.ElementName, elem.Namespace);
				if (_elements.ContainsKey (key)) 
					throw new InvalidOperationException ("The XML element named '" + elem.ElementName + "' from namespace '" + elem.Namespace + "' is already present in the current scope. Use XML attributes to specify another XML name or namespace for the element.");
				_elements.Add (key, elem);
			}
			
			if (member.TypeData.IsListType && member.TypeData.Type != null && !member.TypeData.Type.IsArray) {
				if (_listMembers == null) _listMembers = new ArrayList ();
				_listMembers.Add (member);
			}
		}

        private XmlTypeMapping ImportClassMapping(TypeData typeData, string defaultNamespace)
        {
            Type type = typeData.Type;

            if (type.IsValueType)
            {
                throw this.CreateStructException(type);
            }
            if (type == typeof(object))
            {
                defaultNamespace = "http://www.w3.org/2001/XMLSchema";
            }
            ReflectionHelper.CheckSerializableType(type, false);
            XmlTypeMapping xmlTypeMapping = this.helper.GetRegisteredClrType(type, this.GetTypeNamespace(typeData, defaultNamespace));

            if (xmlTypeMapping != null)
            {
                return(xmlTypeMapping);
            }
            xmlTypeMapping = this.CreateTypeMapping(typeData, null, defaultNamespace);
            this.helper.RegisterClrType(xmlTypeMapping, type, xmlTypeMapping.Namespace);
            xmlTypeMapping.MultiReferenceType = true;
            ClassMap classMap = new ClassMap();

            xmlTypeMapping.ObjectMap = classMap;
            ICollection reflectionMembers = this.GetReflectionMembers(type);

            foreach (object obj in reflectionMembers)
            {
                XmlReflectionMember xmlReflectionMember = (XmlReflectionMember)obj;
                if (!xmlReflectionMember.SoapAttributes.SoapIgnore)
                {
                    classMap.AddMember(this.CreateMapMember(xmlReflectionMember, defaultNamespace));
                }
            }
            SoapIncludeAttribute[] array = (SoapIncludeAttribute[])type.GetCustomAttributes(typeof(SoapIncludeAttribute), false);
            for (int i = 0; i < array.Length; i++)
            {
                Type type2 = array[i].Type;
                this.ImportTypeMapping(type2);
            }
            if (type == typeof(object) && this.includedTypes != null)
            {
                foreach (object obj2 in this.includedTypes)
                {
                    Type type3 = (Type)obj2;
                    xmlTypeMapping.DerivedTypes.Add(this.ImportTypeMapping(type3));
                }
            }
            if (type.BaseType != null)
            {
                XmlTypeMapping xmlTypeMapping2 = this.ImportClassMapping(type.BaseType, defaultNamespace);
                if (type.BaseType != typeof(object))
                {
                    xmlTypeMapping.BaseMap = xmlTypeMapping2;
                }
                this.RegisterDerivedMap(xmlTypeMapping2, xmlTypeMapping);
            }
            return(xmlTypeMapping);
        }