XmlDocument Classe

Definizione

Rappresenta un documento XML.Represents an XML document. È possibile usare questa classe per caricare, convalidare, modificare, aggiungere e posizionare XML in un documento.You can use this class to load, validate, edit, add, and position XML in a document.

public ref class XmlDocument : System::Xml::XmlNode
public class XmlDocument : System.Xml.XmlNode
type XmlDocument = class
    inherit XmlNode
Public Class XmlDocument
Inherits XmlNode
Ereditarietà
XmlDocument
Derivato

Commenti

La XmlDocument classe è una rappresentazione in memoria di un documento XML.The XmlDocument class is an in-memory representation of an XML document. Implementa il W3C XML Document Object Model (Dom) Level 1 core e Core DOM Level 2.It implements the W3C XML Document Object Model (DOM) Level 1 Core and the Core DOM Level 2.

Dom sta per il modello a oggetti documento.DOM stands for document object model. Per altre informazioni, vedere XML Document Object Model (Dom).To read more about it, see XML Document Object Model (DOM).

È possibile caricare il codice XML nel DOM utilizzando la XmlDocument classe e quindi leggere, modificare e rimuovere codice XML nel documento a livello di codice.You can load XML into the DOM by using the XmlDocument class, and then programmatically read, modify, and remove XML in the document.

Se si vuole aprire la XmlDocument classe e vedere come viene implementata, vedere origine riferimento.If you want to pry open the XmlDocument class and see how it's implemented, see the Reference Source.

AttivitàTasks

Caricare XML nel modello a oggetti DocumentLoad XML into the document object model

Iniziare con un documento XML simile a quello che include alcuni libri in una raccolta.Start with an XML document like this one that has a few books in a collection. Contiene le informazioni di base disponibili in qualsiasi documento XML, inclusi uno spazio dei nomi, elementi che rappresentano i dati e attributi che descrivono i dati.It contains the basic things that you'd find in any XML document, including a namespace, elements that represent data, and attributes that describe the data.

<?xml version="1.0" encoding="utf-8"?>  
<books xmlns="http://www.contoso.com/books">  
  <book genre="novel" ISBN="1-861001-57-8" publicationdate="1823-01-28">  
    <title>Pride And Prejudice</title>  
    <price>24.95</price>  
  </book>  
  <book genre="novel" ISBN="1-861002-30-1" publicationdate="1985-01-01">  
    <title>The Handmaid's Tale</title>  
    <price>29.95</price>  
  </book>  
  <book genre="novel" ISBN="1-861001-45-3" publicationdate="1811-01-01">  
    <title>Sense and Sensibility</title>  
    <price>19.95</price>  
  </book>  
</books>  

Successivamente, caricare i dati nel DOM in modo che sia possibile utilizzarli in memoria.Next, load this data into the DOM so that you can work with it in memory. Il modo più comune per eseguire questa operazione è fare riferimento a un file nel computer locale o in una rete.The most popular way to do this is refer to a file on your local computer or on a network.

In questo esempio viene caricato il codice XML da un file.This example loads XML from a file. Se il file non esiste, genera solo codice XML e lo carica.If the file doesn't exist, it just generates some XML and loads that.

XmlDocument ^doc = gcnew XmlDocument();
doc->PreserveWhitespace = true;
try
{doc->Load("booksData.xml");}
catch (System::IO::FileNotFoundException ^e1)
{
    // If no book is found, generate some XML.

    doc->LoadXml("<?xml version=\"1.0\"?> \n" +
    "<books xmlns=\"http://www.contoso.com/books\"> \n" +
    "  <book genre=\"novel\" ISBN=\"1-861001-57-8\" publicationdate=\"1823-01-28\"> \n" +
    "    <title>Pride And Prejudice</title> \n" +
    "    <price>24.95</price> \n" +
    "  </book> \n" +
    "  <book genre=\"novel\" ISBN=\"1-861002-30-1\" publicationdate=\"1985-01-01\"> \n" +
    "    <title>The Handmaid's Tale</title> \n" +
    "    <price>29.95</price> \n" +
    "  </book> \n" +
    "</books>");
}
XmlDocument doc = new XmlDocument();
doc.PreserveWhitespace = true;
try { doc.Load("booksData.xml"); }
catch (System.IO.FileNotFoundException)
{
    doc.LoadXml("<?xml version=\"1.0\"?> \n" +
    "<books xmlns=\"http://www.contoso.com/books\"> \n" +
    "  <book genre=\"novel\" ISBN=\"1-861001-57-8\" publicationdate=\"1823-01-28\"> \n" +
    "    <title>Pride And Prejudice</title> \n" +
    "    <price>24.95</price> \n" +
    "  </book> \n" +
    "  <book genre=\"novel\" ISBN=\"1-861002-30-1\" publicationdate=\"1985-01-01\"> \n" +
    "    <title>The Handmaid's Tale</title> \n" +
    "    <price>29.95</price> \n" +
    "  </book> \n" +
    "</books>");             
}
Dim doc As XmlDocument = New XmlDocument
doc.PreserveWhitespace = True
Try
    doc.Load("booksData.xml")
Catch ex As System.IO.FileNotFoundException
    ' If no file is found, generate some XML.
    doc.LoadXml("<?xml version=""1.0""?> " & ControlChars.NewLine & _
        "<books xmlns=""http://www.contoso.com/books""> " & ControlChars.NewLine & _
        "  <book genre=""novel"" ISBN=""1-861001-57-8"" publicationdate=""1823-01-28""> " & ControlChars.NewLine & _
        "    <title>Pride And Prejudice</title> " & ControlChars.NewLine & _
        "    <price>24.95</price> " & ControlChars.NewLine & _
        "  </book> " & ControlChars.NewLine & _
        "  <book genre=""novel"" ISBN=""1-861002-30-1"" publicationdate=""1985-01-01""> " & ControlChars.NewLine & _
        "    <title>The Handmaid's Tale</title> " & ControlChars.NewLine & _
        "    <price>29.95</price> " & ControlChars.NewLine & _
        "  </book> " & ControlChars.NewLine & _
        "</books>")
End Try

Esempio completo: Modificare XML in memoria usando la classe XmlDocument e altri tipi correlatiComplete sample: Manipulate XML in-Memory by using the XmlDocument class and other related types

Altre informazioni: Lettura di un documento XML nel DOMLearn more: Reading an XML Document into the DOM

Convalidarlo in base a uno schemaValidate it against a schema

Iniziare con un XML Schema come questo.Start with an XML schema like this one. Questo schema definisce i tipi di dati nel codice XML e quali attributi sono obbligatori.This schema defines the data types in the XML and which attributes are required.

<?xml version="1.0" encoding="utf-8"?>  
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"  
  attributeFormDefault="unqualified"   
  elementFormDefault="qualified"  
  targetNamespace="http://www.contoso.com/books">   
  <xs:element name="books">  
    <xs:complexType>  
      <xs:sequence>  
        <xs:element maxOccurs="unbounded" name="book">  
          <xs:complexType>  
            <xs:sequence>  
              <xs:element name="title" type="xs:string" />  
              <xs:element name="price" type="xs:decimal" />  
            </xs:sequence>  
            <xs:attribute name="genre" type="xs:string" use="required" />  
            <xs:attribute name="ISBN" type="xs:string" use="required" />  
            <xs:attribute name="publicationdate" type="xs:date" use="required" />  
          </xs:complexType>  
        </xs:element>  
      </xs:sequence>  
    </xs:complexType>  
  </xs:element>  
</xs:schema>  

Creare un XmlReader oggetto utilizzando lo schema, quindi caricare l'oggetto nel DOM.Create an XmlReader object by using your schema, and then load that object into the DOM. Creare un gestore eventi che viene eseguito quando il codice tenta di modificare il file XML in modi che violano le regole dello schema.Create an event handler that executes when code attempts to modify your XML file in ways that violate the rules of the schema.

Questi blocchi di codice mostrano metodi helper che eseguono tutte queste operazioni.These blocks of code show helper methods that do all of this.

//************************************************************************************
//
//  Associate the schema with XML. Then, load the XML and validate it against
//  the schema.
//
//************************************************************************************

XmlDocument ^XMLDOMProcessing::XMLHelperMethods::LoadDocumentWithSchemaValidation(bool generateXML, bool generateSchema)
{
    XmlReader ^reader;

    XmlReaderSettings ^settings = gcnew XmlReaderSettings();

    // Helper method to retrieve schema.
    XmlSchema ^schema = getSchema(generateSchema);
    
    if (schema == nullptr)
    {
        return nullptr;
    }

    settings->Schemas->Add(schema);
    settings->ValidationEventHandler +=
        gcnew System::Xml::Schema::ValidationEventHandler
        (this, &XMLDOMProcessing::XMLHelperMethods::OnValidationEventHandler);
    settings->ValidationFlags = settings->ValidationFlags | XmlSchemaValidationFlags::ReportValidationWarnings;
    settings->ValidationType = ValidationType::Schema;

    try
    {
        reader = XmlReader::Create("booksData.xml", settings);
    }
    catch (System::IO::FileNotFoundException ^e1)
    {
        if (generateXML)
        {
            String ^xml = generateXMLString();
            array<Byte> ^byteArray = Encoding::UTF8->GetBytes(xml);
            MemoryStream ^stream = gcnew MemoryStream(byteArray);
            reader = XmlReader::Create(stream, settings);
        }
        else
        {
            return nullptr;
        }

    }

    XmlDocument ^doc = gcnew XmlDocument();
    doc->PreserveWhitespace = true;
    doc->Load(reader);
    reader->Close();

    return doc;
}

//************************************************************************************
//
//  Helper method that generates an XML Schema.
//
//************************************************************************************

