C# XmlUtilWriter.AppendWhiteSpace方法代码示例

//.........这里部分代码省略.........
                //
                // The reader only gives us the position of 'rootElementName', so we must track what was
                // written before "<!DOCTYPE" in order to correctly determine the position of the
                // <!DOCTYPE tag
                //
                Debug.Assert(utilWriter.TrackPosition, "utilWriter.TrackPosition");
                int c = utilWriter.Write("<!DOCTYPE");

                // Write the space between <!DOCTYPE and the rootElementName
                utilWriter.AppendRequiredWhiteSpace(_lastLineNumber, _lastLinePosition + c, _reader.LineNumber, _reader.LinePosition);

                // Write the rootElementName
                utilWriter.Write(_reader.Name);

                // Get the dtd declarations, if any
                string dtdValue = null;
                if (_reader.HasValue) {
                    dtdValue = _reader.Value;
                }

                // get line position after the !DOCTYPE declaration:
                //      <!DOCTYPE  rootElement     SYSTEM rootElementDtdUri >
                //                            ^
                //                            linePosition
                lineNumber = _reader.LineNumber;
                linePosition = _reader.LinePosition + _reader.Name.Length;

                // Note that there is no way to get the spacing after PUBLIC or SYSTEM attributes and their values
                if (_reader.MoveToFirstAttribute()) {
                    // Write the space before SYSTEM or PUBLIC
                    utilWriter.AppendRequiredWhiteSpace(lineNumber, linePosition, _reader.LineNumber, _reader.LinePosition); 

                    // Write SYSTEM or PUBLIC and the 1st value of the attribute
                    string attrName = _reader.Name;
                    utilWriter.Write(attrName);
                    utilWriter.AppendSpace();
                    utilWriter.AppendAttributeValue(_reader);
                    _reader.MoveToAttribute(0);
                    
                    // If PUBLIC, write the second value of the attribute
                    if (attrName == "PUBLIC") {
                        _reader.MoveToAttribute(1);
                        utilWriter.AppendSpace();
                        utilWriter.AppendAttributeValue(_reader);
                        _reader.MoveToAttribute(1);
                    }
                }

                // If there is a dtd, write it
                if (dtdValue != null && dtdValue.Length > 0) {
                    utilWriter.Write(" [");
                    utilWriter.Write(dtdValue);
                    utilWriter.Write(']');
                }

                utilWriter.Write('>');
            }

            // Advance the _reader so we can get the position of the next node.
            bool moreToRead = _reader.Read();
            nodeType = _reader.NodeType;

            // Close the node we are copying.
            if (close != null) {
                //
                // Find the position of the close string, for example:
                //
                //          <element      >  <subElement />
                //                        ^
                //                        closeLinePosition
                //
                int startOffset = GetPositionOffset(nodeType);
                int closeLineNumber = _reader.LineNumber;
                int closeLinePosition = _reader.LinePosition - startOffset - close.Length;

                // Add whitespace up to the position of the close string
                utilWriter.AppendWhiteSpace(lineNumber, linePosition, closeLineNumber, closeLinePosition);

                // Write the close string
                utilWriter.Write(close);
            }

            //
            // Track the position of the reader based on the position of the reader
            // before we copied this node and what we have written in copying the node.
            // This allows us to determine the position of the <!DOCTYPE tag.
            //
            if (utilWriter.TrackPosition) {
                _lastLineNumber = (readerLineNumber - writerLineNumber) + utilWriter.LineNumber;

                if (writerLineNumber == utilWriter.LineNumber) {
                    _lastLinePosition = (readerLinePosition - writerLinePosition) + utilWriter.LinePosition;
                }
                else {
                    _lastLinePosition = utilWriter.LinePosition;
                }
            }

            return moreToRead;
        }

 internal bool SkipAndCopyReaderToNextElement(XmlUtilWriter utilWriter, bool limitDepth)
 {
     int depth;
     if (!utilWriter.IsLastLineBlank)
     {
         this._reader.Skip();
         return this.CopyReaderToNextElement(utilWriter, limitDepth);
     }
     if (limitDepth)
     {
         depth = this._reader.Depth;
     }
     else
     {
         depth = 0;
     }
     this._reader.Skip();
     int lineNumber = this._reader.LineNumber;
     while (!this._reader.EOF)
     {
         if (this._reader.NodeType != XmlNodeType.Whitespace)
         {
             if (this._reader.LineNumber > lineNumber)
             {
                 utilWriter.SeekToLineStart();
                 utilWriter.AppendWhiteSpace(lineNumber + 1, 1, this.LineNumber, this.TrueLinePosition);
             }
             break;
         }
         this._reader.Read();
     }
     while (!this._reader.EOF)
     {
         if ((this._reader.NodeType == XmlNodeType.Element) || (this._reader.Depth < depth))
         {
             break;
         }
         this.CopyXmlNode(utilWriter);
     }
     return !this._reader.EOF;
 }

        //
        // Skip over the current element and copy until the next element.
        // This function removes the one blank line that would otherwise
        // be inserted by simply skipping and copying to the next element
        // in a situation like this:
        //
        //      <!-- end of previous configSection -->
        //      <configSectionToDelete>
        //          <content />
        //          <moreContent />
        //      </configSectionToDelete>
        //      <!-- end of configSectionToDelete -->
        //      <nextConfigSection />
        //
        internal bool SkipAndCopyReaderToNextElement(XmlUtilWriter utilWriter, bool limitDepth) {
            Debug.Assert(_reader.NodeType == XmlNodeType.Element, "_reader.NodeType == XmlNodeType.Element");

            // If the last line before the element is not blank, then we do not have to
            // remove the blank line.
            if (!utilWriter.IsLastLineBlank) {
                _reader.Skip();
                return CopyReaderToNextElement(utilWriter, limitDepth);
            }

            // Set the depth if we limit copying to this depth
            int depth;
            if (limitDepth) {
                depth = _reader.Depth;
            }
            else {
                depth = 0;
            }

            // Skip over the element
            _reader.Skip();

            int lineNumberOfEndElement = _reader.LineNumber;

            // Read until we hit a a non-whitespace node or reach the end
            while (!_reader.EOF) {
                if (_reader.NodeType != XmlNodeType.Whitespace) {
                    //
                    // If the next non-whitepace node is on another line,
                    // seek back to the beginning of the current blank line,
                    // skip a blank line of whitespace, and copy the remaining whitespace.
                    //
                    if (_reader.LineNumber > lineNumberOfEndElement) {
                        utilWriter.SeekToLineStart();
                        utilWriter.AppendWhiteSpace(lineNumberOfEndElement + 1, 1, LineNumber, TrueLinePosition);
                    }

                    break;
                }

                _reader.Read();
            }

            // Copy nodes until we've reached the desired depth, or until we hit an element.
            while (!_reader.EOF) {
                if (_reader.NodeType == XmlNodeType.Element)
                    break;

                if (_reader.Depth < depth) {
                    break;
                }

                CopyXmlNode(utilWriter);
            };

            return !_reader.EOF;
        }

