Hente væerdier vha, LINQ2XML

Demo:

using System;
using System.Linq;
using System.Xml.Linq;

namespace E
{
    public class Program
    {
        public static void Main(string[] args)
        {
            string s = @"<ROOT>
    <FOO>
        <TABEL1>
            <TABELELEMENT>
            <NAVN>MitNavn1</NAVN>
            <VAERDI>2,530</VAERDI>
            </TABELELEMENT>
            <TABELELEMENT>
            <NAVN>MitNavn2</NAVN>
            <VAERDI>2,5430</VAERDI>
            </TABELELEMENT>
            <TABELELEMENT>
            <NAVN>MitNavn3</NAVN>
            <VAERDI>2,540</VAERDI>
            </TABELELEMENT>
            <TABELELEMENT>
            <NAVN>MitNavn4</NAVN>
            <VAERDI>2,550</VAERDI>
            </TABELELEMENT>
            <TABELELEMENT>
            <NAVN>MitNavn5</NAVN>
            <VAERDI>2,504</VAERDI>
            </TABELELEMENT>
        </TABEL1>
        <TABEL2>
            <TABELELEMENT>
            <NAVN>MitNavn6</NAVN>
            <VAERDI>2,450</VAERDI>
            </TABELELEMENT>
            <TABELELEMENT>
            <NAVN>MitNavn7</NAVN>
            <VAERDI>2,550</VAERDI>
            </TABELELEMENT>
            <TABELELEMENT>
            <NAVN>MitNavn8</NAVN>
            <VAERDI>2,5503</VAERDI>
            </TABELELEMENT>
            <TABELELEMENT>
            <NAVN>MitNavn9</NAVN>
            <VAERDI>2,505</VAERDI>
            </TABELELEMENT>
            <TABELELEMENT>
            <NAVN>MitNavn10</NAVN>
            <VAERDI>2,540</VAERDI>
            </TABELELEMENT>
        </TABEL2>
    </FOO>
</ROOT>";
            XDocument doc = XDocument.Parse(s);
            foreach(XElement elm in doc.Root.Element("FOO").Elements().Elements("TABELELEMENT").Elements("NAVN"))
            {
                Console.WriteLine(elm.Value);
            }
            Console.ReadKey();
        }
    }
}

Hmmm ok så man kan altså ikke skrive et Linq udtryk, der giver en collection tilbage..eller antallet af noder...

Prøvede faktisk at undgå at bruge en løkke...

Ville jo prøve at lege med mulighederne for LINQ2XMl :)

var res = from v in _xDoc.Elements("ROOT") select v.Elements("FOO").Elements("TABEL1").Elements("TABELELEMENT").Elements("NAVN");

Denne gav mig kun det første navn...hvor jeg gerne ville have alle navnene... den sidste betingelse i mit udtryk kan vel skrive om, så det bliver alle navnene eller noderne inden for TABEL1 jeg får ud...

I virkeligheden har jeg behov for at Linq udtryk, der giver mig alle navnene noget á la //NAVN i xpath.

Faktisk giver denne mig alle navnene:
var res = from v in _xDoc.Elements("ROOT") select v.Elements("FOO").Elements("TABEL1").Elements("TABELELEMENT").Elements("NAVN");

Men jeg får "<NAVN>MineNavne</NAVN>" med ud...nu skal jeg sådan set bare have tekst værdien ud :S

Du skal nok have fat i .Value

Dvs:
var res = from v in _xDoc.Elements("ROOT")
                      select v.Elements("FOO").Elements("TABEL1").Elements("TABELELEMENT").Elements("NAVN").Select(a => a.Value);

Når du bruger .Elements fremfor .Element får du en enumerable (og det er sådan en slags list).

Og det er vel det samme som XPath med //NAVN gør.

Hvis du så vil hente værdierne kan du hente .Value ligesom du i XPath kan hente text().

Fandt value og fik det til at virke...

Jeg deler points til begge, da I var med til at give mig en retningslinje...selvom jeg var tæt på og fandt svaret selv :P

Jeg deler points...skylder vist også buzzzy fra før...

Kan jeg ikke lave det til et array i samme udtryk? .ToArray?? Hvordan?

Både enumerable af XElement og String kan omformes til arrays med .ToArray()

Ja, ToArray() i enden ... så får du en string[] tilbage.

