XmlSignificantWhitespace.NodeType-Eigenschaft

Ruft den Typ des aktuellen Knotens ab.

Namespace: System.Xml
Assembly: System.Xml (in system.xml.dll)

Syntax

'Declaration
Public Overrides ReadOnly Property NodeType As XmlNodeType
'Usage
Dim instance As XmlSignificantWhitespace
Dim value As XmlNodeType

value = instance.NodeType

public override XmlNodeType NodeType { get; }

public:
virtual property XmlNodeType NodeType {
    XmlNodeType get () override;
}

/** @property */
public XmlNodeType get_NodeType ()

public override function get NodeType () : XmlNodeType

Eigenschaftenwert

Für XmlSignificantWhitespace-Knoten ist dieser Wert XmlNodeType.SignificantWhitespace.

Beispiel

Im folgenden Beispiel wird dem Dokument ein signifikanter Leerraum hinzugefügt.

Option Explicit
Option Strict

Imports System
Imports System.IO
Imports System.Xml
Imports Microsoft.VisualBasic

Public Class Sample
    Private currNode As XmlNode
    Private filename As String = "space.xml"
    Private reader As XmlTextReader = Nothing
    
    Public Shared Sub Main()
        Dim test As New Sample()
    End Sub 'Main
    
    Public Sub New()
            Dim doc As New XmlDocument()
            doc.LoadXml("<!-- Sample XML fragment -->" & _
                        "<author xml:space='preserve'>" & _
                        "<first-name>Eva</first-name>"& _
                        "<last-name>Corets</last-name>" & _ 
                        "</author>")
            
            Console.WriteLine("InnerText before...")
            Console.WriteLine(doc.DocumentElement.InnerText)
            
            ' Add white space.     
            currNode = doc.DocumentElement
            Dim sigws As XmlSignificantWhitespace = doc.CreateSignificantWhitespace(ControlChars.Tab)
            currNode.InsertAfter(sigws, currNode.FirstChild)
            
            Console.WriteLine()
            Console.WriteLine("InnerText after...")
            Console.WriteLine(doc.DocumentElement.InnerText)
            
            ' Save and then display the file.
            doc.Save(filename)
            Console.WriteLine()
            Console.WriteLine("Reading file...")
            ReadFile(filename)
        
    End Sub 'New
     
    
    ' Parse the file and print out each node.
    Public Sub ReadFile(filename As String)
        Try
            reader = New XmlTextReader(filename)
            Dim sNodeType As String = Nothing
            While reader.Read()
                sNodeType = NodeTypeToString(reader.NodeType)
                
                'Print the node type, name, value
                Console.WriteLine("{0}<{1}> {2}", sNodeType, reader.Name, reader.Value)
            End While
        Finally
            If Not (reader Is Nothing) Then
                reader.Close()
            End If
        End Try
    End Sub 'ReadFile
     
    Public Shared Function NodeTypeToString(nodetype As XmlNodeType) As String
        Dim sNodeType As String = Nothing
        Select Case nodetype
            Case XmlNodeType.None
                sNodeType = "None"
            Case XmlNodeType.Element
                sNodeType = "Element"
            Case XmlNodeType.Attribute
                sNodeType = "Attribute"
            Case XmlNodeType.Text
                sNodeType = "Text"
            Case XmlNodeType.Comment
                sNodeType = "Comment"
            Case XmlNodeType.Document
                sNodeType = "Document"
            Case XmlNodeType.Whitespace
                sNodeType = "Whitespace"
            Case XmlNodeType.SignificantWhitespace
                sNodeType = "SignificantWhitespace"
            Case XmlNodeType.EndElement
                sNodeType = "EndElement"
        End Select
        Return sNodeType
    End Function 'NodeTypeToString
End Class 'Sample

using System;
using System.IO;
using System.Xml;

public class Sample {

  private XmlNode currNode;
  private const String filename="space.xml";
  XmlTextReader reader=null;
  
