De waarde van een element ophalen (LINQ naar XML)

In dit artikel wordt beschreven hoe u de waarde van elementen kunt ophalen. Er zijn twee belangrijke manieren om de waarde op te halen:

  • Cast een XElement ofwel een XAttribute naar het gewenste type. De expliciete conversieoperator converteert vervolgens de inhoud van het element of kenmerk naar het opgegeven type en wijst deze toe aan uw variabele.

  • Gebruik de XElement.Value of XAttribute.Value eigenschappen. U kunt de waarde ook instellen met behulp van deze eigenschappen.

Met C# is casten over het algemeen de betere aanpak. Als u het element of kenmerk naar een type null-waarde cast, is de code eenvoudiger te schrijven bij het ophalen van de waarde van een element (of kenmerk) dat mogelijk niet bestaat. In het laatste voorbeeld in dit artikel ziet u dit. U kunt de inhoud van een element echter niet instellen via casting, zoals u dat wel kunt via de eigenschap XElement.Value.

Met Visual Basic kunt u de XElement.Value eigenschap beter gebruiken.

Voorbeeld van conversie naar string

Als u de waarde van een element wilt ophalen, cast u het XElement object naar het gewenste type. U kunt een element als volgt naar een tekenreeks casten:

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)

In dit voorbeeld wordt de volgende uitvoer gegenereerd:

<StringElement>abcde</StringElement>
Value of e:abcde

Voorbeeld van integer-cast

U kunt ook elementen omzetten naar andere typen dan tekenreeksen. Als u bijvoorbeeld een element hebt dat een geheel getal bevat, kunt u het casten naar int, zoals wordt weergegeven in de volgende code:

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))

In dit voorbeeld wordt de volgende uitvoer gegenereerd:

<Age>44</Age>
Value of e:44

LINQ naar XML biedt expliciete cast-operators voor de volgende gegevenstypen: string, bool, bool?, int, int?, uint, uint?, long, long?, ulong, ulong?, float, float?, double, double?, decimal, decimal?, DateTime, DateTime?, TimeSpan, TimeSpan?, en GUID, GUID?.

LINQ naar XML biedt dezelfde cast-operators voor XAttribute objecten.

Voorbeeld van waardeeigenschap

U kunt de Value eigenschap gebruiken om de inhoud van een element op te halen:

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)

In dit voorbeeld wordt de volgende uitvoer gegenereerd:

<StringElement>abcde</StringElement>
Value of e:abcde

Element bestaat mogelijk niet voorbeeld

Soms probeert u de waarde van een element op te halen, ook al weet u niet zeker of het bestaat. In dit geval, wanneer u het gecaste element toewijst aan een nullable verwijzingstype of een nullable-waardetype, wordt de toegewezen variabele ingesteld op null (bij C#) of nothing (bij Visual Basic) als het element niet bestaat. In de volgende code ziet u dat wanneer het element mogelijk niet bestaat, het gemakkelijker is om cast te gebruiken dan om de Value eigenschap te gebruiken.

XElement root = new XElement("Root",
    new XElement("Child1", "child 1 content"),
    new XElement("Child2", "2")
);

// The following assignments show why it's 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 doesn't exist" : c1);

int? c2 = (int?)root.Element("Child2");
Console.WriteLine("c2:{0}", c2 == null ? "element doesn't exist" : c2.ToString());

string c3 = (string)root.Element("Child3");
Console.WriteLine("c3:{0}", c3 == null ? "element doesn't exist" : c3);

int? c4 = (int?)root.Element("Child4");
Console.WriteLine("c4:{0}", c4 == null ? "element doesn't 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 doesn't 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 doesn't 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 doesn't 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 doesn't exist" : v4.ToString());

Dim root As XElement = <Root>
                           <Child1>child 1 content</Child1>
                           <Child2>2</Child2>
                       </Root>

' The following assignments show why it's 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 doesn't exist", c1))

Dim c2 As Nullable(Of Integer) = CType(root.Element("Child2"), Nullable(Of Integer))
Console.WriteLine("c2:{0}", IIf(Not (c2.HasValue), "element doesn't exist", c2.ToString()))

Dim c3 As String = CStr(root.Element("Child3"))
Console.WriteLine("c3:{0}", IIf(c3 Is Nothing, "element doesn't exist", c3))

Dim c4 As Nullable(Of Integer) = CType(root.Element("Child4"), Nullable(Of Integer))
Console.WriteLine("c4:{0}", IIf(Not (c4.HasValue), "element doesn't 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 doesn't 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 doesn't 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 doesn't 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 doesn't exist", v4))

In dit voorbeeld wordt de volgende uitvoer gegenereerd:

c1:child 1 content
c2:2
c3:element doesn't exist
c4:element doesn't exist

v1:child 1 content
v2:2
v3:element doesn't exist
v4:element doesn't exist

Over het algemeen kunt u eenvoudigere code schrijven door te casten om de inhoud van elementen en kenmerken op te halen.

Zie ook

  • Last updated on