Point til arne_v, jeg har ikke rigtig bedraget med noget specielt.

mvh

Jeps fik det også til at virke...det eneste jeg synes, der er lidt grimt er det her:

var n = res.ElementAt(0).ToArray();

Jeg får nemlig en collection med et element, der indeholder en collection af mine værdier...det ville være fedt at komme udenom ElementAt(0)delen.

Hvordan beregnes res før:

var n = res.ElementAt(0).ToArray();

?

var res = from v in _xDoc.Elements("ROOT")
                      select v.Elements("FOO").Elements("TABEL1").Elements("TABELELEMENT").Elements("NAVN").Select(a => a.Value).ToArray();
var n = res.ElementAt(0).ToArray();

for mange .ToArray() - prøv:

var res = from v in _xDoc.Elements("ROOT")
                      select v.Elements("FOO").Elements("TABEL1").Elements("TABELELEMENT").Elements("NAVN").Select(a => a.Value);
var n = res.ToArray();

Hvis jeg kan fange VAERDI i samme omgang fra xml'en, så jeg får begge værdier...så vil jeg også blive meget glad.

Den havde jeg før...men jeg fik ikke mine værdier ud i min n.
så ligger værdierne i n[0].

IEnumerable<XElement> res = doc.Root.Element("FOO").Elements().Elements("TABELELEMENT");
            var res2 = res.Select(elm => new { Navn=elm.Element("NAVN").Value, Vaerdi=elm.Element("VAERDI").Value});
            foreach(var pair in res2)
            {
                Console.WriteLine(pair.Navn + " = " + pair.Vaerdi);
            }

Mange tak...smid et bare et svar ind.

svar

Jeg kan se at "TABEL1" og "TABEL2" kan forvolde mig problemer...der er ikke mulighed for at springe det element over? Jeg er sådan set bare interesseret i værdierne i mellem, og vil helst være fri for at smide en parameter med over, der hedder 'TABEL1' eller 'TABEL2'.

Kan det lade sig gøre...siger jeg, mens jeg accepterer svaret...og håber på et svar fra de kloge(dvs. Arne). :)

Buzz er naturligvis også en klog mand...

Jeg forstår ikke spørgsmålet.

.Element("FOO").Elements().Elements("TABELELEMENT")

det at der ikke er noget angivet i den midterste .Elements gør at den tager både TABLE1 og TABLE2.

ahhh ok...det kan jeg lige prøve så...du har alligevel forstået mit spørgsmål :)
Det er bare mig der ikke har briller på...jeg så ikke den tomme element()
Skrev selv koden i mit eksempel...og det blev med TABEL1.

Tak for hjælpen.

I virkeligheden er XPath og LINQ to XML meget ens.

doc.SelectNodes("/a/b/c")

doc.Elements("a").Elements("b").Elements("c")

etc.

Nogen bestemt grundt til du har angivet en doc.root?
Jeg får null reference exception med et tomt element().

Jeg tror ike at .Root er nødvendig - den røg bare på i farten.

.Elements() giver mening - jeg ved ikke om .Element() virker.

Sorry det var et tomt Elements(), jeg mente...irriterer mig lidt, da det virker lige så snart jeg knalder "TABEL1" eller "TABEL2" ind...

Hvordan ser dit udtryk ud nu?

var res = _xDoc.Root.Element("FOO").Elements().Elements("TABELELEMENT");
var res2 = res.Select(element => new { Navn = element.Element("NAVN").Value, Vaerdi = element.Element("VAERDI").Value}).ToArray();

I det øjeblik jeg sætter "TABEL1" i det tomme Elements(), så får jeg svar tilbage..men får et null reference exception nu.

Det lyder meget mystisk.

Hvad sjer der hvis du starter et nyt projekt og kører:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Xml.Linq;

