Visual Basic 2012 Voorbeelden
   

visual basic 2012 broncode voorbeelden

Blijf op de hoogte van de recente aanpassingen op vbvoorbeelden!

Microsoft Visual Studio 2012Microsoft Developers Network - Visual BasicMicrosoft .NET Framework

29.5. Informatie in LINQ to XML Structuren Benaderen

Print Email Deel op Twitter Deel op Facebook

Dit artikel is gepubliceerd op maandag 15 oktober 2012 op vbvoorbeelden, bezoek de website voor een recente versie van dit artikel of andere artikels.

De verschillende nodes en elementen van XML kunnen we op allerlei manieren benaderen.

29.5.1. System.Xml.Linq.XObject

Zowel XAttributes als XNodes zijn XObjects.  Een XObject hoort tot een bepaald XDocument en kan tot een parent XElement behoren.

29.5.2. System.Xml.Linq.XAttribute

Een XAttribute is een XObject en stelt een attribuut voor van een XNode.

29.5.3. System.Xml.Linq.XNode

Een XNode is een XObject en stelt een node voor.  Een XNode kan gekoppeld zijn aan een vorige en volgende XNode.
Zowel XComments als XContainers zijn XNodes.

29.5.4. System.Xml.Linq.XComment

Een XComment is een XNode en stelt een commentaar node voor.

29.5.5. System.Xml.Linq.XContainer

Een XContainer is een XNode en stelt een node voor die child nodes kan bevatten.  Zowel XElements als XDocuments zijn XContainers.

29.5.6. System.Xml.Linq.XElement

Een XElement is een XContainer en stelt een node voor die een waarde kan hebben.  Deze waarde kan een reeks van child nodes zijn.  Het XElement zelf kan een parent element zijn van andere XNodes.

29.5.7. System.Xml.Linq.XDocument

Een XDocument is een XContainer en stelt een XML document voor.  Deze heeft steeds exact één root XElement.

29.5.8. System.Xml.Linq.XName

Een XName stelt de naam voor van ondermeer XElements en XAttributes.

29.5.9. Een Voorbeeld

In dit onderwerp stellen we volgend XML document op :
<?xml version="1.0"?>
<administration>
  <employees>
    <employee>
      <name>Alex Smith</name>
    </employee>
    <employee>
      <name>John Smith</name>
      <departement type="Sales">London</departement>
      <departement type="distribution">England</departement>
    </employee>
    <employee>
      <name>Jane Jones</name>
      <departement type="sales">Manchester</departement>
    </employee>
  </employees>
</administration>
We geven aan het document (XDocument), maar ook aan enkele elementen ( XElement), attributen (XAttribute) en namen (XName) een naam.
Dit om in onderstaand voorbeeld de mogelijkheden om deze te benaderen te kunnen illustreren :
Visual Basic 2012 Broncode - Codevoorbeeld 757
Option Explicit On
Option Strict On

Imports System.Collections.Generic
Imports System.Xml.Linq

Namespace AccessingXML
    Class Example1
        Public Shared Sub Main()
            Dim nameXElementValue As String = "John Smith"
            Dim nameXElement As XElement = <name><%= nameXElementValue %></name>
            '
            Dim departementXElementValue As String = "London"
            Dim typeXAttributeValue As String = "Sales"
            Dim departementXName As XName = XName.Get("departement")
            Dim typeXName As XName = XName.Get("type")
            Dim typeXAttribute As XAttribute = _
                                  New XAttribute(typeXName, typeXAttributeValue)
            Dim departement1XElement As XElement = _