String ^XMLDOMProcessing::XMLHelperMethods::generateXMLSchema()
{
    String ^xmlSchema = "<?xml version=\"1.0\" encoding=\"utf-8\"?> " + 
        "<xs:schema attributeFormDefault=\"unqualified\" " + 
        "elementFormDefault=\"qualified\" targetNamespace=\"http://www.contoso.com/books\" " + 
        "xmlns:xs=\"http://www.w3.org/2001/XMLSchema\"> " + "<xs:element name=\"books\"> " + 
        "<xs:complexType> " + "<xs:sequence> " + "<xs:element maxOccurs=\"unbounded\" name=\"book\"> " + 
        "<xs:complexType> " + "<xs:sequence> " + "<xs:element name=\"title\" type=\"xs:string\" /> " + 
        "<xs:element name=\"price\" type=\"xs:decimal\" /> " + "</xs:sequence> " + 
        "<xs:attribute name=\"genre\" type=\"xs:string\" use=\"required\" /> " + 
        "<xs:attribute name=\"publicationdate\" type=\"xs:date\" use=\"required\" /> " + 
        "<xs:attribute name=\"ISBN\" type=\"xs:string\" use=\"required\" /> " + "</xs:complexType> " + 
        "</xs:element> " + "</xs:sequence> " + "</xs:complexType> " + "</xs:element> " + "</xs:schema> ";
    
    return xmlSchema;
}

//************************************************************************************
//
//  Helper method that gets a schema
//
//************************************************************************************

XmlSchema ^XMLDOMProcessing::XMLHelperMethods::getSchema(bool generateSchema)
{
    XmlSchemaSet ^xs = gcnew XmlSchemaSet();
    XmlSchema ^schema;
    try
    {
        schema = xs->Add("http://www.contoso.com/books", "booksData.xsd");
    }
    catch (System::IO::FileNotFoundException ^e1)
    {
        if (generateSchema)
        {
            String ^xmlSchemaString = generateXMLSchema();
            array<Byte> ^byteArray = Encoding::UTF8->GetBytes(xmlSchemaString);
            MemoryStream ^stream = gcnew MemoryStream(byteArray);
            XmlReader ^reader = XmlReader::Create(stream);
            schema = xs->Add("http://www.contoso.com/books", reader);
        }
        else
        {
            return nullptr;
        }

    }
    return schema;
}
//************************************************************************************
//
//  Helper method to validate the XML against the schema.
//
//************************************************************************************
bool XMLDOMProcessing::XMLHelperMethods::validateXML(bool generateSchema, XmlDocument ^doc)
{
    if (doc->Schemas->Count == 0)
    {
        // Helper method to retrieve schema.
        XmlSchema ^schema = getSchema(generateSchema);
        doc->Schemas->Add(schema);
    }

    ValidationEventHandler^ eventHandler = gcnew System::Xml::Schema::ValidationEventHandler
        (this, &XMLDOMProcessing::XMLHelperMethods::OnValidationEventHandler);

    // Use an event handler to validate the XML node against the schema.
    doc->Validate(eventHandler);

    if (_IsValid == false)
    {
        _IsValid = true;
        return false;
    }
    else
    {
        return true;
    }

}
//************************************************************************************
//
//  Event handler that is raised when XML doesn't validate against the schema.
//
//************************************************************************************

void XMLDOMProcessing::XMLHelperMethods::OnValidationEventHandler(System::Object ^sender, System::Xml::Schema::ValidationEventArgs ^e)
{
    if (e->Severity == XmlSeverityType::Warning)
    {
        // do nothing.
    }
    else if (e->Severity == XmlSeverityType::Error)
    {
        // set some global variables.
        _IsValid = false;
        ValidationError = e->Message;
    }
}

//************************************************************************************
//
//  Associate the schema with XML. Then, load the XML and validate it against
//  the schema.
//
//************************************************************************************
public XmlDocument LoadDocumentWithSchemaValidation(bool generateXML, bool generateSchema)
{
    XmlReader reader;

    XmlReaderSettings settings = new XmlReaderSettings();

    // Helper method to retrieve schema.
    XmlSchema schema = getSchema(generateSchema);

    if (schema == null)
    {
        return null;
    }

    settings.Schemas.Add(schema);

    settings.ValidationEventHandler += settings_ValidationEventHandler;
    settings.ValidationFlags =
        settings.ValidationFlags | XmlSchemaValidationFlags.ReportValidationWarnings;
    settings.ValidationType = ValidationType.Schema;

    try
    {
        reader = XmlReader.Create("booksData.xml", settings);
    }
    catch (System.IO.FileNotFoundException)
    {
        if (generateXML)
        {
            string xml = generateXMLString();
            byte[] byteArray = Encoding.UTF8.GetBytes(xml);
            MemoryStream stream = new MemoryStream(byteArray);
            reader = XmlReader.Create(stream, settings);
        }
        else
        {
            return null;
        }

    }

    XmlDocument doc = new XmlDocument();
    doc.PreserveWhitespace = true;
    doc.Load(reader);
    reader.Close();

    return doc;
}

//************************************************************************************
//
//  Helper method that generates an XML Schema.
//
//************************************************************************************
private string generateXMLSchema()
{
    string xmlSchema =
        "<?xml version=\"1.0\" encoding=\"utf-8\"?> " +
        "<xs:schema attributeFormDefault=\"unqualified\" " +
        "elementFormDefault=\"qualified\" targetNamespace=\"http://www.contoso.com/books\" " +
        "xmlns:xs=\"http://www.w3.org/2001/XMLSchema\"> " +
        "<xs:element name=\"books\"> " +
        "<xs:complexType> " +
        "<xs:sequence> " +
        "<xs:element maxOccurs=\"unbounded\" name=\"book\"> " +
        "<xs:complexType> " +
        "<xs:sequence> " +
        "<xs:element name=\"title\" type=\"xs:string\" /> " +
        "<xs:element name=\"price\" type=\"xs:decimal\" /> " +
        "</xs:sequence> " +
        "<xs:attribute name=\"genre\" type=\"xs:string\" use=\"required\" /> " +
        "<xs:attribute name=\"publicationdate\" type=\"xs:date\" use=\"required\" /> " +
        "<xs:attribute name=\"ISBN\" type=\"xs:string\" use=\"required\" /> " +
        "</xs:complexType> " +
        "</xs:element> " +
        "</xs:sequence> " +
        "</xs:complexType> " +
        "</xs:element> " +
        "</xs:schema> ";
    return xmlSchema;
}

//************************************************************************************
//
//  Helper method that gets a schema
//
//************************************************************************************
private XmlSchema getSchema(bool generateSchema)
{
    XmlSchemaSet xs = new XmlSchemaSet();
    XmlSchema schema;
    try
    {
        schema = xs.Add("http://www.contoso.com/books", "booksData.xsd");
    }
    catch (System.IO.FileNotFoundException)
    {
        if (generateSchema)
        {
            string xmlSchemaString = generateXMLSchema();
            byte[] byteArray = Encoding.UTF8.GetBytes(xmlSchemaString);
            MemoryStream stream = new MemoryStream(byteArray);
            XmlReader reader = XmlReader.Create(stream);
            schema = xs.Add("http://www.contoso.com/books", reader);
        }
        else
        {
            return null;
        }

    }
    return schema;
}

//************************************************************************************
//
//  Helper method to validate the XML against the schema.
//
//************************************************************************************
private void validateXML(bool generateSchema, XmlDocument doc)
{
    if (doc.Schemas.Count == 0)
    {
        // Helper method to retrieve schema.
        XmlSchema schema = getSchema(generateSchema);
        doc.Schemas.Add(schema);
    }

    // Use an event handler to validate the XML node against the schema.
    doc.Validate(settings_ValidationEventHandler);

}

//************************************************************************************
//
//  Event handler that is raised when XML doesn't validate against the schema.
//
//************************************************************************************
void settings_ValidationEventHandler(object sender,
    System.Xml.Schema.ValidationEventArgs e)
{
    if (e.Severity == XmlSeverityType.Warning)
    {
        System.Windows.Forms.MessageBox.Show
            ("The following validation warning occurred: " + e.Message);
    }
    else if (e.Severity == XmlSeverityType.Error)
    {
        System.Windows.Forms.MessageBox.Show
            ("The following critical validation errors occurred: " + e.Message);
        Type objectType = sender.GetType();
    }

}
'************************************************************************************
'
'  Associate the schema with XML. Then, load the XML and validate it against
'  the schema.
'
'************************************************************************************
Public Function LoadDocumentWithSchemaValidation(ByVal generateXML As Boolean, ByVal generateSchema As Boolean) As XmlDocument
    Dim reader As XmlReader
    Dim settings As XmlReaderSettings = New XmlReaderSettings
    ' Helper method to retrieve schema.
    Dim schema As XmlSchema = getSchema(generateSchema)
    If (schema Is Nothing) Then
        Return Nothing
    End If
    settings.Schemas.Add(schema)
    AddHandler settings.ValidationEventHandler, AddressOf settings_ValidationEventHandler
    settings.ValidationFlags = (settings.ValidationFlags Or XmlSchemaValidationFlags.ReportValidationWarnings)
    settings.ValidationType = ValidationType.Schema
    Try
        reader = XmlReader.Create("booksData.xml", settings)
    Catch ex As System.IO.FileNotFoundException
        If generateXML Then
            Dim xml As String = generateXMLString()
            Dim byteArray() As Byte = Encoding.UTF8.GetBytes(xml)
            Dim stream As MemoryStream = New MemoryStream(byteArray)
            reader = XmlReader.Create(stream, settings)
        Else
            Return Nothing
        End If
    End Try
    Dim doc As XmlDocument = New XmlDocument
    doc.PreserveWhitespace = True
    doc.Load(reader)
    reader.Close()
    Return doc
End Function

