Partager via

Gestion d'événements dans un document XML à l'aide de XmlNodeChangedEventArgs

  • Article

XmlNodeChangedEventArgs encapsule les arguments passés aux gestionnaires d'événements inscrits dans l'objet XmlDocument pour la gestion d'événements. Le tableau suivant répertorie ces événements et fournit une description des circonstances dans lesquelles ils sont déclenchés :

Événement

Est déclenché

NodeInserting

Quand un nœud faisant partie du document actif est sur le point d'être inséré dans un autre nœud.

NodeInserted

Quand un nœud faisant partie du document actif a été inséré dans un autre nœud.

NodeRemoving

Quand un nœud faisant partie du document en cours est sur le point d'être supprimé du document.

NodeRemoved

Quand un nœud faisant partie de ce document a été supprimé de son parent.

NodeChanging

Quand la valeur d'un nœud est sur le point d'être modifiée.

NodeChanged

Quand la valeur d'un nœud a été modifiée.
RemarqueRemarque

Si l'utilisation de la mémoire XmlDataDocument est pleinement optimisée pour utiliser le stockage DataSet, il est possible que XmlDataDocument ne déclenche aucun des événements répertoriés ci-avant lorsque des modifications sont apportées au DataSet sous-jacent.Si vous avez besoin de ces événements, vous devez traverser l'intégralité de XmlDocument une fois pour rendre partielle l'utilisation de la mémoire.

L'exemple de code suivant illustre la définition d'un gestionnaire d'événements et l'ajout de celui-ci à un événement :

' 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!!");
}

Certaines opérations Document Object Model (DOM) XML sont des opérations composées pouvant entraîner le déclenchement de plusieurs événements. Par exemple, AppendChild peut également avoir à supprimer de son ancien parent le nœud à ajouter. Dans ce cas, un événement NodeRemoved est déclenché en premier, suivi d'un événement NodeInserted. Des opérations telles que la définition d'InnerXml peuvent provoquer plusieurs événements.

L'exemple de code suivant montre la création du gestionnaire d'événements et la gestion de l'événement NodeInserted.

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

Pour plus d'informations, voir Membres XmlNodeChangeEventArgs et Délégué XmlNodeChangedEventHandler.

Voir aussi

Concepts

DOM (Document Object Model) XML