XObject.Changed Gebeurtenis

public:
 event EventHandler<System::Xml::Linq::XObjectChangeEventArgs ^> ^ Changed;

public event EventHandler<System.Xml.Linq.XObjectChangeEventArgs> Changed;

member this.Changed : EventHandler<System.Xml.Linq.XObjectChangeEventArgs> 

Public Custom Event Changed As EventHandler(Of XObjectChangeEventArgs) 

Gebeurtenistype

Voorbeelden

In het volgende voorbeeld wordt een gebeurtenis-handler toegevoegd aan het hoofdelement van een XML-structuur. Vervolgens wordt de structuur gewijzigd, waardoor LINQ in XML bepaalde gebeurtenissen genereert.

XElement root = new XElement("Root", "content");
root.Changing += new EventHandler<XObjectChangeEventArgs>(
    (sender, cea) =>
    {
        Console.WriteLine("Changing event raised");
        XElement xSender = (XElement)sender;
        Console.WriteLine("  Sender: {0}", xSender.Name);
        Console.WriteLine("  ObjectChange: {0}", cea.ObjectChange);
    }
);
root.Changed += new EventHandler<XObjectChangeEventArgs>(
    (sender, cea) =>
    {
        Console.WriteLine("Changed event raised");
        XElement xSender = (XElement)sender;
        Console.WriteLine("  Sender: {0}", xSender.Name);
        Console.WriteLine("  ObjectChange: {0}", cea.ObjectChange);
    }
);
root.Add(new XElement("Child", "child content"));

Module Module1
    WithEvents root As XElement = <Root>content</Root>

    Sub Main()
        root.Add(<Child>child content</Child>)
    End Sub

    Private Sub root_Changing( _
            ByVal sender As Object, _
            ByVal e As XObjectChangeEventArgs) _
            Handles root.Changing
        Dim xSender As XElement = DirectCast(sender, XElement)
        Console.WriteLine("Changing event raised")
        Console.WriteLine("  Sender: {0}", xSender.Name)
        Console.WriteLine("  ObjectChange: {0}", e.ObjectChange)
    End Sub

    Private Sub root_Changed( _
            ByVal sender As Object, _
            ByVal e As XObjectChangeEventArgs) _
            Handles root.Changed
        Dim xSender As XElement = DirectCast(sender, XElement)
        Console.WriteLine("Changed event raised")
        Console.WriteLine("  Sender: {0}", xSender.Name)
        Console.WriteLine("  ObjectChange: {0}", e.ObjectChange)
    End Sub
End Module

In dit voorbeeld wordt de volgende uitvoer gegenereerd:

Changing event raised
  Sender: Child
  ObjectChange: Add
Changed event raised
  Sender: Child
  ObjectChange: Add

Gebeurtenissen zijn handig als u statistische informatie in een XML-structuur wilt bijhouden. U kunt bijvoorbeeld een factuurtotaal onderhouden dat de som is van de regelitems van de factuur. In dit voorbeeld worden gebeurtenissen gebruikt om het totaal van alle onderliggende elementen bij het complexe element Items bij te houden.

XElement root = new XElement("Root",
    new XElement("Total", 0),
    new XElement("Items")
);
XElement total = root.Element("Total");
XElement items = root.Element("Items");
items.Changed += (object sender, XObjectChangeEventArgs cea) =>
{
    switch (cea.ObjectChange)
    {
        case XObjectChange.Add:
            if (sender is XElement)
                total.Value = ((int)total + (int)(XElement)sender).ToString();
            if (sender is XText)
                total.Value = ((int)total + (int)((XText)sender).Parent).ToString();
            break;
        case XObjectChange.Remove:
            if (sender is XElement)
                total.Value = ((int)total - (int)(XElement)sender).ToString();
            if (sender is XText)
                total.Value = ((int)total - Int32.Parse(((XText)sender).Value)).ToString();
            break;
    }
    Console.WriteLine("Changed {0} {1}", sender.GetType().ToString(), cea.ObjectChange.ToString());
};
items.SetElementValue("Item1", 25);
items.SetElementValue("Item2", 50);
items.SetElementValue("Item2", 75);
items.SetElementValue("Item3", 133);
items.SetElementValue("Item1", null);
items.SetElementValue("Item4", 100);
Console.WriteLine("Total:{0}", (int)total);
Console.WriteLine(root);