'************************************************************************************
'
'  Helper method that generates an XML Schema.
'
'************************************************************************************
Private Function generateXMLSchema() As String

    Dim generatedXmlSchema As String = "<?xml version=""1.0"" encoding=""utf-8""?> " & _
            "<xs:schema attributeFormDefault=""unqualified"" " & _
            "elementFormDefault=""qualified"" targetNamespace=""http://www.contoso.com/books"" " & _
            "xmlns:xs=""http://www.w3.org/2001/XMLSchema""> " & _
            "<xs:element name=""books""> " & _
            "<xs:complexType> " & _
            "<xs:sequence> " & _
            "<xs:element maxOccurs=""unbounded"" name=""book""> " & _
            "<xs:complexType> " & _
            "<xs:sequence> " & _
            "<xs:element name=""title"" type=""xs:string"" /> " & _
            "<xs:element name=""price"" type=""xs:decimal"" /> " & _
            "</xs:sequence> " & _
            "<xs:attribute name=""genre"" type=""xs:string"" use=""required"" /> " & _
            "<xs:attribute name=""publicationdate"" type=""xs:date"" use=""required"" /> " & _
            "<xs:attribute name=""ISBN"" type=""xs:string"" use=""required"" /> " & _
            "</xs:complexType> " & _
            "</xs:element> " & _
            "</xs:sequence> " & _
            "</xs:complexType> " & _
            "</xs:element> " & _
            "</xs:schema> "


    Return generatedXmlSchema

End Function

'************************************************************************************
'
'  Helper method that gets a schema
'
'************************************************************************************
Private Function getSchema(ByVal generateSchema As Boolean) As XmlSchema
    Dim xs As XmlSchemaSet = New XmlSchemaSet
    Dim schema As XmlSchema
    Try
        schema = xs.Add("http://www.contoso.com/books", "booksData.xsd")
    Catch ex As System.IO.FileNotFoundException
        If generateSchema Then
            Dim xmlSchemaString As String = generateXMLSchema()
            Dim byteArray() As Byte = Encoding.UTF8.GetBytes(xmlSchemaString)
            Dim stream As MemoryStream = New MemoryStream(byteArray)
            Dim reader As XmlReader = XmlReader.Create(stream)
            schema = xs.Add("http://www.contoso.com/books", reader)
        Else
            Return Nothing
        End If
    End Try
    Return schema
End Function

'************************************************************************************
'
'  Helper method to validate the XML against the schema.
'
'************************************************************************************
Private Sub validateXML(ByVal generateSchema As Boolean, ByVal doc As XmlDocument)
    If (doc.Schemas.Count = 0) Then
        ' Helper method to retrieve schema.
        Dim schema As XmlSchema = getSchema(generateSchema)
        doc.Schemas.Add(schema)
    End If
    ' Use an event handler to validate the XML node against the schema.
    doc.Validate(AddressOf settings_ValidationEventHandler)
End Sub

'************************************************************************************
'
'  Event handler that is raised when XML doesn't validate against the schema.
'
'************************************************************************************
Private Sub settings_ValidationEventHandler(ByVal sender As Object, ByVal e As System.Xml.Schema.ValidationEventArgs)
    If (e.Severity = XmlSeverityType.Warning) Then
        System.Windows.Forms.MessageBox.Show(("The following validation warning occurred: " & e.Message))
    ElseIf (e.Severity = XmlSeverityType.Error) Then
        System.Windows.Forms.MessageBox.Show(("The following critical validation errors occurred: " & e.Message))
        Dim objectType As Type = sender.GetType
    End If
End Sub

Esempio completo: Modificare XML in memoria usando la classe XmlDocument e altri tipi correlatiComplete sample: Manipulate XML in-Memory by using the XmlDocument class and other related types

Altre informazioni: Convalida di un documento XML nel DOMLearn more: Validating an XML Document in the DOM

È possibile utilizzare le proprietà per spostarsi in un documento XML.You can use properties to navigate around an XML document. Tuttavia, prima di usare uno di essi, è possibile esaminare rapidamente alcuni termini.But before you use any of them, let's quickly review a few terms. Il documento è costituito da nodi.Your document is composed of nodes. Ogni nodo ha come singolo nodo padre direttamente sopra.Each node has as single parent node directly above it. L'unico nodo che non dispone di un nodo padre è la radice del documento, perché si tratta del nodo di primo livello.The only node that does not have a parent node is the document root, as it is the top-level node. La maggior parte dei nodi può avere nodi figlio , che sono nodi direttamente sotto di essi.Most nodes can have child nodes, which are nodes directly below them. I nodi che si trovano allo stesso livello sono elementi di parilivello.Nodes that are at the same level are siblings.

Gli esempi seguenti illustrano come ottenere il nodo radice, passare al primo nodo figlio del nodo radice, accedere a uno dei relativi nodi figlio, tornare al nodo padre e spostarsi tra i nodi di pari livello.The following examples show you how to obtain the root node, jump to the first child node of the root node, access any of its child nodes, get back out to the parent node, and then navigate across sibling nodes.

Inizia con il nodo radiceStart with the root node

Questo esempio Mostra come ottenere il nodo radice e quindi usare tale nodo per restituire il contenuto del documento alla console.This example gets the root node and then uses that node to output the contents of the document to the console.

#using <System.Xml.dll>

using namespace System;
using namespace System::IO;
using namespace System::Xml;
int main()
{
   
   //Create the XmlDocument.
   XmlDocument^ doc = gcnew XmlDocument;
   doc->LoadXml( "<?xml version='1.0' ?><book genre='novel' ISBN='1-861001-57-5'><title>Pride And Prejudice</title></book>" );
   
   //Display the document element.
   Console::WriteLine( doc->DocumentElement->OuterXml );
}

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

public class Sample
{
  public static void Main()
  {
    //Create the XmlDocument.
    XmlDocument doc = new XmlDocument();
    doc.LoadXml("<?xml version='1.0' ?>" +
                "<book genre='novel' ISBN='1-861001-57-5'>" +
                "<title>Pride And Prejudice</title>" +
                "</book>");

    //Display the document element.
    Console.WriteLine(doc.DocumentElement.OuterXml);
 }
}
Option Strict
Option Explicit

Imports System.IO
Imports System.Xml

Public Class Sample
    
    Public Shared Sub Main()
        'Create the XmlDocument.
        Dim doc As New XmlDocument()
        doc.LoadXml("<?xml version='1.0' ?>" & _
                    "<book genre='novel' ISBN='1-861001-57-5'>" & _
                    "<title>Pride And Prejudice</title>" & _
                    "</book>")
        
        'Display the document element.
        Console.WriteLine(doc.DocumentElement.OuterXml)
    End Sub
End Class

Ottenere i nodi figlioGet child nodes

Questo esempio passa al primo nodo figlio del nodo radice e quindi scorre i nodi figlio del nodo, se presenti.This example jumps to the first child node of the root node and then iterates through the child nodes of that node if any exist.

#using <System.Xml.dll>

using namespace System;
using namespace System::IO;
using namespace System::Xml;

int main()
{
   XmlDocument^ doc = gcnew XmlDocument;
   doc->LoadXml( "<book ISBN='1-861001-57-5'>"
   "<title>Pride And Prejudice</title>"
   "<price>19.95</price>"
   "</book>" );
   XmlNode^ root = doc->FirstChild;
   
   //Display the contents of the child nodes.
   if ( root->HasChildNodes )
   {
      for ( int i = 0; i < root->ChildNodes->Count; i++ )
      {
         Console::WriteLine( root->ChildNodes[ i ]->InnerText );
      }
   }
}
using System;
using System.IO;
using System.Xml;

public class Sample {

  public static void Main() {

    XmlDocument doc = new XmlDocument();
    doc.LoadXml("<book ISBN='1-861001-57-5'>" +
                "<title>Pride And Prejudice</title>" +
                "<price>19.95</price>" +
                "</book>");

    XmlNode root = doc.FirstChild;

    //Display the contents of the child nodes.
    if (root.HasChildNodes)
    {
      for (int i=0; i<root.ChildNodes.Count; i++)
      {
        Console.WriteLine(root.ChildNodes[i].InnerText);
      }
    }
  }
}
Option Strict
Option Explicit

Imports System.IO
Imports System.Xml

Public Class Sample
    
    Public Shared Sub Main()
        
        Dim doc As New XmlDocument()
        doc.LoadXml("<book ISBN='1-861001-57-5'>" & _
                    "<title>Pride And Prejudice</title>" & _
                    "<price>19.95</price>" & _
                    "</book>")
        
        Dim root As XmlNode = doc.FirstChild
        
        'Display the contents of the child nodes.
        If root.HasChildNodes Then
            Dim i As Integer
            For i = 0 To root.ChildNodes.Count - 1
                Console.WriteLine(root.ChildNodes(i).InnerText)
            Next i
        End If
    End Sub
End Class

Tornare al nodo padreGet back to the parent node

Usare la proprietà ParentNode.Use the ParentNode property.

Fare riferimento all'ultimo nodo figlioRefer to the last child node

In questo esempio viene scritto il prezzo di un libro nella console.This example writes the price of a book to the console. Il nodo Price è l'ultimo elemento figlio di un nodo libro.The price node is the last child of a book node.

#using <System.Xml.dll>

using namespace System;
using namespace System::IO;
using namespace System::Xml;
int main()
{
   XmlDocument^ doc = gcnew XmlDocument;
   doc->LoadXml( "<book ISBN='1-861001-57-5'>"
   "<title>Pride And Prejudice</title>"
   "<price>19.95</price>"
   "</book>" );
   XmlNode^ root = doc->FirstChild;
   Console::WriteLine( "Display the price element..." );
   Console::WriteLine( root->LastChild->OuterXml );
}

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

public class Sample {

  public static void Main() {

    XmlDocument doc = new XmlDocument();
    doc.LoadXml("<book ISBN='1-861001-57-5'>" +
                "<title>Pride And Prejudice</title>" +
                "<price>19.95</price>" +
                "</book>");

    XmlNode root = doc.FirstChild;

    Console.WriteLine("Display the price element...");
    Console.WriteLine(root.LastChild.OuterXml);
  }
}
Option Explicit
Option Strict

Imports System.IO
Imports System.Xml

