XmlText.cs

using System.Xml.XPath;

namespace System.Xml
{
    public class XmlText : XmlCharacterData
    {
        public override string Name => OwnerDocument.strTextName;

        public override string LocalName => OwnerDocument.strTextName;

        public override XmlNodeType NodeType => XmlNodeType.Text;

        public override XmlNode ParentNode
        {
            get
            {
                switch (base.parentNode.NodeType)
                {
                case XmlNodeType.Document:
                    return null;
                case XmlNodeType.Text:
                case XmlNodeType.CDATA:
                case XmlNodeType.Whitespace:
                case XmlNodeType.SignificantWhitespace:
                {
                    XmlNode parentNode = base.parentNode.parentNode;
                    while (parentNode.IsText)
                    {
                        parentNode = parentNode.parentNode;
                    }
                    return parentNode;
                }
                default:
                    return base.parentNode;
                }
            }
        }

        public override string Value
        {
            get
            {
                return Data;
            }
            set
            {
                Data = value;
                XmlNode parentNode = base.parentNode;
                if (parentNode != null && parentNode.NodeType == XmlNodeType.Attribute)
                {
                    XmlUnspecifiedAttribute xmlUnspecifiedAttribute = parentNode as XmlUnspecifiedAttribute;
                    if (xmlUnspecifiedAttribute != null && !xmlUnspecifiedAttribute.Specified)
                    {
                        xmlUnspecifiedAttribute.SetSpecified(f: true);
                    }
                }
            }
        }

        internal override XPathNodeType XPNodeType => XPathNodeType.Text;

        internal override bool IsText => true;

        public override XmlNode PreviousText
        {
            get
            {
                if (parentNode.IsText)
                {
                    return parentNode;
                }
                return null;
            }
        }

        internal XmlText(string strData)
            : this(strData, null)
        {
        }

        protected internal XmlText(string strData, XmlDocument doc)
            : base(strData, doc)
        {
        }

        public override XmlNode CloneNode(bool deep)
        {
            return OwnerDocument.CreateTextNode(Data);
        }

        public virtual XmlText SplitText(int offset)
        {
            XmlNode parentNode = ParentNode;
            int length = Length;
            if (offset > length)
            {
                throw new ArgumentOutOfRangeException("offset");
            }
            if (parentNode == null)
            {
                throw new InvalidOperationException(Res.GetString("Xdom_TextNode_SplitText"));
            }
            int count = length - offset;
            string text = Substring(offset, count);
            DeleteData(offset, count);
            XmlText xmlText = OwnerDocument.CreateTextNode(text);
            parentNode.InsertAfter(xmlText, this);
            return xmlText;
        }

        public override void WriteTo(XmlWriter w)
        {
            w.WriteString(Data);
        }

        public override void WriteContentTo(XmlWriter w)
        {
        }
    }
}