Freigeben über


XObject.Changed Ereignis

Definition

Wird ausgelöst, wenn dieses XObject oder eines seiner untergeordneten Elemente geändert wurde.

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) 

Ereignistyp

Beispiele

Im folgenden Beispiel wird dem Stammelement einer XML-Struktur ein Ereignishandler hinzugefügt. Anschließend wird die Struktur geändert, sodass LINQ to XML einige Ereignisse auslöst.

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  

Dieses Beispiel erzeugt die folgende Ausgabe:

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

Ereignisse erweisen sich als nützlich, wenn aggregierte Informationen in einer XML-Struktur bereitgestellt werden sollen. So können Sie auf diese Weise z. B. einen Rechnungsgesamtbetrag bereitstellen, der sich aus der Summe der Einzelpositionen der Rechnung ergibt. Dieses Beispiel verwendet Ereignisse, um den Gesamtbetrag aller untergeordneten Elemente des komplexen Elements Items bereitzustellen:

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  

Dieser Code erzeugt die folgende Ausgabe:

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>  

Hinweise

Ereignisse werden nur ausgelöst, wenn eine XML-Struktur geändert wird, nicht, wenn sie erstellt wird. Dies liegt daran, dass Sie einem Ereignis einen Ereignishandler hinzufügen müssen, bevor Sie Ereignisse empfangen können, und Sie können keinen Ereignishandler hinzufügen, bevor Sie einen Verweis auf einen XObjecthaben. Sie können keinen Verweis auf einen XObject abrufen, bevor die XML-Struktur erstellt wird. Dies bedeutet, dass Sie beim Funktionalen Aufbau einer XML-Struktur keine Ereignisse empfangen.

Sie sollten beim Ändern einer XML-Struktur innerhalb eines dieser Ereignisse vorsichtig sein, da dies zu unerwarteten Ergebnissen führen kann. Wenn Sie beispielsweise ein Changing Ereignis erhalten und während der Verarbeitung des Ereignisses Sie den Knoten aus der Struktur entfernen, erhalten Sie das Changed Ereignis möglicherweise nicht. Wenn ein Ereignis verarbeitet wird, ist es gültig, eine andere XML-Struktur als die zu ändern, die den Knoten enthält, der das Ereignis empfängt. Es ist sogar gültig, dieselbe Struktur zu ändern, vorausgesetzt, die Änderungen wirken sich nicht auf die spezifischen Knoten aus, auf denen das Ereignis ausgelöst wurde. Wenn Sie jedoch den Bereich der Struktur ändern, der den Knoten enthält, der das Ereignis empfängt, sind die empfangenen Ereignisse und die Auswirkungen auf die Struktur nicht definiert.

Gilt für:

Weitere Informationen