Public Class Sample
    
    Public Shared Sub Main()
        
        Dim doc As New XmlDocument()
        doc.LoadXml("<book ISBN='1-861001-57-5'>" & _
                    "<title>Pride And Prejudice</title>" & _
                    "<price>19.95</price>" & _
                    "</book>")
        
        Dim root As XmlNode = doc.FirstChild
        
        Console.WriteLine("Display the price element...")
        Console.WriteLine(root.LastChild.OuterXml)
    End Sub
End Class

Spostarsi in diretta tra gli elementi di pari livelloNavigate forward across siblings

Questo esempio passa da Book a book.This example moves forward from book to book. I nodi del libro sono di pari livello tra loro.Book nodes are siblings to one another.

#using <System.Xml.dll>

using namespace System;
using namespace System::Xml;
int main()
{
   XmlDocument^ doc = gcnew XmlDocument;
   doc->Load( "books.xml" );
   XmlNode^ currNode = doc->DocumentElement->FirstChild;
   Console::WriteLine( "First book..." );
   Console::WriteLine( currNode->OuterXml );
   XmlNode^ nextNode = currNode->NextSibling;
   Console::WriteLine( "\r\nSecond book..." );
   Console::WriteLine( nextNode->OuterXml );
}

using System;
using System.Xml;

public class Sample {

  public static void Main() {

      XmlDocument doc = new XmlDocument();
      doc.Load("books.xml");

      XmlNode currNode = doc.DocumentElement.FirstChild;
      Console.WriteLine("First book...");
      Console.WriteLine(currNode.OuterXml);

      XmlNode nextNode = currNode.NextSibling;
      Console.WriteLine("\r\nSecond book...");
      Console.WriteLine(nextNode.OuterXml); 

  }
}
Imports System.Xml
 
public class Sample 

  public shared sub Main() 

      Dim doc as XmlDocument = new XmlDocument()
      doc.Load("books.xml")

      Dim currNode as XmlNode = doc.DocumentElement.FirstChild
      Console.WriteLine("First book...")
      Console.WriteLine(currNode.OuterXml)

      Dim nextNode as XmlNode = currNode.NextSibling
      Console.WriteLine(ControlChars.LF + "Second book...")
      Console.WriteLine(nextNode.OuterXml) 

  end sub
end class

Spostarsi all'indietro tra gli elementi di pari livelloNavigate backwards across siblings

Questo esempio si sposta indietro da Book a book.This example moves backwards from book to book.

#using <System.Xml.dll>

using namespace System;
using namespace System::Xml;
int main()
{
   XmlDocument^ doc = gcnew XmlDocument;
   doc->Load( "books.xml" );
   XmlNode^ lastNode = doc->DocumentElement->LastChild;
   Console::WriteLine( "Last book..." );
   Console::WriteLine( lastNode->OuterXml );
   XmlNode^ prevNode = lastNode->PreviousSibling;
   Console::WriteLine( "\r\nPrevious book..." );
   Console::WriteLine( prevNode->OuterXml );
}

using System;
using System.Xml;

public class Sample {

  public static void Main() {

      XmlDocument doc = new XmlDocument();
      doc.Load("books.xml");

      XmlNode lastNode = doc.DocumentElement.LastChild;
      Console.WriteLine("Last book...");
      Console.WriteLine(lastNode.OuterXml);

      XmlNode prevNode = lastNode.PreviousSibling;
      Console.WriteLine("\r\nPrevious book...");
      Console.WriteLine(prevNode.OuterXml);  
  }
}
Imports System.Xml

public class Sample 

  public shared sub Main() 

      Dim doc as XmlDocument = new XmlDocument()
      doc.Load("books.xml")

      Dim lastNode as XmlNode = doc.DocumentElement.LastChild
      Console.WriteLine("Last book...")
      Console.WriteLine(lastNode.OuterXml)

      Dim prevNode as XmlNode = lastNode.PreviousSibling
      Console.WriteLine(ControlChars.LF + "Previous book...")
      Console.WriteLine(prevNode.OuterXml)  
  end sub
end class

Trova nodiFind nodes

Il modo più comune per trovare uno o più nodi di dati consiste nell'usare una stringa di query XPath, ma esistono anche metodi che non ne richiedono uno.The most popular way to find one or more nodes of data is to use an XPath query string, but there are also methods that don't require one.

Ottenere un singolo nodoGet a single node

In questo esempio viene individuato un libro utilizzando il numero ISBN.This example locates a book by using the ISBN number.

XmlNode ^XMLDOMProcessing::XMLHelperMethods::GetBook(String ^uniqueAttribute, XmlDocument ^doc)
{
    XmlNamespaceManager ^nsmgr = gcnew XmlNamespaceManager(doc->NameTable);
    nsmgr->AddNamespace("bk", "http://www.contoso.com/books");
    String ^xPathString = "//bk:books/bk:book[@ISBN='" + uniqueAttribute + "']";
    XmlNode ^xmlNode = doc->DocumentElement->SelectSingleNode(xPathString, nsmgr);
    return xmlNode;
}
public XmlNode GetBook(string uniqueAttribute, XmlDocument doc)
{
    XmlNamespaceManager nsmgr = new XmlNamespaceManager(doc.NameTable);
    nsmgr.AddNamespace("bk", "http://www.contoso.com/books");
    string xPathString = "//bk:books/bk:book[@ISBN='" + uniqueAttribute + "']";
    XmlNode xmlNode = doc.DocumentElement.SelectSingleNode(xPathString, nsmgr);
   return xmlNode;
}
Public Function GetBook(ByVal uniqueAttribute As String, ByVal doc As XmlDocument) As XmlNode
    Dim nsmgr As XmlNamespaceManager = New XmlNamespaceManager(doc.NameTable)
    nsmgr.AddNamespace("bk", "http://www.contoso.com/books")
    Dim xPathString As String = ("//bk:books/bk:book[@ISBN='" _
                & (uniqueAttribute & "']"))
    Dim xmlNode As XmlNode = doc.DocumentElement.SelectSingleNode(xPathString, nsmgr)
    Return xmlNode
End Function

La stringa utilizzata in questo esempio è una query XPath.The string used in this example is an Xpath query. Per ulteriori esempi, vedere: Esempi di XPath.You can find more examples of them here: XPath examples.

È anche possibile usare per GetElementById recuperare i nodi.You can also use the GetElementById to retrieve nodes. Per utilizzare questo approccio, è necessario definire gli ID nella Document Type Definition dichiarazioni del file XML.To use this approach, you'll have to define ID's in the document type definition declarations of your XML file.

Dopo aver ottenuto un nodo, è possibile ottenere il valore di attributi o nodi figlio.After you get a node, you get the value of attributes or child nodes. Questo esempio esegue questa operazione con un nodo libro.This example does that with a book node.

void XMLDOMProcessing::XMLHelperMethods::GetBookInformation
(String ^%title, String ^%ISBN, String ^%publicationDate, String ^%price, String ^%genre, XmlNode ^book)
{
    XmlElement ^bookElement = safe_cast<XmlElement^>(book);

    // Get the attributes of a book.        
    XmlAttribute ^attr = bookElement->GetAttributeNode("ISBN");
    ISBN = attr->InnerXml;

    attr = bookElement->GetAttributeNode("genre");
    genre = attr->InnerXml;

    attr = bookElement->GetAttributeNode("publicationdate");
    publicationDate = attr->InnerXml;

    // Get the values of child elements of a book.
    title = bookElement["title"]->InnerText;
    price = bookElement["price"]->InnerText;
}
public void GetBookInformation(ref string title, ref string ISBN, ref string publicationDate,
    ref string price, ref string genre, XmlNode book)
{
    XmlElement bookElement = (XmlElement)book;

    // Get the attributes of a book.        
    XmlAttribute attr = bookElement.GetAttributeNode("ISBN");
    ISBN = attr.InnerXml;

    attr = bookElement.GetAttributeNode("genre");
    genre = attr.InnerXml;

    attr = bookElement.GetAttributeNode("publicationdate");
    publicationDate = attr.InnerXml;

    // Get the values of child elements of a book.
    title = bookElement["title"].InnerText;
    price = bookElement["price"].InnerText;
}
Public Sub GetBookInformation(ByRef title As String, ByRef ISBN As String, ByRef publicationDate As String, ByRef price As String, ByRef genre As String, ByVal book As XmlNode)
    Dim bookElement As XmlElement = CType(book, XmlElement)
    ' Get the attributes of a book.        
    Dim attr As XmlAttribute = bookElement.GetAttributeNode("ISBN")
    ISBN = attr.InnerXml
    attr = bookElement.GetAttributeNode("genre")
    genre = attr.InnerXml
    attr = bookElement.GetAttributeNode("publicationdate")
    publicationDate = attr.InnerXml
    ' Get the values of child elements of a book.
    title = bookElement("title").InnerText
    price = bookElement("price").InnerText
End Sub

Ottenere una raccolta di nodiGet a collection of nodes

Questo esempio seleziona tutti i libri in cui il cognome dell'autore è Austen, quindi modifica il prezzo di tali libri.This example selects all books where the author's last name is Austen, and then changes the price of those books.

#using <System.Xml.dll>

using namespace System;
using namespace System::IO;
using namespace System::Xml;
int main()
{
   XmlDocument^ doc = gcnew XmlDocument;
   doc->Load( "booksort.xml" );
   XmlNodeList^ nodeList;
   XmlNode^ root = doc->DocumentElement;
   nodeList = root->SelectNodes( "descendant::book[author/last-name='Austen']" );
   
   //Change the price on the books.
   System::Collections::IEnumerator^ myEnum = nodeList->GetEnumerator();
   while ( myEnum->MoveNext() )
   {
      XmlNode^ book = safe_cast<XmlNode^>(myEnum->Current);
      book->LastChild->InnerText = "15.95";
   }

   Console::WriteLine( "Display the modified XML document...." );
   doc->Save( Console::Out );
}

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

public class Sample {