namespace E
{
    public class Program
    {
        public static void Main(string[] args)
        {
            string s = @"<ROOT>
    <FOO>
        <TABEL1>
            <TABELELEMENT>
            <NAVN>MitNavn1</NAVN>
            <VAERDI>2,530</VAERDI>
            </TABELELEMENT>
            <TABELELEMENT>
            <NAVN>MitNavn2</NAVN>
            <VAERDI>2,5430</VAERDI>
            </TABELELEMENT>
            <TABELELEMENT>
            <NAVN>MitNavn3</NAVN>
            <VAERDI>2,540</VAERDI>
            </TABELELEMENT>
            <TABELELEMENT>
            <NAVN>MitNavn4</NAVN>
            <VAERDI>2,550</VAERDI>
            </TABELELEMENT>
            <TABELELEMENT>
            <NAVN>MitNavn5</NAVN>
            <VAERDI>2,504</VAERDI>
            </TABELELEMENT>
        </TABEL1>
        <TABEL2>
            <TABELELEMENT>
            <NAVN>MitNavn6</NAVN>
            <VAERDI>2,450</VAERDI>
            </TABELELEMENT>
            <TABELELEMENT>
            <NAVN>MitNavn7</NAVN>
            <VAERDI>2,550</VAERDI>
            </TABELELEMENT>
            <TABELELEMENT>
            <NAVN>MitNavn8</NAVN>
            <VAERDI>2,5503</VAERDI>
            </TABELELEMENT>
            <TABELELEMENT>
            <NAVN>MitNavn9</NAVN>
            <VAERDI>2,505</VAERDI>
            </TABELELEMENT>
            <TABELELEMENT>
            <NAVN>MitNavn10</NAVN>
            <VAERDI>2,540</VAERDI>
            </TABELELEMENT>
        </TABEL2>
    </FOO>
</ROOT>";
            XDocument doc = XDocument.Parse(s);
            foreach(XElement elm in doc.Root.Element("FOO").Elements().Elements("TABELELEMENT").Elements("NAVN"))
            {
                Console.WriteLine(elm.Value);
            }
            IEnumerable<XElement> res = doc.Root.Element("FOO").Elements().Elements("TABELELEMENT");
            var res2 = res.Select(elm => new { Navn=elm.Element("NAVN").Value, Vaerdi=elm.Element("VAERDI").Value});
            foreach(var pair in res2)
            {
                Console.WriteLine(pair.Navn + " = " + pair.Vaerdi);
            }
            Console.ReadKey();
        }
    }
}

Så virker det fint...kan det have noget at gøre med den måde man loader xml ind på? Jeg henter det fra en fil på min disk....

Nu parser jeg den som dig...

Det burde ikke gøre en forskel.

Er der nogen forskel i XML'en?

Jeg har fundet ud af problemet...men ved ikke, hvordan jeg kan løse det.

Min XML ser i virkeligheden således ud: Prøv at køre dit program over det...så kan du se problemet.
<ROOT>
    <FOO>
        <TABEL1>
            <TABELELEMENT>
                <NAVN>500</NAVN>
                <VAERDI>250</VAERDI>
            </TABELELEMENT>
            <TABELELEMENT>
                <NAVN>10000</NAVN>
                <VAERDI>2,00</VAERDI>
            </TABELELEMENT>
            <TABELELEMENT>
                <NAVN>2000</NAVN>
                <VAERDI>1,7</VAERDI>
            </TABELELEMENT>
            <TABELELEMENT>
                <NAVN>50000</NAVN>
                <VAERDI>1,0</VAERDI>
            </TABELELEMENT>
            <TABELELEMENT>
                <NAVN>99.999</NAVN>
                <VAERDI/>
            </TABELELEMENT>
        </TABEL1>
        <TABEL2>
            <TABELELEMENT>
                <NAVN_C>50.00</NAVN_C>
                <VAERDI_C>2,0</VAERDI_C>
            </TABELELEMENT>
            <TABELELEMENT>
                <NAVN_C>100.000</NAVN_C>
                <VAERDI_C>150</VAERDI_C>
            </TABELELEMENT>
            <TABELELEMENT>
                <NAVN_C>20000</NAVN_C>
                <VAERDI_C>25</VAERDI_C>
            </TABELELEMENT>
            <TABELELEMENT>
                <NAVN_C>500.000</NAVN_C>
                <VAERDI_C>1,0</VAERDI_C>
            </TABELELEMENT>
            <TABELELEMENT>
                <NAVN_C>9999</NAVN_C>
                <VAERDI_C/>
            </TABELELEMENT>
        </TABEL2>
        <TABEL3>
            <TABELELEMENT>
                <NAVN_B>999.999</NAVN_B>
                <VAERDI_B>200</VAERDI_B>
            </TABELELEMENT>
        </TABEL3>
                <ANDETSNASK>Noget der ikke skal bruges</ANDETSNASK>
                <ANDETSNASK2>Noget der heller ikke skal bruges</ANDETSNASK2>
        <TABEL4>
            <TABELELEMENT>
                <NAVN_A>10000</NAVN_A>
                <VAERDI_A>2,0</VAERDI_A>
            </TABELELEMENT>
            <TABELELEMENT>
                <NAVN_A>99.999</NAVN_A>
                <VAERDI_A>100</VAERDI_A>
            </TABELELEMENT>
        </TABEL4>