<departement <%= typeXAttribute %>><%= departementXElementValue %></departement>
            '
            Dim departement2XElement As XElement = _
                          <departement type="distribution">England</departement>
            '
            Dim employee1XElement As XElement = <employee>
                                                    <name>Alex Smith</name>
                                                </employee>
            Dim employee2XElement As XElement = <employee>
                                                    <%= nameXElement %>
                                                    <%= departement1XElement %>
                                                    <%= departement2XElement %>
                                                </employee>
            Dim employee3XElement As XElement = _
                        <employee>
                            <name>Jane Jones</name>
                            <departement type="sales">Manchester</departement>
                        </employee>
            '
            Dim employeesXElement As XElement = <employees>
                                                    <%= employee1XElement %>
                                                    <%= employee2XElement %>
                                                    <%= employee3XElement %>
                                                </employees>
            '
            Dim administrationXElement As XElement = _
                                                <administration>
                                                    <%= employeesXElement %>
                                                </administration>
            '
            Dim document As XDocument = <?xml version="1.0"?>
                                        <%= administrationXElement %>
            '
            Console.WriteLine(document.ToString())
            ' ------------------------------------------------------------------
            ' XDocument of XObject :: Document Readonly Property :
            Console.WriteLine(employee1XElement.Document Is document)
            Console.WriteLine(typeXAttribute.Document Is document)
            ' ------------------------------------------------------------------
            ' XName of XObject :: Name Writable Property :
            Console.WriteLine(employeesXElement.Name Is XName.Get("employees"))
            ' ------------------------------------------------------------------
            ' Value of XObject ::
            ' Value Writable Property :
            Console.WriteLine(nameXElement.Value Is nameXElementValue)
            Console.WriteLine(typeXAttribute.Value Is typeXAttributeValue)
            ' IsEmpty Function - Checks for content in XElement :
            Console.WriteLine(nameXElement.IsEmpty() = False)
            ' ------------------------------------------------------------------
            ' Child XNode's of XContainer ::
            ' First & LastNode ReadOnly Properties :
            Console.WriteLine(employeesXElement.FirstNode Is employee1XElement)
            Console.WriteLine(employeesXElement.LastNode Is employee3XElement)
            ' Nodes Function :
            Dim childNodes As IEnumerable(Of XNode) = employeesXElement.Nodes()
            childNodes = document.Nodes()
            ' ------------------------------------------------------------------
            ' Child XElement's of XContainer :: Element Function :
            Console.WriteLine( _
                        employee2XElement.Element(XName.Get("departement")) Is _
                                                           departement1XElement)
            ' Elements, Descendants(AndSelf) & Ancestors(AndSelf) Functions :
            Dim elements As IEnumerable(Of XElement)
            elements = employeesXElement.Elements()
            elements = employeesXElement.Descendants()
            elements = employeesXElement.DescendantsAndSelf()
            elements = employee2XElement.Ancestors()
            elements = employee2XElement.AncestorsAndSelf()
            ' HasElements Function :
            Console.WriteLine(employeesXElement.HasElements())
            ' ------------------------------------------------------------------
            ' Parent XElement of XObject :: Parent ReadOnly Property :
            Console.WriteLine(employee1XElement.Parent Is employeesXElement)
            ' ------------------------------------------------------------------
            ' Sibling XNode's of XObject ::
            ' Next & PreviousNode ReadOnly Properties :
            Console.WriteLine(employee1XElement.NextNode Is employee2XElement)
            Console.WriteLine(employee3XElement.NextNode Is Nothing)
            Console.WriteLine(employee2XElement.PreviousNode Is _
                                                              employee1XElement)
            Console.WriteLine(employee1XElement.PreviousNode Is Nothing)
            ' IsBefore & After Function - Sibling XNode Order :
            Console.WriteLine(employee1XElement.IsBefore(employee2XElement))
            Console.WriteLine(employee2XElement.IsAfter(employee1XElement))
            ' ------------------------------------------------------------------
            ' XAttribute's of XElement :: Attribute Function :
            Console.WriteLine(departement1XElement.Attribute(typeXName) Is _
                                                                 typeXAttribute)
            ' Attributes Function :
            Dim attributes As IEnumerable(Of XAttribute) = _
                                               departement1XElement.Attributes()
            ' First & LastAttribute ReadOnly Properties :
            Console.WriteLine(departement1XElement.FirstAttribute Is _
                                                                 typeXAttribute)
            Console.WriteLine(departement1XElement.LastAttribute Is _
                                                                 typeXAttribute)
            ' HasAttributes Function :
            Console.WriteLine(departement1XElement.HasAttributes())
            ' ------------------------------------------------------------------
            '
            Console.ReadLine()
        End Sub
    End Class
End Namespace
Console Application Output
<administration>
  <employees>
    <employee>
      <name>Alex Smith</name>
    </employee>
    <employee>
      <name>John Smith</name>
      <departement type="Sales">London</departement>
      <departement type="distribution">England</departement>
    </employee>
    <employee>
      <name>Jane Jones</name>
      <departement type="sales">Manchester</departement>
    </employee>
  </employees>
</administration>
True
True
True
True
True
True
True
True
True
True
True
True
True
True
True
True
True
True
True
True
True
We hebben in een vorig voorbeeld al eens de voor <employee> child nodes <departement> via een LINQ query laten bepalen.  In onderstaand voorbeeld doen we dit nogmaals, maar deze keer haalt de LINQ query zijn informatie uit de IEnumerable(Of XElement) collectie die de Elements functie van het XElement object departements oplevert :
Visual Basic 2012 Broncode - Codevoorbeeld 758
Namespace AccessingXML
    Class Example2
        Public Shared Sub Main()
            Dim departements As XElement = _
                    <departements>
                        <departement type="Sales">London</departement>
                        <departement type="Distrubution">England</departement>
                        <departement type="Management">London</departement>
                    </departements>
            '
            Dim employee1 As XElement = _
                                <employee>
                                    <name>John Smith</name>
                                    <%= From d In departements.Elements() _
                                        Where d.Value = "London" _
                                        Select d %>
                                </employee>
            Console.WriteLine(employee1.ToString())
            '
            Console.ReadLine()
        End Sub
    End Class
    Class Departement
        Public Property Area As String
        Public Property Type As DepartementType
    End Class
    Enum DepartementType
        Sales
        Distrubution
    End Enum
End Namespace
Console Application Output
<employee>
  <name>John Smith</name>
  <departement type="Sales">London</departement>
  <departement type="Management">London</departement>
</employee>

Dit artikel is gepubliceerd op maandag 15 oktober 2012 op vbvoorbeelden, bezoek de website voor een recente versie van dit artikel of andere artikels.