  public static void Main() {

    XmlDocument doc = new XmlDocument();
    doc.Load("booksort.xml");

    XmlNodeList nodeList;
    XmlNode root = doc.DocumentElement;

    nodeList=root.SelectNodes("descendant::book[author/last-name='Austen']");
 
    //Change the price on the books.
    foreach (XmlNode book in nodeList)
    {
      book.LastChild.InnerText="15.95";
    }

    Console.WriteLine("Display the modified XML document....");
    doc.Save(Console.Out);
    
  }
}
Imports System.IO
Imports System.Xml

public class Sample

  public shared sub Main()

    'Create the XmlDocument.
    Dim doc as XmlDocument = new XmlDocument()
    doc.Load("booksort.xml")
           
    Dim book as XmlNode
    Dim nodeList as XmlNodeList 
    Dim root as XmlNode = doc.DocumentElement

    nodeList=root.SelectNodes("descendant::book[author/last-name='Austen']")
 
    'Change the price on the books.
    for each book in nodeList      
      book.LastChild.InnerText="15.95"
    next 

    Console.WriteLine("Display the modified XML document....")
    doc.Save(Console.Out)
    
  end sub
end class

È anche possibile ottenere una raccolta di nodi usando il nome del nodo.You can also get a collection of nodes by using the name of the node. Ad esempio, in questo esempio viene ottenuta una raccolta di tutti i titoli dei libri.For example, this example gets a collection of all book titles.

#using <System.Xml.dll>

using namespace System;
using namespace System::IO;
using namespace System::Xml;

int main()
{
   //Create the XmlDocument.
   XmlDocument^ doc = gcnew XmlDocument;
   doc->Load( "books.xml" );
   
   //Display all the book titles.
   XmlNodeList^ elemList = doc->GetElementsByTagName( "title" );
   for ( int i = 0; i < elemList->Count; i++ )
   {
      Console::WriteLine( elemList[ i ]->InnerXml );
   }
}
using System;
using System.IO;
using System.Xml;

public class Sample
{
  public static void Main()
  {
    //Create the XmlDocument.
    XmlDocument doc = new XmlDocument();
    doc.Load("books.xml");

    //Display all the book titles.
    XmlNodeList elemList = doc.GetElementsByTagName("title");
    for (int i=0; i < elemList.Count; i++)
    {   
      Console.WriteLine(elemList[i].InnerXml);
    }  

  }
}
Option Explicit
Option Strict

Imports System.IO
Imports System.Xml

Public Class Sample
    
    Public Shared Sub Main()
        'Create the XmlDocument.
        Dim doc As New XmlDocument()
        doc.Load("books.xml")
        
        'Display all the book titles.
        Dim elemList As XmlNodeList = doc.GetElementsByTagName("title")
        Dim i As Integer
        For i = 0 To elemList.Count - 1
            Console.WriteLine(elemList(i).InnerXml)
        Next i
    End Sub
End Class

Esempio completo: Modificare XML in memoria usando la classe XmlDocument e altri tipi correlatiComplete sample: Manipulate XML in-Memory by using the XmlDocument class and other related types

Altre informazioni: Selezionare nodi con la navigazione XPathLearn more: Select Nodes Using XPath Navigation

Modifica nodiEdit nodes

Questo esempio Mostra come modificare un nodo libro e i relativi attributi.This example edits a book node and its attributes.

bool XMLDOMProcessing::XMLHelperMethods::editBook(String ^title, String ^ISBN, String ^publicationDate, String ^genre, String ^price, XmlNode ^book, bool validateNode, bool generateSchema)
{

    XmlElement ^bookElement = safe_cast<XmlElement^>(book);

    // Get the attributes of a book.        
    bookElement->SetAttribute("ISBN", ISBN);
    bookElement->SetAttribute("genre", genre);
    bookElement->SetAttribute("publicationdate", publicationDate);

    // Get the values of child elements of a book.
    bookElement["title"]->InnerText = title;
    bookElement["price"]->InnerText = price;

    if (validateNode)
    {
        if (validateXML(generateSchema, bookElement->OwnerDocument))
        {
            return true;
        }
        else
        {
            return false;
        }
    }
    return true;
}
public void editBook(string title, string ISBN, string publicationDate,
    string genre, string price, XmlNode book, bool validateNode, bool generateSchema)
{

    XmlElement bookElement = (XmlElement)book;

    // Get the attributes of a book.        
    bookElement.SetAttribute("ISBN", ISBN);
    bookElement.SetAttribute("genre", genre);
    bookElement.SetAttribute("publicationdate", publicationDate);

    // Get the values of child elements of a book.
    bookElement["title"].InnerText = title;
    bookElement["price"].InnerText = price;

    if (validateNode)
    {
        validateXML(generateSchema, bookElement.OwnerDocument);
    }
}
Public Sub editBook(ByVal title As String, ByVal ISBN As String,
                    ByVal publicationDate As String, ByVal genre As String,
                    ByVal price As String, ByVal book As XmlNode, ByVal validateNode As Boolean,
                    ByVal generateSchema As Boolean)

    Dim bookElement As XmlElement = CType(book, XmlElement)

    ' Get the attributes of a book.        
    bookElement.SetAttribute("ISBN", ISBN)
    bookElement.SetAttribute("genre", genre)
    bookElement.SetAttribute("publicationdate", publicationDate)

    ' Get the values of child elements of a book.
    bookElement("title").InnerText = title
    bookElement("price").InnerText = price
    If validateNode Then
        validateXML(generateSchema, bookElement.OwnerDocument)
    End If

End Sub

Altre informazioni: Modifica di nodi, contenuto e valori in un documento XMLLearn more: Modifying Nodes, Content, and Values in an XML Document

Esempio completo: Modificare XML in memoria usando la classe XmlDocument e altri tipi correlatiComplete sample: Manipulate XML in-Memory by using the XmlDocument class and other related types

Aggiungi nodiAdd nodes

Per aggiungere un nodo, utilizzare il CreateElement metodo CreateNode o.To add a node, use the CreateElement method or the CreateNode method.

Per aggiungere un nodo dati come un libro, utilizzare il CreateElement metodo.To add a data node such as a book, use the CreateElement method.

Per qualsiasi altro tipo di nodo, ad esempio un commento, un nodo di spazio vuoto o un nodo CreateNode CDATA, utilizzare il metodo.For any other type of node such as a comment, whitespace node, or CDATA node, use the CreateNode method.

Questo esempio crea un nodo libro, aggiunge attributi a tale nodo e quindi aggiunge il nodo al documento.This example creates a book node, adds attributes to that node, and then adds that node to the document.

XmlElement ^XMLDOMProcessing::XMLHelperMethods::AddNewBook(String ^genre, String ^ISBN, String ^misc, String ^title, String ^price, XmlDocument ^doc)
{
    // Create a new book element.
    XmlElement ^bookElement = doc->CreateElement("book", "http://www.contoso.com/books");

    // Create attributes for book and append them to the book element.
    XmlAttribute ^attribute = doc->CreateAttribute("genre");
    attribute->Value = genre;
    bookElement->Attributes->Append(attribute);

    attribute = doc->CreateAttribute("ISBN");
    attribute->Value = ISBN;
    bookElement->Attributes->Append(attribute);

    attribute = doc->CreateAttribute("publicationdate");
    attribute->Value = misc;
    bookElement->Attributes->Append(attribute);

    // Create and append a child element for the title of the book.
    XmlElement ^titleElement = doc->CreateElement("title");
    titleElement->InnerText = title;
    bookElement->AppendChild(titleElement);

    // Introduce a newline character so that XML is nicely formatted.
    bookElement->InnerXml = bookElement->InnerXml->Replace(titleElement->OuterXml, "\n    " + titleElement->OuterXml + " \n    ");

    // Create and append a child element for the price of the book.
    XmlElement ^priceElement = doc->CreateElement("price");
    priceElement->InnerText = price;
    bookElement->AppendChild(priceElement);

    // Introduce a newline character so that XML is nicely formatted.
    bookElement->InnerXml = bookElement->InnerXml->Replace(priceElement->OuterXml, priceElement->OuterXml + "   \n  ");

    return bookElement;

}
public XmlElement AddNewBook(string genre, string ISBN, string misc, 
    string title, string price, XmlDocument doc)
{
    // Create a new book element.
    XmlElement bookElement = doc.CreateElement("book", "http://www.contoso.com/books");

    // Create attributes for book and append them to the book element.
    XmlAttribute attribute = doc.CreateAttribute("genre");
    attribute.Value = genre;
    bookElement.Attributes.Append(attribute);

    attribute = doc.CreateAttribute("ISBN");
    attribute.Value = ISBN;
    bookElement.Attributes.Append(attribute);

    attribute = doc.CreateAttribute("publicationdate");
    attribute.Value = misc;
    bookElement.Attributes.Append(attribute);

    // Create and append a child element for the title of the book.
    XmlElement titleElement = doc.CreateElement("title");
    titleElement.InnerText = title;
    bookElement.AppendChild(titleElement);

    // Introduce a newline character so that XML is nicely formatted.
    bookElement.InnerXml = 
        bookElement.InnerXml.Replace(titleElement.OuterXml, 
        "\n    " + titleElement.OuterXml + " \n    ");
    
    // Create and append a child element for the price of the book.
    XmlElement priceElement = doc.CreateElement("price");
    priceElement.InnerText= price;
    bookElement.AppendChild(priceElement);

    // Introduce a newline character so that XML is nicely formatted.
    bookElement.InnerXml =
        bookElement.InnerXml.Replace(priceElement.OuterXml, priceElement.OuterXml + "   \n  ");

    return bookElement;
     
}
Public Function AddNewBook(ByVal genre As String, ByVal ISBN As String, ByVal misc As String, ByVal title As String, ByVal price As String, ByVal doc As XmlDocument) As XmlElement
    ' Create a new book element.
    Dim bookElement As XmlElement = doc.CreateElement("book", "http://www.contoso.com/books")

    ' Create attributes for book and append them to the book element.
    Dim attribute As XmlAttribute = doc.CreateAttribute("genre")
    attribute.Value = genre
    bookElement.Attributes.Append(attribute)

    attribute = doc.CreateAttribute("ISBN")
    attribute.Value = ISBN
    bookElement.Attributes.Append(attribute)

    attribute = doc.CreateAttribute("publicationdate")
    attribute.Value = misc
    bookElement.Attributes.Append(attribute)

    ' Create and append a child element for the title of the book.
    Dim titleElement As XmlElement = doc.CreateElement("title")
    titleElement.InnerText = title
    bookElement.AppendChild(titleElement)

    ' Introduce a newline character so that XML is nicely formatted.
    bookElement.InnerXml = bookElement.InnerXml.Replace(titleElement.OuterXml, _
                           "\n   " & titleElement.OuterXml & " " & ControlChars.NewLine + "    ")
    ' Create and append a child element for the price of the book.
    Dim priceElement As XmlElement = doc.CreateElement("price")
    priceElement.InnerText = price
    bookElement.AppendChild(priceElement)

    ' Introduce a newline character so that XML is nicely formatted.
    bookElement.InnerXml = bookElement.InnerXml.Replace(priceElement.OuterXml,
                                                        (priceElement.OuterXml & "   " & ControlChars.NewLine & "  "))
    Return bookElement