  public static void Main() {
  
    Sample test = new Sample();
  }
  public Sample() {
  
      XmlDocument doc = new XmlDocument();
      doc.LoadXml("<!-- Sample XML fragment -->" +
                  "<author xml:space='preserve'>" +
                  "<first-name>Eva</first-name>"+
                  "<last-name>Corets</last-name>" + 
                  "</author>"); 

       
      Console.WriteLine("InnerText before...");
      Console.WriteLine(doc.DocumentElement.InnerText);

      // Add white space.     
      currNode=doc.DocumentElement;
      XmlSignificantWhitespace sigws=doc.CreateSignificantWhitespace("\t");
      currNode.InsertAfter(sigws, currNode.FirstChild);

      Console.WriteLine();
      Console.WriteLine("InnerText after...");
      Console.WriteLine(doc.DocumentElement.InnerText);

      // Save and then display the file.
      doc.Save(filename);
      Console.WriteLine();
      Console.WriteLine("Reading file...");
      ReadFile(filename);

  }

  // Parse the file and print out each node.
  public void ReadFile(String filename) {
    try {
    
      reader = new XmlTextReader(filename);
      String sNodeType = null;
      while (reader.Read()) {       
       sNodeType = NodeTypeToString(reader.NodeType); 
       // Print the node type, name, and value.
       Console.WriteLine("{0}<{1}> {2}", sNodeType, reader.Name, reader.Value);
      }
    }
    finally {
       if (reader != null)
         reader.Close();
    }
   }

   public static String NodeTypeToString(XmlNodeType nodetype) {
      String sNodeType = null;
      switch (nodetype) {
        case XmlNodeType.None:
          sNodeType = "None";
          break;
        case XmlNodeType.Element:
          sNodeType = "Element";
          break;
        case XmlNodeType.Attribute:
          sNodeType = "Attribute";
          break;
        case XmlNodeType.Text:
          sNodeType = "Text";
          break;
        case XmlNodeType.Comment:
          sNodeType = "Comment";
          break;
        case XmlNodeType.Document:
          sNodeType = "Document";
          break;
        case XmlNodeType.Whitespace:
          sNodeType = "Whitespace";
          break;
        case XmlNodeType.SignificantWhitespace:
          sNodeType = "SignificantWhitespace";
          break;
        case XmlNodeType.EndElement:
          sNodeType = "EndElement";
          break;
      }
      return sNodeType;
   }
}

#using <System.Xml.dll>

using namespace System;
using namespace System::IO;
using namespace System::Xml;
public ref class Sample
{
private:
   XmlNode^ currNode;
   XmlTextReader^ reader;

public:
   Sample()
   {
      reader = nullptr;
      String^ filename = "space.xml";
      XmlDocument^ doc = gcnew XmlDocument;
      doc->LoadXml( "<!-- Sample XML fragment -->"
      "<author xml:space='preserve'>"
      "<first-name>Eva</first-name>"
      "<last-name>Corets</last-name>"
      "</author>" );
      Console::WriteLine( "InnerText before..." );
      Console::WriteLine( doc->DocumentElement->InnerText );
      
      // Add white space.     
      currNode = doc->DocumentElement;
      XmlSignificantWhitespace^ sigws = doc->CreateSignificantWhitespace( "\t" );
      currNode->InsertAfter( sigws, currNode->FirstChild );
      Console::WriteLine();
      Console::WriteLine( "InnerText after..." );
      Console::WriteLine( doc->DocumentElement->InnerText );
      
      // Save and then display the file.
      doc->Save( filename );
      Console::WriteLine();
      Console::WriteLine( "Reading file..." );
      ReadFile( filename );
   }


   // Parse the file and print out each node.
   void ReadFile( String^ filename )
   {
      try
      {
         reader = gcnew XmlTextReader( filename );
         String^ sNodeType = nullptr;
         while ( reader->Read() )
         {
            sNodeType = NodeTypeToString( reader->NodeType );
            
            // Print the node type, name, and value.
            Console::WriteLine( "{0}<{1}> {2}", sNodeType, reader->Name, reader->Value );
         }
      }
      finally
      {
         if ( reader != nullptr )
                  reader->Close();
      }

   }

   static String^ NodeTypeToString( XmlNodeType nodetype )
   {
      String^ sNodeType = nullptr;
      switch ( nodetype )
      {
         case XmlNodeType::None:
            sNodeType = "None";
            break;

         case XmlNodeType::Element:
            sNodeType = "Element";
            break;

         case XmlNodeType::Attribute:
            sNodeType = "Attribute";
            break;

         case XmlNodeType::Text:
            sNodeType = "Text";
            break;

         case XmlNodeType::Comment:
            sNodeType = "Comment";
            break;

         case XmlNodeType::Document:
            sNodeType = "Document";
            break;

         case XmlNodeType::Whitespace:
            sNodeType = "Whitespace";
            break;

         case XmlNodeType::SignificantWhitespace:
            sNodeType = "SignificantWhitespace";
            break;

         case XmlNodeType::EndElement:
            sNodeType = "EndElement";
            break;
      }
      return sNodeType;
   }

};

