System.Runtime.Remoting.MetadataServices.SdlParser.ParseClass C# (CSharp) Method

        private void ParseClass(URTNamespace parsingNamespace)
        {
            Util.Log("SdlParser.ParseClass");
            String className = LookupAttribute(s_nameString, null, false);
            bool bUnique = false;
            if((className == s_emptyString) && (_parsingInput.UniqueType == null))
            {
                className = _parsingInput.Name;
                bUnique = true;
            }
            URTComplexType parsingComplexType = parsingNamespace.LookupComplexType(className);
            if(parsingComplexType == null)
            {
                parsingComplexType = new URTComplexType(className, parsingNamespace.Namespace,
                                                        parsingNamespace.EncodedNS, _blockDefault,
                                                        true, false);
                if(_bWrappedProxy)
                {
                    parsingComplexType.SUDSType = SUDSType.ClientProxy;

                    if (_parsingInput.Location.Length > 0)
                    {
                        if (parsingComplexType.ConnectURLs == null)
                            parsingComplexType.ConnectURLs = new ArrayList(10);
                        parsingComplexType.ConnectURLs.Add(_parsingInput.Location);
                    }
                }
                
                parsingNamespace.AddComplexType(parsingComplexType);
            }
            if(bUnique)
            {
                _parsingInput.UniqueType = parsingComplexType;
            }
            if(parsingComplexType.Methods.Count > 0)
            {
                SkipXmlElement();
            }
            else
            {
                parsingComplexType.IsSUDSType = true;
                int curDepth = _XMLReader.Depth;
                ReadNextXmlElement();
                while(_XMLReader.Depth > curDepth)
                {
                    if(MatchingNamespace(s_sudsNamespaceString))
                    {
                        String elmName = _XMLReader.LocalName;
                        if(MatchingStrings(elmName, s_extendsString))
                        {
                            String nameValue = LookupAttribute(s_nameString, null, true);
                            String nameValueNS = ParseQName(ref nameValue);
                            parsingComplexType.Extends(nameValue, nameValueNS);

                            //Set up extend class so that it is marked as the correct SUDSType
                            URTNamespace extendsNamespace = LookupNamespace(nameValueNS);                   
                            if (extendsNamespace == null)
                                extendsNamespace = new URTNamespace(nameValueNS, this);                     

                            URTComplexType extendsComplexType = extendsNamespace.LookupComplexType(nameValue);                  
                            if(extendsComplexType == null)
                            {
                                extendsComplexType = new URTComplexType(nameValue, extendsNamespace.Namespace, extendsNamespace.EncodedNS, _blockDefault ,true, false);
                                extendsNamespace.AddComplexType(extendsComplexType);
                            }
                            else
                                extendsComplexType.IsSUDSType = true;

                            if (_bWrappedProxy)
                                extendsComplexType.SUDSType = SUDSType.ClientProxy;
                            else
                                extendsComplexType.SUDSType = SUDSType.MarshalByRef;

                            // Only top of inheritance hierarchy is marked
                            //parsingComplexType.SUDSType = SUDSType.None;  

                        }
                        else if(MatchingStrings(elmName, s_implementsString))
                        {
                            String nameValue = LookupAttribute(s_nameString, null, true);
                            String nameValueNS = ParseQName(ref nameValue);
                            parsingComplexType.Implements(nameValue, nameValueNS, this);
                        }
                        else if(MatchingStrings(elmName, s_addressesString))
                        {
                            ParseAddresses(parsingComplexType);
                            continue;
                        }
                        else if(MatchingStrings(elmName, s_requestResponseString))
                        {
                            ParseRRMethod(parsingComplexType, null);
                            continue;
                        }
                        else if(MatchingStrings(elmName, s_onewayString))
                        {
                            ParseOnewayMethod(parsingComplexType, null);
                            continue;
                        }
                        else
                            goto SkipXMLNode;
                    }
                    else
                        goto SkipXMLNode;

                    // Read next element
                    ReadNextXmlElement();
                    continue;

        SkipXMLNode:
                    // Ignore others elements such as annotations
                    SkipXmlElement();
                }
            }

            return;
        }