</FOO>
</ROOT>

Så jeg skal bare have "NAVN" og "VAERDI" ud, som befinder sig i TABEL1, men jeg kan faktisk ikke være sikker...det kan komme ud i TABEL2 i visse tilfælde...derfor vil jeg stadigvæk have alle "NAVN" og "VAERDI" ud uanset hvilken TABEL, den befinder sig i.

PS! NAVN_A og VAERDI_A er jeg fx. ikke interesseret i. Kun dem uden underscore.

Se det er jo en lidt anden XML.

:-)

Forslag:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Xml.Linq;

namespace E
{
    public class Program
    {
        public static void Main(string[] args)
        {
            string s = @"<ROOT>
    <FOO>
        <TABEL1>
            <TABELELEMENT>
                <NAVN>500</NAVN>
                <VAERDI>250</VAERDI>
            </TABELELEMENT>
            <TABELELEMENT>
                <NAVN>10000</NAVN>
                <VAERDI>2,00</VAERDI>
            </TABELELEMENT>
            <TABELELEMENT>
                <NAVN>2000</NAVN>
                <VAERDI>1,7</VAERDI>
            </TABELELEMENT>
            <TABELELEMENT>
                <NAVN>50000</NAVN>
                <VAERDI>1,0</VAERDI>
            </TABELELEMENT>
            <TABELELEMENT>
                <NAVN>99.999</NAVN>
                <VAERDI/>
            </TABELELEMENT>
        </TABEL1>
        <TABEL2>
            <TABELELEMENT>
                <NAVN_C>50.00</NAVN_C>
                <VAERDI_C>2,0</VAERDI_C>
            </TABELELEMENT>
            <TABELELEMENT>
                <NAVN_C>100.000</NAVN_C>
                <VAERDI_C>150</VAERDI_C>
            </TABELELEMENT>
            <TABELELEMENT>
                <NAVN_C>20000</NAVN_C>
                <VAERDI_C>25</VAERDI_C>
            </TABELELEMENT>
            <TABELELEMENT>
                <NAVN_C>500.000</NAVN_C>
                <VAERDI_C>1,0</VAERDI_C>
            </TABELELEMENT>
            <TABELELEMENT>
                <NAVN_C>9999</NAVN_C>
                <VAERDI_C/>
            </TABELELEMENT>
        </TABEL2>
        <TABEL3>
            <TABELELEMENT>
                <NAVN_B>999.999</NAVN_B>
                <VAERDI_B>200</VAERDI_B>
            </TABELELEMENT>
        </TABEL3>
                <ANDETSNASK>Noget der ikke skal bruges</ANDETSNASK>
                <ANDETSNASK2>Noget der heller ikke skal bruges</ANDETSNASK2>
        <TABEL4>
            <TABELELEMENT>
                <NAVN_A>10000</NAVN_A>
                <VAERDI_A>2,0</VAERDI_A>
            </TABELELEMENT>
            <TABELELEMENT>
                <NAVN_A>99.999</NAVN_A>
                <VAERDI_A>100</VAERDI_A>
            </TABELELEMENT>
        </TABEL4>
</FOO>
</ROOT>";
            XDocument doc = XDocument.Parse(s);
            foreach(XElement elm in doc.Root.Element("FOO").Elements().Where(elm => elm.Name.LocalName.StartsWith("TABEL")).Elements("TABELELEMENT").Elements().Where(elm => elm.Name.LocalName.StartsWith("NAVN")))
            {
                Console.WriteLine(elm.Value);
            }
            IEnumerable<XElement> res = doc.Root.Element("FOO").Elements().Where(elm => elm.Name.LocalName.StartsWith("TABEL")).Elements("TABELELEMENT");
            var res2 = res.Select(elm => new { Navn=elm.Elements().Where(elm2 => elm2.Name.LocalName.StartsWith("NAVN")).First().Value, Vaerdi=elm.Elements().Where(elm2 => elm2.Name.LocalName.StartsWith("VAERDI")).First().Value});
            foreach(var pair in res2)
            {
                Console.WriteLine(pair.Navn + " = " + pair.Vaerdi);
            }
            Console.ReadKey();
        }
    }
}