int main()
{
   gcnew Sample;
}

import System.*;
import System.IO.*;
import System.Xml.*;

public class Sample
{  
    private XmlNode currNode;
    private String fileName = "space.xml";
    private XmlTextReader reader = null;

    public static void main(String[] args)
    {
        Sample test = new Sample();
    } //main 

    public Sample()
    {
        XmlDocument doc = new XmlDocument();
        doc.LoadXml("<!-- Sample XML fragment -->" 
            + "<author xml:space='preserve'>" 
            + "<first-name>Eva</first-name>" 
            + "<last-name>Corets</last-name>" + "</author>");

        Console.WriteLine("InnerText before...");
        Console.WriteLine(doc.get_DocumentElement().get_InnerText());

        // Add white space.   
        currNode = doc.get_DocumentElement();
        XmlSignificantWhitespace sigws = doc.CreateSignificantWhitespace("\t");
        currNode.InsertAfter(sigws, currNode.get_FirstChild());

        Console.WriteLine();
        Console.WriteLine("InnerText after...");
        Console.WriteLine(doc.get_DocumentElement().get_InnerText());

        // Save and then display the file.
        doc.Save(fileName);
        Console.WriteLine();
        Console.WriteLine("Reading file...");
        ReadFile(fileName);
    } //Sample

    // Parse the file and print out each node.
    public void ReadFile(String fileName) 
    {
        try {
            reader = new XmlTextReader(fileName);
            String sNodeType = null;
            while(reader.Read()) {
                sNodeType = NodeTypeToString(reader.get_NodeType());
                // Print the node type, name, and value.
                Console.WriteLine("{0}<{1}> {2}", sNodeType, reader.get_Name(),
                reader.get_Value());
            }
        }
        finally {
            if ( reader != null ) {
                reader.Close();
            }
        }
    } //ReadFile

  public static String NodeTypeToString(XmlNodeType nodetype)
  {
      String sNodeType = null;
      switch(nodetype) {
          case XmlNodeType.None : 
              sNodeType = "None";
              break;
          case XmlNodeType.Element : 
              sNodeType = "Element";
              break;
          case XmlNodeType.Attribute : 
              sNodeType = "Attribute";
              break;
          case XmlNodeType.Text : 
              sNodeType = "Text";
              break;
          case XmlNodeType.Comment : 
              sNodeType = "Comment";
              break;
          case XmlNodeType.Document : 
              sNodeType = "Document";
              break;
          case XmlNodeType.Whitespace : 
              sNodeType = "Whitespace";
              break;
          case XmlNodeType.SignificantWhitespace : 
              sNodeType = "SignificantWhitespace";
              break;
          case XmlNodeType.EndElement : 
              sNodeType = "EndElement";
              break;
    }
    return sNodeType;
  } //NodeTypeToString
} //Sample

Plattformen

Windows 98, Windows 2000 SP4, Windows CE, Windows Millennium Edition, Windows Mobile für Pocket PC, Windows Mobile für Smartphone, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

.NET Framework unterstützt nicht alle Versionen sämtlicher Plattformen. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen.

Versionsinformationen

.NET Framework

Unterstützt in: 2.0, 1.1, 1.0

.NET Compact Framework

Unterstützt in: 2.0, 1.0

Siehe auch

Referenz

XmlSignificantWhitespace-Klasse
XmlSignificantWhitespace-Member
System.Xml-Namespace
XmlNodeType-Enumeration