Gestione degli eventi in un documento XML con XmlNodeChangedEventArgsEvent Handling in an XML Document Using the XmlNodeChangedEventArgs

XmlNodeChangedEventArgs incapsula gli argomenti passati ai gestori eventi registrati nell'oggetto XmlDocument per gestire gli eventi.The XmlNodeChangedEventArgs encapsulates the arguments passed to the event handlers registered on the XmlDocument object for handling events. Nella tabella seguente viene fornita una descrizione degli eventi e della relativa generazione.The events and a description of when they are fired is given in the following table.

eventEvent GeneratoFired
NodeInserting Quando un nodo che appartiene al documento corrente sta per essere inserito in un altro nodo.When a node belonging to the current document is about to be inserted into another node.
NodeInserted Quando un nodo che appartiene al documento corrente è stato inserito in un altro nodo.When a node belonging to the current document has been inserted into another node.
NodeRemoving Quando un nodo che appartiene al documento corrente sta per essere rimosso dal documento.When a node belonging to this document is about to be removed from the document.
NodeRemoved Quando un nodo che appartiene al documento corrente è stato rimosso dal nodo padre.When a node belonging to this document has been removed from its parent.
NodeChanging Quando il valore di un nodo sta per essere modificato.When the value of a node is about to be changed.
NodeChanged Quando il valore di un nodo è stato modificato.When the value of a node has been changed.

Nota

Se l'uso della memoria di XmlDataDocument è completamente ottimizzato per usare la risorsa di archiviazione DataSet, è possibile che nessuno degli eventi precedenti venga generato da XmlDataDocument quando vengono apportate modifiche al DataSet sottostante.If the XmlDataDocument memory usage is fully optimized to use DataSet storage, the XmlDataDocument might not raise any of the events listed above when changes are made to the underlying DataSet. Se tali eventi sono indispensabili, è necessario scorrere l'intero documento XmlDocument una volta per rendere l'uso della memoria non completamente ottimizzato.If you need these events, you must traverse the whole XmlDocument once to make the memory usage non-fully optimized.

Nell'esempio di codice seguente viene illustrato come definire un gestore eventi e come aggiungerlo a un evento.The following code example shows how to define an event handler and how to add the event handler to an event.

' Attach the event handler, NodeInsertedHandler, to the NodeInserted  
' event.  
Dim doc as XmlDocument = new XmlDocument()  
Dim XmlNodeChgEHdlr as XmlNodeChangedEventHandler = new XmlNodeChangedEventHandler(addressof MyNodeChangedEvent)   
AddHandler doc.NodeInserted, XmlNodeChgEHdlr   

Dim n as XmlNode = doc.CreateElement( "element" )  
Console.WriteLine( "Before Event Inserting" )   

' This is the point where the new node is being inserted in the tree,  
' and this is the point where the NodeInserted event is raised.  
doc.AppendChild( n )  
Console.WriteLine( "After Event Inserting" )   

' Define the event handler that handles the NodeInserted event.  
sub NodeInsertedHandler(src as Object, args as XmlNodeChangedEventArgs)  
    Console.WriteLine("Node " + args.Node.Name + " inserted!!")  
end sub  
// Attach the event handler, NodeInsertedHandler, to the NodeInserted  
// event.  
XmlDocument doc = new XmlDocument();  
doc.NodeInserted += new XmlNodeChangedEventHandler(NodeInsertedHandler);  
XmlNode n = doc.CreateElement( "element" );  
Console.WriteLine( "Before Event Inserting" );  

// This is the point where the new node is being inserted in the tree,  
// and this is the point where the NodeInserted event is raised.  
doc.AppendChild( n );  
Console.WriteLine( "After Event Inserting" );   

// Define the event handler that handles the NodeInserted event.  
void NodeInsertedHandler(Object src, XmlNodeChangedEventArgs args)  
{  
    Console.WriteLine("Node " + args.Node.Name + " inserted!!");  
}  

Alcune operazioni DOM (Document Object Model) XML sono operazioni composte che possono determinare la generazione di più eventi.Some XML Document Object Model (DOM) operations are compound operations that can result in multiple events being fired. Ad esempio, è possibile che AppendChild debba anche rimuovere il nodo aggiunto dal nodo padre precedente.For example, AppendChild may also have to remove the node being appended from its previous parent. In questo caso, viene prima visualizzato un evento NodeRemoved generato, seguito da un evento NodeInserted.In this case, you see a NodeRemoved event fired first, followed by a NodeInserted event. Operazioni quali l'impostazione del codice InnerXml potrebbero restituire più eventi.Operations like setting InnerXml could result in multiple events.

