System.Xml.XmlTextReaderImpl.ResolveEntity C# (CSharp) Method

        public override void ResolveEntity()
        {
            if (_curNode.type != XmlNodeType.EntityReference)
            {
                throw new InvalidOperationException(SR.Xml_InvalidOperation);
            }

            Debug.Assert(_parsingMode == ParsingMode.Full);

            // entity in attribute value
            if (_parsingFunction == ParsingFunction.InReadAttributeValue ||
                 _parsingFunction == ParsingFunction.FragmentAttribute)
            {
                switch (HandleGeneralEntityReference(_curNode.localName, true, true, _curNode.LinePos))
                {
                    case EntityType.ExpandedInAttribute:
                    case EntityType.Expanded:
                        if (_ps.charsUsed - _ps.charPos == 0)
                        {  // entity value == ""
                            _emptyEntityInAttributeResolved = true;
                        }
                        break;
                    case EntityType.FakeExpanded:
                        _emptyEntityInAttributeResolved = true;
                        break;
                    default:
                        Debug.Assert(false);
                        throw new XmlException(SR.Xml_InternalError, string.Empty);
                }
            }
            // entity in element content
            else
            {
                switch (HandleGeneralEntityReference(_curNode.localName, false, true, _curNode.LinePos))
                {
                    case EntityType.ExpandedInAttribute:
                    case EntityType.Expanded:
                        _nextParsingFunction = _parsingFunction;
                        if (_ps.charsUsed - _ps.charPos == 0 && !_ps.entity.IsExternal)
                        {  // empty internal entity value
                            _parsingFunction = ParsingFunction.AfterResolveEmptyEntityInContent;
                        }
                        else
                        {
                            _parsingFunction = ParsingFunction.AfterResolveEntityInContent;
                        }
                        break;
                    case EntityType.FakeExpanded:
                        _nextParsingFunction = _parsingFunction;
                        _parsingFunction = ParsingFunction.AfterResolveEmptyEntityInContent;
                        break;
                    default:
                        Debug.Assert(false);
                        throw new XmlException(SR.Xml_InternalError, string.Empty);
                }
            }
            _ps.entityResolvedManually = true;
            _index++;
        }

#pragma warning disable 618
        // Creates a XmlValidatingReader suitable for parsing InnerXml strings
        private XmlReader CreateInnerXmlReader(String xmlFragment, XmlNodeType nt, XmlParserContext context, XmlDocument doc)
        {
            XmlNodeType contentNT = nt;

            if (contentNT == XmlNodeType.Entity || contentNT == XmlNodeType.EntityReference)
            {
                contentNT = XmlNodeType.Element;
            }

            XmlTextReaderImpl tr = new XmlTextReaderImpl(xmlFragment, contentNT, context);

            tr.XmlValidatingReaderCompatibilityMode = true;
            if (doc.HasSetResolver)
            {
                tr.XmlResolver = doc.GetResolver();
            }
            if (!(doc.ActualLoadingStatus))
            {
                tr.DisableUndeclaredEntityCheck = true;
            }
            Debug.Assert(tr.EntityHandling == EntityHandling.ExpandCharEntities);

            XmlDocumentType dtdNode = doc.DocumentType;

            if (dtdNode != null)
            {
                tr.Namespaces = dtdNode.ParseWithNamespaces;
                if (dtdNode.DtdSchemaInfo != null)
                {
                    tr.SetDtdInfo(dtdNode.DtdSchemaInfo);
                }
                else
                {
                    IDtdParser dtdParser = DtdParser.Create();
                    XmlTextReaderImpl.DtdParserProxy proxy = new XmlTextReaderImpl.DtdParserProxy(tr);

                    IDtdInfo dtdInfo = dtdParser.ParseFreeFloatingDtd(context.BaseURI, context.DocTypeName, context.PublicId, context.SystemId, context.InternalSubset, proxy);

                    // TODO: Change all of XmlDocument to IDtdInfo interfaces
                    dtdNode.DtdSchemaInfo = dtdInfo as SchemaInfo;
                    tr.SetDtdInfo(dtdInfo);
                }
            }

            if (nt == XmlNodeType.Entity || nt == XmlNodeType.EntityReference)
            {
                tr.Read(); //this will skip the first element "wrapper"
                tr.ResolveEntity();
            }
            return(tr);
        }