End Function

Esempio completo: Modificare XML in memoria usando la classe XmlDocument e altri tipi correlatiComplete sample: Manipulate XML in-Memory by using the XmlDocument class and other related types

Altre informazioni: Inserimento di nodi in un documento XMLLearn more: Inserting Nodes into an XML Document

Rimuovi nodiRemove nodes

Per rimuovere un nodo, utilizzare il RemoveChild metodo.To remove a node, use the RemoveChild method.

In questo esempio viene rimosso un libro dal documento e qualsiasi spazio vuoto visualizzato immediatamente prima del nodo libro.This example removes a book from the document and any whitespace that appears just before the book node.

void XMLDOMProcessing::XMLHelperMethods::deleteBook(XmlNode ^book)
{
    XmlNode ^prevNode = book->PreviousSibling;

    book->OwnerDocument->DocumentElement->RemoveChild(book);


    if (prevNode->NodeType == XmlNodeType::Whitespace || prevNode->NodeType == XmlNodeType::SignificantWhitespace)
    {
        prevNode->OwnerDocument->DocumentElement->RemoveChild(prevNode);
    }
}
public void deleteBook(XmlNode book)
{
    XmlNode prevNode = book.PreviousSibling;
    
    book.OwnerDocument.DocumentElement.RemoveChild(book);


    if (prevNode.NodeType == XmlNodeType.Whitespace || 
        prevNode.NodeType == XmlNodeType.SignificantWhitespace)
    {
        prevNode.OwnerDocument.DocumentElement.RemoveChild(prevNode);
    }
}
Public Sub deleteBook(ByVal book As XmlNode)

    Dim prevNode As XmlNode = book.PreviousSibling
    book.OwnerDocument.DocumentElement.RemoveChild(book)

    If ((prevNode.NodeType = XmlNodeType.Whitespace) _
                OrElse (prevNode.NodeType = XmlNodeType.SignificantWhitespace)) Then
        prevNode.OwnerDocument.DocumentElement.RemoveChild(prevNode)

    End If
End Sub

Esempio completo: Modificare XML in memoria usando la classe XmlDocument e altri tipi correlatiComplete sample: Manipulate XML in-Memory by using the XmlDocument class and other related types

Altre informazioni: Rimozione di nodi, contenuto e valori da un documento XMLLearn more: Removing Nodes, Content, and Values from an XML Document

Nodi posizionePosition nodes

È possibile scegliere la posizione in cui si vuole che un nodo venga visualizzato nel documento InsertBefore usando InsertAfter i metodi e.You can choose where you want a node to appear in your document by using the InsertBefore and InsertAfter methods.

Questo esempio mostra due metodi helper.This example shows two helper methods. Uno di essi sposta un nodo più in alto in un elenco.One of them moves a node higher in a list. L'altro si sposta un nodo in basso.The other one moves a node lower.

Questi metodi possono essere usati in un'applicazione che consente agli utenti di spostare i libri verso l'alto e verso il basso in un elenco di libri.These methods could be used in an application that enables users to move books up and down in a list of books. Quando un utente sceglie un libro e preme un pulsante verso l'alto o verso il basso, il codice può chiamare metodi come questi per posizionare il nodo book corrispondente prima o dopo altri nodi del libro.When a user chooses a book and presses an up or down button, your code could call methods like these to position the corresponding book node before or after other book nodes.

//************************************************************************************
//
//  Summary: Move elements up in the XML.
//  
//
//************************************************************************************
void XMLDOMProcessing::XMLHelperMethods::MoveElementUp(XmlNode ^book)
{
    XmlNode ^previousNode = book->PreviousSibling;
    while (previousNode != nullptr && (previousNode->NodeType != XmlNodeType::Element))
    {
        previousNode = previousNode->PreviousSibling;
    }
    if (previousNode != nullptr)
    {
        XmlNode ^newLineNode = book->NextSibling;
        book->OwnerDocument->DocumentElement->RemoveChild(book);
        if (newLineNode->NodeType == XmlNodeType::Whitespace || newLineNode->NodeType == XmlNodeType::SignificantWhitespace)
        {
            newLineNode->OwnerDocument->DocumentElement->RemoveChild(newLineNode);
        }
        InsertBookElement(safe_cast<XmlElement^>(book), Constants::positionAbove, previousNode, false, false);
    }
}

//************************************************************************************
//
//  Summary: Move elements down in the XML.
//  
//
//************************************************************************************
void XMLDOMProcessing::XMLHelperMethods::MoveElementDown(XmlNode ^book)
{
    // Walk backwards until we find an element - ignore text nodes
    XmlNode ^NextNode = book->NextSibling;
    while (NextNode != nullptr && (NextNode->NodeType != XmlNodeType::Element))
    {
        NextNode = NextNode->NextSibling;
    }
    if (NextNode != nullptr)
    {
        XmlNode ^newLineNode = book->PreviousSibling;
        book->OwnerDocument->DocumentElement->RemoveChild(book);
        if (newLineNode->NodeType == XmlNodeType::Whitespace || newLineNode->NodeType == XmlNodeType::SignificantWhitespace)
        {
            newLineNode->OwnerDocument->DocumentElement->RemoveChild(newLineNode);
        }

        InsertBookElement(safe_cast<XmlElement^>(book), Constants::positionBelow, NextNode, false, false);
    }

}
//************************************************************************************
//
//  Summary: Move elements up in the XML.
//  
//
//************************************************************************************

public void MoveElementUp(XmlNode book)
{
    XmlNode previousNode = book.PreviousSibling;
    while (previousNode != null && (previousNode.NodeType != XmlNodeType.Element))
    {
        previousNode = previousNode.PreviousSibling;
    }
    if (previousNode != null)
    {
        XmlNode newLineNode = book.NextSibling;
        book.OwnerDocument.DocumentElement.RemoveChild(book);
        if (newLineNode.NodeType == XmlNodeType.Whitespace | 
            newLineNode.NodeType == XmlNodeType.SignificantWhitespace)
        {
            newLineNode.OwnerDocument.DocumentElement.RemoveChild(newLineNode);
        }
        InsertBookElement((XmlElement)book, Constants.positionAbove, 
            previousNode, false, false);
    }
}


//************************************************************************************
//
//  Summary: Move elements down in the XML.
//  
//
//************************************************************************************
public void MoveElementDown(XmlNode book)
{
    // Walk backwards until we find an element - ignore text nodes
    XmlNode NextNode = book.NextSibling;
    while (NextNode != null && (NextNode.NodeType != XmlNodeType.Element))
    {
        NextNode = NextNode.NextSibling;
    }
    if (NextNode != null)
    {
        XmlNode newLineNode = book.PreviousSibling;
        book.OwnerDocument.DocumentElement.RemoveChild(book);
        if (newLineNode.NodeType == XmlNodeType.Whitespace |
            newLineNode.NodeType == XmlNodeType.SignificantWhitespace)
        {
            newLineNode.OwnerDocument.DocumentElement.RemoveChild(newLineNode);
        }

        InsertBookElement((XmlElement)book, Constants.positionBelow, 
            NextNode, false, false);
    }

}
'************************************************************************************
'
'  Summary: Move elements up in the XML.
'  
'
'************************************************************************************
Public Sub MoveElementUp(ByVal book As XmlNode)
    Dim previousNode As XmlNode = book.PreviousSibling

    While ((Not (previousNode) Is Nothing) _
                AndAlso (previousNode.NodeType <> XmlNodeType.Element))
        previousNode = previousNode.PreviousSibling

    End While
    If (Not (previousNode) Is Nothing) Then
        Dim newLineNode As XmlNode = book.NextSibling
        book.OwnerDocument.DocumentElement.RemoveChild(book)

        If ((newLineNode.NodeType = XmlNodeType.Whitespace) _
                    Or (newLineNode.NodeType = XmlNodeType.SignificantWhitespace)) Then
            newLineNode.OwnerDocument.DocumentElement.RemoveChild(newLineNode)
        End If

        InsertBookElement(CType(book, XmlElement), Constants.positionAbove,
                          previousNode, False, False)
    End If
End Sub

'************************************************************************************
'
'  Summary: Move elements down in the XML.
'  
'
'************************************************************************************
Public Sub MoveElementDown(ByVal book As XmlNode)
    ' Walk backwards until we find an element - ignore text nodes
    Dim NextNode As XmlNode = book.NextSibling

    While ((Not (NextNode) Is Nothing) _
                AndAlso (NextNode.NodeType <> XmlNodeType.Element))
        NextNode = NextNode.NextSibling

    End While

    If (Not (NextNode) Is Nothing) Then
        Dim newLineNode As XmlNode = book.PreviousSibling
        book.OwnerDocument.DocumentElement.RemoveChild(book)

        If ((newLineNode.NodeType = XmlNodeType.Whitespace) _
                    Or (newLineNode.NodeType = XmlNodeType.SignificantWhitespace)) Then
            newLineNode.OwnerDocument.DocumentElement.RemoveChild(newLineNode)
        End If

        InsertBookElement(CType(book, XmlElement), Constants.positionBelow,
                          NextNode, False, False)
    End If