Ah - du vill ikke have NAVN_* med ud. 2 minutter.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Xml.Linq;

namespace E
{
    public class Program
    {
        public static void Main(string[] args)
        {
            string s = @"<ROOT>
    <FOO>
        <TABEL1>
            <TABELELEMENT>
                <NAVN>500</NAVN>
                <VAERDI>250</VAERDI>
            </TABELELEMENT>
            <TABELELEMENT>
                <NAVN>10000</NAVN>
                <VAERDI>2,00</VAERDI>
            </TABELELEMENT>
            <TABELELEMENT>
                <NAVN>2000</NAVN>
                <VAERDI>1,7</VAERDI>
            </TABELELEMENT>
            <TABELELEMENT>
                <NAVN>50000</NAVN>
                <VAERDI>1,0</VAERDI>
            </TABELELEMENT>
            <TABELELEMENT>
                <NAVN>99.999</NAVN>
                <VAERDI/>
            </TABELELEMENT>
        </TABEL1>
        <TABEL2>
            <TABELELEMENT>
                <NAVN_C>50.00</NAVN_C>
                <VAERDI_C>2,0</VAERDI_C>
            </TABELELEMENT>
            <TABELELEMENT>
                <NAVN_C>100.000</NAVN_C>
                <VAERDI_C>150</VAERDI_C>
            </TABELELEMENT>
            <TABELELEMENT>
                <NAVN_C>20000</NAVN_C>
                <VAERDI_C>25</VAERDI_C>
            </TABELELEMENT>
            <TABELELEMENT>
                <NAVN_C>500.000</NAVN_C>
                <VAERDI_C>1,0</VAERDI_C>
            </TABELELEMENT>
            <TABELELEMENT>
                <NAVN_C>9999</NAVN_C>
                <VAERDI_C/>
            </TABELELEMENT>
        </TABEL2>
        <TABEL3>
            <TABELELEMENT>
                <NAVN_B>999.999</NAVN_B>
                <VAERDI_B>200</VAERDI_B>
            </TABELELEMENT>
        </TABEL3>
                <ANDETSNASK>Noget der ikke skal bruges</ANDETSNASK>
                <ANDETSNASK2>Noget der heller ikke skal bruges</ANDETSNASK2>
        <TABEL4>
            <TABELELEMENT>
                <NAVN_A>10000</NAVN_A>
                <VAERDI_A>2,0</VAERDI_A>
            </TABELELEMENT>
            <TABELELEMENT>
                <NAVN_A>99.999</NAVN_A>
                <VAERDI_A>100</VAERDI_A>
            </TABELELEMENT>
        </TABEL4>
</FOO>
</ROOT>";
            XDocument doc = XDocument.Parse(s);
            foreach(XElement elm in doc.Root.Element("FOO").Elements().Where(elm => elm.Name.LocalName.StartsWith("TABEL")).Elements("TABELELEMENT").Elements("NAVN"))
            {
                Console.WriteLine(elm.Value);
            }
            IEnumerable<XElement> res = doc.Root.Element("FOO").Elements().Where(elm => elm.Name.LocalName.StartsWith("TABEL")).Elements("TABELELEMENT").Where(elm => elm.Element("NAVN") != null);
            var res2 = res.Select(elm => new { Navn=elm.Element("NAVN").Value, Vaerdi=elm.Element("VAERDI").Value});
            foreach(var pair in res2)
            {
                Console.WriteLine(pair.Navn + " = " + pair.Vaerdi);
            }
            Console.ReadKey();
        }
    }
}

Ja, meget ked af det tog længere tid...jeg vidste ikke at xml strukturen ville give anledning til nogle problemer... Jeg er sikker på dit eksempel virker...men skal nok kigge videre på det imorgen :)

Tak for hjælpen

Hov...fik det til at virke :D

Takker :D