XObject.Changed Zdarzenie

Odwołanie

Definicja

Przestrzeń nazw:: System.Xml.Linq

Zestawy:: System.Xml.Linq.dll, System.Xml.XDocument.dll

Zestawy:: netstandard.dll, System.Xml.XDocument.dll

Zestaw:: System.Xml.XDocument.dll

Zestaw:: System.Xml.Linq.dll

Zestaw:: netstandard.dll

Źródło:: XObject.cs

Źródło:: XObject.cs

Źródło:: XObject.cs

Ważne

Niektóre informacje odnoszą się do produktu w wersji wstępnej, który może zostać znacząco zmodyfikowany przed wydaniem. Firma Microsoft nie udziela żadnych gwarancji, jawnych lub domniemanych, w odniesieniu do informacji podanych w tym miejscu.

Podniesione, gdy to XObject lub którykolwiek z jego elementów potomnych uległy zmianie.

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)

Typ zdarzenia

EventHandler<XObjectChangeEventArgs>

Przykłady

Poniższy przykład dodaje procedurę obsługi zdarzeń do elementu głównego drzewa XML. Następnie modyfikuje drzewo, powodując LINQ to XML zgłaszania niektórych zdarzeń.

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

Ten przykład generuje następujące wyniki:

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

Zdarzenia są przydatne, gdy chcesz zachować pewne zagregowane informacje w drzewie XML. Możesz na przykład zachować sumę faktury, która jest sumą pozycji wiersza faktury. W tym przykładzie użyto zdarzeń, aby zachować sumę wszystkich elementów podrzędnych w ramach złożonego elementu Items.

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

Ten kod spowoduje wygenerowanie następujących danych wyjściowych:

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>

Uwagi

Zdarzenia są wywoływane tylko wtedy, gdy drzewo XML jest modyfikowane, a nie podczas jego konstruowania. Jest to spowodowane tym, że należy dodać procedurę obsługi zdarzeń do zdarzenia przed odebraniem zdarzeń i nie można dodać programu obsługi zdarzeń przed odwołaniem do elementu XObject. Nie można uzyskać odwołania do elementu XObject przed utworzeniem drzewa XML. Oznacza to, że podczas funkcjonalnej konstrukcji drzewa XML nie będą odbierane zdarzenia.

Podczas modyfikowania drzewa XML w ramach jednego z tych zdarzeń należy zachować ostrożność, ponieważ może to prowadzić do nieoczekiwanych wyników. Jeśli na przykład otrzymasz Changing zdarzenie i gdy zdarzenie jest przetwarzane, usuniesz węzeł z drzewa, zdarzenie może nie zostać odebrane Changed . Podczas przetwarzania zdarzenia ważne jest zmodyfikowanie drzewa XML innego niż zdarzenie zawierającego węzeł odbierający zdarzenie; Jest to nawet ważne, aby zmodyfikować to samo drzewo, pod warunkiem, że modyfikacje nie mają wpływu na określone węzły, na których zostało zgłoszone zdarzenie. Jeśli jednak zmodyfikujesz obszar drzewa zawierającego węzeł odbierający zdarzenie, zdarzenia, które otrzymujesz, i wpływ na drzewo są niezdefiniowane.

Dotyczy

Produkt	Wersje
.NET	Core 1.0, Core 1.1, Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9, 10
.NET Framework	3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1
.NET Standard	1.0, 1.1, 1.2, 1.3, 1.4, 1.6, 2.0, 2.1
UWP	10.0

Zobacz też

LINQ to XML — przegląd

Udostępnij za pośrednictwem