Vorgehensweise: Abrufen des Werts eines Elements (LINQ to XML)
In diesem Thema wird gezeigt, wie Sie den Wert von Elementen abrufen können.Im Wesentlichen gibt es dafür zwei Möglichkeiten.Die eine Möglichkeit besteht darin, ein XElement oder ein XAttribute in den gewünschten Typ umzuwandeln.Der explizite Konvertierungsoperator wandelt dann den Inhalt des Elements oder Attributs in den angegebenen Typ um und weist ihn Ihrer Variable zu.Die andere Möglichkeit besteht darin, die XElement.Value-Eigenschaft oder die XAttribute.Value-Eigenschaft zu verwenden.
Bei Verwendung von C# ist die Umwandlung aber in der Regel der bessere Ansatz.Wenn Sie das Element oder Attribut in einen Typ umwandeln, der NULL-Werte zulässt, ist der Code für das Abrufen des Werts eines Elements (oder Attributs), das vorhanden oder nicht vorhanden ist, einfacher zu schreiben.Dies wird im letzten Beispiel in diesem Thema gezeigt.Während Sie bei der Verwendung der XElement.Value-Eigenschaft den Inhalt des Elements sehen können, ist dies beim Umwandeln nicht möglich.
Wenn Sie mit Visual Basic arbeiten, empfiehlt es sich, die XElement.Value-Eigenschaft zu verwenden.
Beispiel
Zum Abrufen des Werts eines Elements wandeln Sie einfach nur das XElement-Objekt in den gewünschten Typ um.Das folgende Beispiel zeigt, wie Sie ein Element in eine Zeichenfolge umwandeln können:
XElement e = new XElement("StringElement", "abcde");
Console.WriteLine(e);
Console.WriteLine("Value of e:" + (string)e);
Dim e As XElement = <StringElement>abcde</StringElement>
Console.WriteLine(e)
Console.WriteLine("Value of e:" & e.Value)
Dieses Beispiel führt zur folgenden Ausgabe:
<StringElement>abcde</StringElement>
Value of e:abcde
Sie können Elemente auch in andere Typen als Zeichenfolgen umwandeln.Wenn Sie z. B. ein Element haben, das eine ganze Zahl enthält, können Sie das Element, wie im folgenden Code gezeigt, in den Typ int umwandeln:
XElement e = new XElement("Age", "44");
Console.WriteLine(e);
Console.WriteLine("Value of e:" + (int)e);
Dim e As XElement = <Age>44</Age>
Console.WriteLine(e)
Console.WriteLine("Value of e:" & CInt(e))
Dieses Beispiel führt zur folgenden Ausgabe:
<Age>44</Age>
Value of e:44
LINQ to XML bietet explizite Umwandlungsoperatoren für die folgenden Datentypen: string, bool, bool?, int, int?, uint, uint?, long, long?, ulong, ulong?, float, float?, double, double?, decimal, decimal?, DateTime, DateTime?, TimeSpan, TimeSpan?, GUID und GUID?.
LINQ to XML stellt dieselben Typumwandlungsoperatoren für XAttribute-Objekte bereit.
Zum Abrufen des Inhalts eines Elements können Sie die Value-Eigenschaft verwenden:
XElement e = new XElement("StringElement", "abcde");
Console.WriteLine(e);
Console.WriteLine("Value of e:" + e.Value);
Dim e As XElement = <StringElement>abcde</StringElement>
Console.WriteLine(e)
Console.WriteLine("Value of e:" & e.Value)
Dieses Beispiel führt zur folgenden Ausgabe:
<StringElement>abcde</StringElement>
Value of e:abcde
Es kann vorkommen, dass Sie versuchen möchten, den Wert eines Elements abzurufen, von dem Sie gar nicht genau wissen, ob es tatsächlich existiert.Wenn Sie in einem solchen Fall das umgewandelte Element einem Typ zuweisen, der NULL-Werte zulässt (entweder eine string oder einer der Typen in .NET Framework, der NULL-Werte zulässt) und wenn das Element nicht existiert, wird die zugewiesene Variable einfach auf null (Nothing in Visual Basic) gesetzt.Der folgende Code zeigt, dass in den Fällen, in denen nicht klar ist, ob das Element existiert oder nicht, das Arbeiten mit der Umwandlung einfacher ist als die Verwendung der Value-Eigenschaft.
XElement root = new XElement("Root",
new XElement("Child1", "child 1 content"),
new XElement("Child2", "2")
);
// The following assignments show why it is easier to use
// casting when the element might or might not exist.
string c1 = (string)root.Element("Child1");
Console.WriteLine("c1:{0}", c1 == null ? "element does not exist" : c1);
int? c2 = (int?)root.Element("Child2");
Console.WriteLine("c2:{0}", c2 == null ? "element does not exist" : c2.ToString());
string c3 = (string)root.Element("Child3");
Console.WriteLine("c3:{0}", c3 == null ? "element does not exist" : c3);
int? c4 = (int?)root.Element("Child4");
Console.WriteLine("c4:{0}", c4 == null ? "element does not exist" : c4.ToString());
Console.WriteLine();
// The following assignments show the required code when using
// the Value property when the element might or might not exist.
// Notice that this is more difficult than the casting approach.
XElement e1 = root.Element("Child1");
string v1;
if (e1 == null)
v1 = null;
else
v1 = e1.Value;
Console.WriteLine("v1:{0}", v1 == null ? "element does not exist" : v1);
XElement e2 = root.Element("Child2");
int? v2;
if (e2 == null)
v2 = null;
else
v2 = Int32.Parse(e2.Value);
Console.WriteLine("v2:{0}", v2 == null ? "element does not exist" : v2.ToString());
XElement e3 = root.Element("Child3");
string v3;
if (e3 == null)
v3 = null;
else
v3 = e3.Value;
Console.WriteLine("v3:{0}", v3 == null ? "element does not exist" : v3);
XElement e4 = root.Element("Child4");
int? v4;
if (e4 == null)
v4 = null;
else
v4 = Int32.Parse(e4.Value);
Console.WriteLine("v4:{0}", v4 == null ? "element does not exist" : v4.ToString());
Dim root As XElement = <Root>
<Child1>child 1 content</Child1>
<Child2>2</Child2>
</Root>
' The following assignments show why it is easier to use
' casting when the element might or might not exist.
Dim c1 As String = CStr(root.Element("Child1"))
Console.WriteLine("c1:{0}", IIf(c1 Is Nothing, "element does not exist", c1))
Dim c2 As Nullable(Of Integer) = CType(root.Element("Child2"), Nullable(Of Integer))
Console.WriteLine("c2:{0}", IIf(Not (c2.HasValue), "element does not exist", c2.ToString()))
Dim c3 As String = CStr(root.Element("Child3"))
Console.WriteLine("c3:{0}", IIf(c3 Is Nothing, "element does not exist", c3))
Dim c4 As Nullable(Of Integer) = CType(root.Element("Child4"), Nullable(Of Integer))
Console.WriteLine("c4:{0}", IIf(Not (c4.HasValue), "element does not exist", c4.ToString()))
Console.WriteLine()
' The following assignments show the required code when using
' the Value property when the attribute might or might not exist.
' Notice that this is more difficult than the casting approach.
Dim e1 As XElement = root.Element("Child1")
Dim v1 As String
If (e1 Is Nothing) Then
v1 = Nothing
Else
v1 = e1.Value
End If
Console.WriteLine("v1:{0}", IIf(v1 Is Nothing, "element does not exist", v1))
Dim e2 As XElement = root.Element("Child2")
Dim v2 As Nullable(Of Integer)
If (e2 Is Nothing) Then
v2 = Nothing
Else
v2 = e2.Value
End If
Console.WriteLine("v2:{0}", IIf(Not (v2.HasValue), "element does not exist", v2))
Dim e3 As XElement = root.Element("Child3")
Dim v3 As String
If (e3 Is Nothing) Then
v3 = Nothing
Else
v3 = e3.Value
End If
Console.WriteLine("v3:{0}", IIf(v3 Is Nothing, "element does not exist", v3))
Dim e4 As XElement = root.Element("Child4")
Dim v4 As Nullable(Of Integer)
If (e4 Is Nothing) Then
v4 = Nothing
Else
v4 = e4.Value
End If
Console.WriteLine("v4:{0}", IIf(Not (v4.HasValue), "element does not exist", v4))
Dieser Code erzeugt die folgende Ausgabe:
c1:child 1 content
c2:2
c3:element does not exist
c4:element does not exist
v1:child 1 content
v2:2
v3:element does not exist
v4:element does not exist
In der Regel können Sie einfacheren Code schreiben, wenn Sie zum Abrufen des Inhalts von Elementen und Attributen die Umwandlung verwenden.