End Sub

Esempio completo: Modificare XML in memoria usando la classe XmlDocument e altri tipi correlatiComplete sample: Manipulate XML in-Memory by using the XmlDocument class and other related types

Costruttori

XmlDocument()

Inizializza una nuova istanza della classe XmlDocument.Initializes a new instance of the XmlDocument class.

XmlDocument(XmlImplementation)

Inizializza una nuova istanza della classe XmlDocument con l'oggetto XmlImplementation specificato.Initializes a new instance of the XmlDocument class with the specified XmlImplementation.

XmlDocument(XmlNameTable)

Inizializza una nuova istanza della classe XmlDocument con l'oggetto XmlNameTable specificato.Initializes a new instance of the XmlDocument class with the specified XmlNameTable.

Proprietà

Attributes

Ottiene un oggetto XmlAttributeCollection contenente gli attributi del nodo.Gets an XmlAttributeCollection containing the attributes of this node.

(Ereditato da XmlNode)
BaseURI

Ottiene l'URI di base del nodo corrente.Gets the base URI of the current node.

ChildNodes

Ottiene tutti i nodi figlio del nodo.Gets all the child nodes of the node.

(Ereditato da XmlNode)
DocumentElement

Ottiene l'oggetto XmlElement radice per il documento.Gets the root XmlElement for the document.

DocumentType

Ottiene il nodo che contiene la dichiarazione DOCTYPE.Gets the node containing the DOCTYPE declaration.

FirstChild

Ottiene il primo elemento figlio del nodo.Gets the first child of the node.

(Ereditato da XmlNode)
HasChildNodes

Ottiene un valore che indica se il nodo dispone di nodi figlio.Gets a value indicating whether this node has any child nodes.

(Ereditato da XmlNode)
Implementation

Ottiene l'oggetto XmlImplementation per il documento corrente.Gets the XmlImplementation object for the current document.

InnerText

Genera InvalidOperationException in tutti i casi.Throws an InvalidOperationException in all cases.

InnerXml

Ottiene o imposta il markup che rappresenta gli elementi figlio del nodo corrente.Gets or sets the markup representing the children of the current node.

IsReadOnly

Ottiene un valore che indica se il nodo corrente è di sola lettura.Gets a value indicating whether the current node is read-only.

Item[String, String]

Ottiene il primo elemento figlio con i valori LocalName e NamespaceURI specificati.Gets the first child element with the specified LocalName and NamespaceURI.

(Ereditato da XmlNode)
Item[String]

Ottiene il primo elemento figlio con il valore Name specificato.Gets the first child element with the specified Name.

(Ereditato da XmlNode)
LastChild

Ottiene l'ultimo elemento figlio del nodo.Gets the last child of the node.

(Ereditato da XmlNode)
LocalName

Ottiene il nome locale del nodo.Gets the local name of the node.

Name

Ottiene il nome completo del nodo.Gets the qualified name of the node.

NamespaceURI

Ottiene l'URI dello spazio dei nomi del nodo.Gets the namespace URI of this node.

(Ereditato da XmlNode)
NameTable

Ottiene l'oggetto XmlNameTable associato all'implementazione.Gets the XmlNameTable associated with this implementation.

NextSibling

Ottiene il nodo immediatamente successivo a quello corrente.Gets the node immediately following this node.

(Ereditato da XmlNode)
NodeType

Ottiene il tipo di nodo corrente.Gets the type of the current node.

OuterXml

Ottiene il markup che contiene questo nodo e tutti i relativi nodi figlio.Gets the markup containing this node and all its child nodes.

(Ereditato da XmlNode)
OwnerDocument

Ottiene l'oggetto XmlDocument a cui appartiene il nodo corrente.Gets the XmlDocument to which the current node belongs.

ParentNode

Ottiene il nodo padre del nodo, per i nodi che hanno elementi padre.Gets the parent node of this node (for nodes that can have parents).

Prefix

Ottiene o imposta il prefisso dello spazio dei nomi del nodo.Gets or sets the namespace prefix of this node.

(Ereditato da XmlNode)
PreserveWhitespace

Ottiene o imposta un valore che indica se preservare lo spazio vuoto nel contenuto dell'elemento.Gets or sets a value indicating whether to preserve white space in element content.

PreviousSibling

Ottiene il nodo immediatamente precedente a quello corrente.Gets the node immediately preceding this node.

(Ereditato da XmlNode)
PreviousText

Ottiene il nodo di testo immediatamente precedente a quello corrente.Gets the text node that immediately precedes this node.

(Ereditato da XmlNode)
SchemaInfo

Restituisce il valore PSVI (Post-Schema-Validation-Infoset) del nodo.Returns the Post-Schema-Validation-Infoset (PSVI) of the node.

Schemas

Ottiene o imposta l'oggetto XmlSchemaSet associato all'oggetto XmlDocument.Gets or sets the XmlSchemaSet object associated with this XmlDocument.

Value

Ottiene o imposta il valore del nodo.Gets or sets the value of the node.

(Ereditato da XmlNode)
XmlResolver

Imposta l'oggetto XmlResolver da usare per risolvere risorse esterne.Sets the XmlResolver to use for resolving external resources.

Metodi

AppendChild(XmlNode)

Aggiunge il nodo specificato alla fine dell'elenco dei nodi figlio del nodo corrente.Adds the specified node to the end of the list of child nodes, of this node.

(Ereditato da XmlNode)
Clone()

Crea un duplicato del nodo.Creates a duplicate of this node.

(Ereditato da XmlNode)
CloneNode(Boolean)

Crea un duplicato del nodo.Creates a duplicate of this node.

CreateAttribute(String)

Crea un oggetto XmlAttribute con la proprietà Name specificata.Creates an XmlAttribute with the specified Name.

CreateAttribute(String, String)

Crea un oggetto XmlAttribute con il nome completo e la proprietà NamespaceURI specificati.Creates an XmlAttribute with the specified qualified name and NamespaceURI.

CreateAttribute(String, String, String)

Crea un oggetto XmlAttribute con le proprietà Prefix, LocalName e NamespaceURI specificate.Creates an XmlAttribute with the specified Prefix, LocalName, and NamespaceURI.

CreateCDataSection(String)

Crea un oggetto XmlCDataSection contenente i dati specificati.Creates an XmlCDataSection containing the specified data.

CreateComment(String)

Crea un oggetto XmlComment contenente i dati specificati.Creates an XmlComment containing the specified data.

CreateDefaultAttribute(String, String, String)

Crea un attributo predefinito con il prefisso, il nome locale e l'URI dello spazio dei nomi specificati.Creates a default attribute with the specified prefix, local name and namespace URI.

CreateDocumentFragment()

Crea un oggetto XmlDocumentFragment.Creates an XmlDocumentFragment.

CreateDocumentType(String, String, String, String)

Restituisce un nuovo oggetto XmlDocumentType.Returns a new XmlDocumentType object.

CreateElement(String)

Crea un elemento con il nome specificato.Creates an element with the specified name.

CreateElement(String, String)

Crea un oggetto XmlElement con il nome completo e una proprietà NamespaceURI.Creates an XmlElement with the qualified name and NamespaceURI.

CreateElement(String, String, String)

Crea un elemento con le proprietà Prefix, LocalName e NamespaceURI specificate.Creates an element with the specified Prefix, LocalName, and NamespaceURI.

CreateEntityReference(String)

Crea un oggetto XmlEntityReference con il nome specificato.Creates an XmlEntityReference with the specified name.

CreateNavigator()

Crea un nuovo oggetto XPathNavigator per spostarsi in questo documento.Creates a new XPathNavigator object for navigating this document.

CreateNavigator(XmlNode)

Crea un oggetto XPathNavigator per lo spostamento all'interno del documento che si trova nella classe XmlNode specificata.Creates an XPathNavigator object for navigating this document positioned on the XmlNode specified.

CreateNode(String, String, String)

Crea un oggetto XmlNode con il tipo di nodo e le proprietà Name e NamespaceURI specificati.Creates an XmlNode with the specified node type, Name, and NamespaceURI.

CreateNode(XmlNodeType, String, String)

Crea un oggetto XmlNode con le proprietà XmlNodeType, Name e NamespaceURI specificate.Creates an XmlNode with the specified XmlNodeType, Name, and NamespaceURI.

CreateNode(XmlNodeType, String, String, String)

Crea un oggetto XmlNode con gli oggetti XmlNodeType, Prefix, Name e NamespaceURI specificati.Creates a XmlNode with the specified XmlNodeType, Prefix, Name, and NamespaceURI.

CreateProcessingInstruction(String, String)

Crea un oggetto XmlProcessingInstruction con il nome e i dati specificati.Creates an XmlProcessingInstruction with the specified name and data.

CreateSignificantWhitespace(String)

Crea un nodo XmlSignificantWhitespace.Creates an XmlSignificantWhitespace node.

CreateTextNode(String)

Crea un oggetto XmlText con il testo specificato.Creates an XmlText with the specified text.

CreateWhitespace(String)

Crea un nodo XmlWhitespace.Creates an XmlWhitespace node.

CreateXmlDeclaration(String, String, String)

Crea un nodo XmlDeclaration con i valori specificati.Creates an XmlDeclaration node with the specified values.

Equals(Object)

Determina se l'oggetto specificato è uguale all'oggetto corrente.Determines whether the specified object is equal to the current object.

(Ereditato da Object)
GetElementById(String)

Ottiene l'oggetto XmlElement con l'ID specificato.Gets the XmlElement with the specified ID.

GetElementsByTagName(String)