//.........这里部分代码省略.........

                case XmlNodeType.Text:
                    utilWriter.AppendEscapeTextString(this._reader.Value);
                    break;

                case XmlNodeType.XmlDeclaration:
                    s = "?>";
                    fromLineNumber = this._reader.LineNumber;
                    fromLinePosition = this._reader.LinePosition + 3;
                    utilWriter.Write("<?xml");
                    while (this._reader.MoveToNextAttribute())
                    {
                        int num10 = this._reader.LineNumber;
                        int num11 = this._reader.LinePosition;
                        utilWriter.AppendRequiredWhiteSpace(fromLineNumber, fromLinePosition, num10, num11);
                        int num12 = utilWriter.Write(this._reader.Name) + utilWriter.Write('=');
                        num12 += utilWriter.AppendAttributeValue(this._reader);
                        fromLineNumber = num10;
                        fromLinePosition = num11 + num12;
                    }
                    this._reader.MoveToElement();
                    break;

                case XmlNodeType.SignificantWhitespace:
                    utilWriter.Write(this._reader.Value);
                    break;

                case XmlNodeType.ProcessingInstruction:
                    utilWriter.AppendProcessingInstruction(this._reader.Name, this._reader.Value);
                    break;

                case XmlNodeType.EntityReference:
                    utilWriter.AppendEntityRef(this._reader.Name);
                    break;

                case XmlNodeType.CDATA:
                    utilWriter.AppendCData(this._reader.Value);
                    break;

                default:
                    if (nodeType == XmlNodeType.DocumentType)
                    {
                        int num13 = utilWriter.Write("<!DOCTYPE");
                        utilWriter.AppendRequiredWhiteSpace(this._lastLineNumber, this._lastLinePosition + num13, this._reader.LineNumber, this._reader.LinePosition);
                        utilWriter.Write(this._reader.Name);
                        string str2 = null;
                        if (this._reader.HasValue)
                        {
                            str2 = this._reader.Value;
                        }
                        fromLineNumber = this._reader.LineNumber;
                        fromLinePosition = this._reader.LinePosition + this._reader.Name.Length;
                        if (this._reader.MoveToFirstAttribute())
                        {
                            utilWriter.AppendRequiredWhiteSpace(fromLineNumber, fromLinePosition, this._reader.LineNumber, this._reader.LinePosition);
                            string name = this._reader.Name;
                            utilWriter.Write(name);
                            utilWriter.AppendSpace();
                            utilWriter.AppendAttributeValue(this._reader);
                            this._reader.MoveToAttribute(0);
                            if (name == "PUBLIC")
                            {
                                this._reader.MoveToAttribute(1);
                                utilWriter.AppendSpace();
                                utilWriter.AppendAttributeValue(this._reader);
                                this._reader.MoveToAttribute(1);
                            }
                        }
                        if ((str2 != null) && (str2.Length > 0))
                        {
                            utilWriter.Write(" [");
                            utilWriter.Write(str2);
                            utilWriter.Write(']');
                        }
                        utilWriter.Write('>');
                    }
                    break;
            }
            bool flag = this._reader.Read();
            nodeType = this._reader.NodeType;
            if (s != null)
            {
                int positionOffset = GetPositionOffset(nodeType);
                int num15 = this._reader.LineNumber;
                int num16 = (this._reader.LinePosition - positionOffset) - s.Length;
                utilWriter.AppendWhiteSpace(fromLineNumber, fromLinePosition, num15, num16);
                utilWriter.Write(s);
            }
            if (utilWriter.TrackPosition)
            {
                this._lastLineNumber = (lineNumber - num5) + utilWriter.LineNumber;
                if (num5 == utilWriter.LineNumber)
                {
                    this._lastLinePosition = (linePosition - num6) + utilWriter.LinePosition;
                    return flag;
                }
                this._lastLinePosition = utilWriter.LinePosition;
            }
            return flag;
        }