Module Module1
    Private total As XElement = Nothing
    Private WithEvents items As XElement = Nothing
    Private root As XElement = _
            <Root>
                <Total>0</Total>
                <Items></Items>
            </Root>

    Sub Main()
        total = root.<Total>(0)
        items = root.<Items>(0)
        items.SetElementValue("Item1", 25)
        items.SetElementValue("Item2", 50)
        items.SetElementValue("Item2", 75)
        items.SetElementValue("Item3", 133)
        items.SetElementValue("Item1", Nothing)
        items.SetElementValue("Item4", 100)
        Console.WriteLine("Total:{0}", CInt(total))
        Console.WriteLine(root)
    End Sub

    Private Sub XObjectChanged( _
            ByVal sender As Object, _
            ByVal cea As XObjectChangeEventArgs) _
            Handles items.Changed
        Select Case cea.ObjectChange
            Case XObjectChange.Add
                If sender.GetType() Is GetType(XElement) Then
                    total.Value = CStr(CInt(total.Value) + _
                            CInt((DirectCast(sender, XElement)).Value))
                End If
                If sender.GetType() Is GetType(XText) Then
                    total.Value = CStr(CInt(total.Value) + _
                            CInt((DirectCast(sender, XText)).Value))
                End If
            Case XObjectChange.Remove
                If sender.GetType() Is GetType(XElement) Then
                    total.Value = CStr(CInt(total.Value) - _
                            CInt((DirectCast(sender, XElement)).Value))
                End If
                If sender.GetType() Is GetType(XText) Then
                    total.Value = CStr(CInt(total.Value) - _
                            CInt((DirectCast(sender, XText)).Value))
                End If
        End Select
        Console.WriteLine("Changed {0} {1}", _
                            sender.GetType().ToString(), _
                            cea.ObjectChange.ToString())
    End Sub
End Module

Deze code produceert de volgende uitvoer:

Changed System.Xml.Linq.XElement Add
Changed System.Xml.Linq.XElement Add
Changed System.Xml.Linq.XText Remove
Changed System.Xml.Linq.XText Add
Changed System.Xml.Linq.XElement Add
Changed System.Xml.Linq.XElement Remove
Changed System.Xml.Linq.XElement Add
Total:308
<Root>
  <Total>308</Total>
  <Items>
    <Item2>75</Item2>
    <Item3>133</Item3>
    <Item4>100</Item4>
  </Items>
</Root>

Opmerkingen

Gebeurtenissen worden alleen gegenereerd wanneer een XML-structuur wordt gewijzigd, niet wanneer deze wordt samengesteld. Dit komt doordat u een gebeurtenis-handler moet toevoegen aan een gebeurtenis voordat u gebeurtenissen kunt ontvangen en u geen gebeurtenis-handler kunt toevoegen voordat u een verwijzing naar een XObjectgebeurtenis hebt. U kunt geen verwijzing naar een bestand XObject ophalen voordat de XML-structuur wordt samengesteld. Dit betekent dat u tijdens de functionele constructie van een XML-boomstructuur geen gebeurtenissen ontvangt.

U moet voorzichtig zijn bij het wijzigen van een XML-structuur binnen een van deze gebeurtenissen, omdat dit kan leiden tot onverwachte resultaten. Als u bijvoorbeeld een Changing gebeurtenis ontvangt en terwijl de gebeurtenis wordt verwerkt, verwijdert u het knooppunt uit de structuur, ontvangt u de Changed gebeurtenis mogelijk niet. Wanneer een gebeurtenis wordt verwerkt, is het geldig om een andere XML-boomstructuur te wijzigen dan de structuur die het knooppunt bevat dat de gebeurtenis ontvangt; het is zelfs geldig om dezelfde structuur te wijzigen, mits de wijzigingen geen invloed hebben op de specifieke knooppunten waarop de gebeurtenis is gegenereerd. Als u echter het gebied van de structuur wijzigt dat het knooppunt bevat dat de gebeurtenis ontvangt, zijn de gebeurtenissen die u ontvangt en de impact op de structuur niet gedefinieerd.

Zie ook

• Overzicht van LINQ naar XML