Restituisce un oggetto XmlNodeList contenente un elenco di tutti gli elementi discendenti che corrispondono alla proprietà Name specificata.Returns an XmlNodeList containing a list of all descendant elements that match the specified Name.

GetElementsByTagName(String, String)

Restituisce un oggetto XmlNodeList contenente un elenco di tutti gli elementi discendenti che corrispondono alle proprietà LocalName e NamespaceURI specificate.Returns an XmlNodeList containing a list of all descendant elements that match the specified LocalName and NamespaceURI.

GetEnumerator()

Ottiene un enumeratore che scorre i nodi figlio nel nodo corrente.Gets an enumerator that iterates through the child nodes in the current node.

(Ereditato da XmlNode)
GetHashCode()

Funge da funzione hash predefinita.Serves as the default hash function.

(Ereditato da Object)
GetNamespaceOfPrefix(String)

Cerca la dichiarazione xmlns più vicina per il prefisso specificato nell'ambito del nodo corrente e restituisce l'URI dello spazio dei nomi in essa contenuto.Looks up the closest xmlns declaration for the given prefix that is in scope for the current node and returns the namespace URI in the declaration.

(Ereditato da XmlNode)
GetPrefixOfNamespace(String)

Cerca la dichiarazione xmlns più vicina per l'URI dello spazio dei nomi specificato nell'ambito del nodo corrente e restituisce il prefisso in essa definito.Looks up the closest xmlns declaration for the given namespace URI that is in scope for the current node and returns the prefix defined in that declaration.

(Ereditato da XmlNode)
GetType()

Ottiene l'oggetto Type dell'istanza corrente.Gets the Type of the current instance.

(Ereditato da Object)
ImportNode(XmlNode, Boolean)

Importa un nodo da un altro documento al documento corrente.Imports a node from another document to the current document.

InsertAfter(XmlNode, XmlNode)

Inserisce il nodo specificato immediatamente dopo il nodo dei riferimenti indicato.Inserts the specified node immediately after the specified reference node.

(Ereditato da XmlNode)
InsertBefore(XmlNode, XmlNode)

Inserisce il nodo specificato immediatamente prima del nodo dei riferimenti indicato.Inserts the specified node immediately before the specified reference node.

(Ereditato da XmlNode)
Load(Stream)

Carica il documento XML dal flusso specificato.Loads the XML document from the specified stream.

Load(String)

Carica il documento XML dall'URL specificato.Loads the XML document from the specified URL.

Load(TextReader)

Carica il documento XML dall'oggetto TextReader specificato.Loads the XML document from the specified TextReader.

Load(XmlReader)

Carica il documento XML dall'oggetto XmlReader specificato.Loads the XML document from the specified XmlReader.

LoadXml(String)

Carica il documento XML dalla stringa specificata.Loads the XML document from the specified string.

MemberwiseClone()

Crea una copia superficiale dell'oggetto Object corrente.Creates a shallow copy of the current Object.

(Ereditato da Object)
Normalize()

Inserisce tutti i nodi XmlText nell'intero sottoalbero del nodo XmlNode corrente in un formato standard in cui tali nodi sono separati solo tramite markup, ovvero tag, commenti, istruzioni di elaborazione, sezioni CDATA e riferimenti a entità, pertanto, non vi sono nodi XmlText adiacenti.Puts all XmlText nodes in the full depth of the sub-tree underneath this XmlNode into a "normal" form where only markup (that is, tags, comments, processing instructions, CDATA sections, and entity references) separates XmlText nodes, that is, there are no adjacent XmlText nodes.

(Ereditato da XmlNode)
PrependChild(XmlNode)

Aggiunge il nodo specificato all'inizio dell'elenco dei nodi figlio del nodo corrente.Adds the specified node to the beginning of the list of child nodes for this node.

(Ereditato da XmlNode)
ReadNode(XmlReader)

Crea un oggetto XmlNode in base alle informazioni contenute in XmlReader.Creates an XmlNode object based on the information in the XmlReader. Il lettore deve essere posizionato su un nodo o un attributo.The reader must be positioned on a node or attribute.

RemoveAll()

Rimuove tutti gli elementi figlio e/o gli attributi del nodo corrente.Removes all the child nodes and/or attributes of the current node.

(Ereditato da XmlNode)
RemoveChild(XmlNode)

Rimuove il nodo figlio specificato.Removes specified child node.

(Ereditato da XmlNode)
ReplaceChild(XmlNode, XmlNode)

Sostituisce il nodo figlio oldChild con il nodo newChild.Replaces the child node oldChild with newChild node.

(Ereditato da XmlNode)
Save(Stream)

Salva il documento XML nel flusso specificato.Saves the XML document to the specified stream.

Save(String)

Salva il documento XML nel file specificato.Saves the XML document to the specified file. Se il file specificato esiste già, il metodo lo sovrascrive.If the specified file exists, this method overwrites it.

Save(TextWriter)

Salva il documento XML nell'oggetto TextWriter specificato.Saves the XML document to the specified TextWriter.

Save(XmlWriter)

Salva il documento XML nell'oggetto XmlWriter specificato.Saves the XML document to the specified XmlWriter.

SelectNodes(String)

Seleziona un elenco di nodi che corrispondono all'espressione XPath.Selects a list of nodes matching the XPath expression.

(Ereditato da XmlNode)
SelectNodes(String, XmlNamespaceManager)

Seleziona un elenco di nodi che corrispondono all'espressione XPath.Selects a list of nodes matching the XPath expression. Qualsiasi prefisso trovato nell'espressione XPath viene risolto usando l'oggetto XmlNamespaceManager fornito.Any prefixes found in the XPath expression are resolved using the supplied XmlNamespaceManager.

(Ereditato da XmlNode)
SelectSingleNode(String)

Seleziona il primo oggetto XmlNode che corrisponde all'espressione XPath.Selects the first XmlNode that matches the XPath expression.

(Ereditato da XmlNode)
SelectSingleNode(String, XmlNamespaceManager)

Seleziona il primo oggetto XmlNode che corrisponde all'espressione XPath.Selects the first XmlNode that matches the XPath expression. Qualsiasi prefisso trovato nell'espressione XPath viene risolto usando l'oggetto XmlNamespaceManager fornito.Any prefixes found in the XPath expression are resolved using the supplied XmlNamespaceManager.

(Ereditato da XmlNode)
Supports(String, String)

Verifica se l'implementazione DOM implementa una funzionalità specifica.Tests if the DOM implementation implements a specific feature.

(Ereditato da XmlNode)
ToString()

Restituisce una stringa che rappresenta l'oggetto corrente.Returns a string that represents the current object.

(Ereditato da Object)
Validate(ValidationEventHandler)

Convalida l'oggetto XmlDocument sulla base degli schemi XSD (XML Schema Definition Language) contenuti nella proprietà Schemas.Validates the XmlDocument against the XML Schema Definition Language (XSD) schemas contained in the Schemas property.

Validate(ValidationEventHandler, XmlNode)

Convalida l'oggetto XmlNode specificato sulla base degli schemi XSD (XML Schema Definition Language) nella proprietà Schemas.Validates the XmlNode object specified against the XML Schema Definition Language (XSD) schemas in the Schemas property.

WriteContentTo(XmlWriter)

Salva tutti gli elementi figlio del nodo XmlDocument nell'oggetto XmlWriter specificato.Saves all the children of the XmlDocument node to the specified XmlWriter.

WriteTo(XmlWriter)

Salva il nodo XmlDocument nell'oggetto XmlWriter specificato.Saves the XmlDocument node to the specified XmlWriter.

Eventi

NodeChanged

Si verifica quando l'oggetto Value di un nodo appartenente a questo documento è stato modificato.Occurs when the Value of a node belonging to this document has been changed.

NodeChanging

Si verifica quando l'oggetto Value di un nodo appartenente a questo documento sta per essere modificato.Occurs when the Value of a node belonging to this document is about to be changed.

NodeInserted

Si verifica quando un nodo appartenente al documento è stato inserito in un altro nodo.Occurs when a node belonging to this document has been inserted into another node.

NodeInserting

Si verifica quando un nodo appartenente al documento sta per essere inserito in un altro nodo.Occurs when a node belonging to this document is about to be inserted into another node.

NodeRemoved

Si verifica quando un nodo appartenente al documento è stato rimosso dal relativo nodo padre.Occurs when a node belonging to this document has been removed from its parent.

NodeRemoving

Si verifica quando un nodo appartenente al documento sta per essere rimosso dal documento.Occurs when a node belonging to this document is about to be removed from the document.

Implementazioni dell'interfaccia esplicita

ICloneable.Clone()

Per una descrizione di questo membro, vedere Clone().For a description of this member, see Clone().

(Ereditato da XmlNode)
IEnumerable.GetEnumerator()

Per una descrizione di questo membro, vedere GetEnumerator().For a description of this member, see GetEnumerator().

(Ereditato da XmlNode)

Metodi di estensione

Cast<TResult>(IEnumerable)

Esegue il cast degli elementi di un oggetto IEnumerable nel tipo specificato.Casts the elements of an IEnumerable to the specified type.

OfType<TResult>(IEnumerable)

Filtra gli elementi di un oggetto IEnumerable in base a un tipo specificato.Filters the elements of an IEnumerable based on a specified type.

AsParallel(IEnumerable)

Consente la parallelizzazione di una query.Enables parallelization of a query.

AsQueryable(IEnumerable)

Converte un oggetto IEnumerable in un oggetto IQueryable.Converts an IEnumerable to an IQueryable.

CreateNavigator(XmlDocument)
CreateNavigator(XmlDocument, XmlNode)
CreateNavigator(XmlNode)
SelectNodes(XmlNode, String)
SelectNodes(XmlNode, String, XmlNamespaceManager)
SelectSingleNode(XmlNode, String)
SelectSingleNode(XmlNode, String, XmlNamespaceManager)
ToXPathNavigable(XmlNode)

Si applica a

Vedi anche