Nell'esempio di codice seguente viene illustrata la creazione del gestore eventi e la gestione dell'evento NodeInserted.The following code example shows the creation of the event handler and the handling of the NodeInserted event.

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

Public Class Sample  

    Private Const filename As String = "books.xml"  

    Shared Sub Main()  
        Dim mySample As Sample = New Sample()  
        mySample.Run(filename)  
    End Sub  

    Public Sub Run(ByVal args As String)  
        ' Create and load the XML document.  
        Console.WriteLine("Loading file 0 ...", args)  
        Dim doc As XmlDocument = New XmlDocument()  
        doc.Load(args)  

        ' Create the event handlers.  
        Dim XmlNodeChgEHdlr As XmlNodeChangedEventHandler = New XmlNodeChangedEventHandler(AddressOf MyNodeChangedEvent)  
        Dim XmlNodeInsrtEHdlr As XmlNodeChangedEventHandler = New XmlNodeChangedEventHandler(AddressOf MyNodeInsertedEvent)  
        AddHandler doc.NodeChanged, XmlNodeChgEHdlr  
        AddHandler doc.NodeInserted, XmlNodeInsrtEHdlr  

        ' Change the book price.  
        doc.DocumentElement.LastChild.InnerText = "5.95"  

        ' Add a new element.  
        Dim newElem As XmlElement = doc.CreateElement("style")  
        newElem.InnerText = "hardcover"  
        doc.DocumentElement.AppendChild(newElem)  

        Console.WriteLine(Chr(13) + Chr(10) + "Display the modified XML...")  
        Console.WriteLine(doc.OuterXml)  
    End Sub  

    ' Handle the NodeChanged event.  
    Public Sub MyNodeChangedEvent(ByVal src As Object, ByVal args As XmlNodeChangedEventArgs)  
        Console.Write("Node Changed Event: <0> changed", args.Node.Name)  
        If Not (args.Node.Value Is Nothing) Then  
            Console.WriteLine(" with value  0", args.Node.Value)  
        Else  
            Console.WriteLine("")  
        End If  
    End Sub  

    ' Handle the NodeInserted event.  
    Public Sub MyNodeInsertedEvent(ByVal src As Object, ByVal args As XmlNodeChangedEventArgs)  
        Console.Write("Node Inserted Event: <0> inserted", args.Node.Name)  
        If Not (args.Node.Value Is Nothing) Then  
            Console.WriteLine(" with value 0", args.Node.Value)  
        Else  
            Console.WriteLine("")  
        End If  
    End Sub  

End Class        ' End class  
using System;  
using System.IO;  
using System.Xml;  

public class Sample  
{  
  private const String filename = "books.xml";  

  public static void Main()  
  {  
     Sample mySample = new Sample();  
     mySample.Run(filename);  
  }  

  public void Run(String args)  
  {  

     // Create and load the XML document.  
     Console.WriteLine ("Loading file {0} ...", args);  
     XmlDocument doc = new XmlDocument();  
     doc.Load (args);  

     // Create the event handlers.  
     doc.NodeChanged += new XmlNodeChangedEventHandler(this.MyNodeChangedEvent);  
     doc.NodeInserted += new XmlNodeChangedEventHandler(this.MyNodeInsertedEvent);  

     // Change the book price.  
     doc.DocumentElement.LastChild.InnerText = "5.95";  

     // Add a new element.  
     XmlElement newElem = doc.CreateElement("style");  
     newElem.InnerText = "hardcover";  
     doc.DocumentElement.AppendChild(newElem);  

     Console.WriteLine("\r\nDisplay the modified XML...");  
     Console.WriteLine(doc.OuterXml);             

  }  

  // Handle the NodeChanged event.  
  public void MyNodeChangedEvent(Object src, XmlNodeChangedEventArgs args)  
  {  
     Console.Write("Node Changed Event: <{0}> changed", args.Node.Name);  
     if (args.Node.Value != null)  
     {  
        Console.WriteLine(" with value  {0}", args.Node.Value);  
     }  
     else  
       Console.WriteLine("");  
  }  

  // Handle the NodeInserted event.  
  public void MyNodeInsertedEvent(Object src, XmlNodeChangedEventArgs args)  
  {  
     Console.Write("Node Inserted Event: <{0}> inserted", args.Node.Name);  
     if (args.Node.Value != null)  
     {  
        Console.WriteLine(" with value {0}", args.Node.Value);  
     }  
     else  
        Console.WriteLine("");  
  }  

} // End class   

Per altre informazioni, vedere XmlNodeChangedEventArgs e XmlNodeChangedEventHandler.For more information, see XmlNodeChangedEventArgs and XmlNodeChangedEventHandler.

Vedere ancheSee Also

Modello DOM (Document Object Mode) XMLXML Document Object Model (DOM)