[Linq to XML]Moeite met juiste query te maken

[Haan]

Wat ik wil is een Dictionary genereren op basis van een xml bestand met de volgende structuur:

XML:

<root>
   <entity name="entity1">
      <mapping>
         <source>source1</source>
         <target>target1</target>
      </mapping>
      <mapping>
         <source>source2</source>
         <target>targe2</target>
      </mapping>
    </entity>
    <entity name="entity2">
      <mapping>
         <source>source1</source>
         <target>target1</target>
      </mapping>
      <mapping>
         <source>source2</source>
         <target>targe2</target>
      </mapping>
    </entity>
</root>

In de dictionary komen dan source/target mappings van een enkele entity.

Nu heb ik dat volgens mij op een omslachtige manier gedaan:

C#:

XDocument mappingXml = XDocument.Load("mapping.xml");
Dictionary<string, string> mappings = new Dictionary<string, string>();

var query = from m in mappingXml.Descendants("entity")
        where (string)m.Attribute("name") == "entity1"
        select new
        {
            Mappings = m.Elements("mapping")
        };            

foreach (var v in query)
{
    foreach (XElement xe in v.Mappings)
    {
        mappings.Add(xe.Element("source").Value, xe.Element("target").Value);
    }
}    

De eerste foreach is omdat ik geen makkelijkere manier kon vinden om direct de Mappings property uit de query variabele te krijgen

Wat ik eigenlijk zou willen is gewoon direct een select maken waarin ik een Source en een Target zet en dan dus de volgende loop gebruiken:

C#:

foreach (var v in query)
{
    mappings.Add(v.Source, v.Target);
}

Daar zit dus het probleem, het beste resultaat dat ik tot nu toe heb bereikt is alleen het eerste element te krijgen met 'Source = m.Element("mapping").Element("Source")'.

Ik ben dus benieuwd of hier een handigere oplossing voor is dan ik nu heb

[Peetman]

Heb niet direct een test beschikbaar, maar misschien is dit handiger:

C#:

var mappings = from m in mappingXml.Descendants("mapping")
        select new
        {
            source = m.Elements("source"),
            target= m.Elements("target"),
            entity = m.Ancestor("entity").Attributes("name")
        }; 

En dan die collection in een dictionary gaan stoppen

[Haan]

Peetman schreef op vrijdag 24 juli 2009 @ 12:55:
Heb niet direct een test beschikbaar, maar misschien is dit handiger:

C#:

var mappings = from m in mappingXml.Descendants("mapping")
        select new
        {
            source = m.Elements("source"),
            target= m.Elements("target"),
            entity = m.Ancestor("entity").Attributes("name")
        }; 

En dan die collection in een dictionary gaan stoppen

Dat is zo te zien niet echt handiger, dan haal je dus alle nodes op, en moet je daarna alsnog handmatig gaan filteren op entiteit. Een Ancestor methode bestaat trouwens niet, en m.Ancestors("entity") geeft geen resultaat terug..

[Niek.NET]

Zoiets:

C#:

Dictionary<string, Dictionary<string, string>> result; // First key = entity name, second dict, key = source, value = target


result = (from n in doc.Descendants("entity")
          let name = n.Attribute("name").Value
          let mappings = n.Descendants("mapping")
          select new 
          {
            EntityName = name,
            Mappings = mappings
          }).ToDictionary((e => e.EntityName), (e => e.Mappings.ToDictionary(m => m.Element("source").Value, m => m.Element("target").Value)));

[Haan]

Die ToDictionary extension method is wel mooi Ben alleen nog niet zo goed thuis in hoe die dingen werken.. Dictionary in een Dictionary vind ik niet zo heel mooi, dus ik kom nu uit op dit:

C#:

var query = from m in mappingXml.Descendants("entity")
            where (string)m.Attribute("name") == "entity1"
            let mappings= m.Descendants("mapping")
            select new
            {
                Mapping = mappings
            };

Dictionary<string, string> mapping;
foreach (var v in query)
{
    mapping = v.Mapping.ToDictionary(x => x.Element("source").Value, x => x.Element("target").Value);
}     

Alleen die foreach zou ik nog weg willen werken, dan is het volgens mij wel netjes

[Niek.NET]

Haan schreef op vrijdag 24 juli 2009 @ 14:17:
Die ToDictionary extension method is wel mooi Ben alleen nog niet zo goed thuis in hoe die dingen werken.. Dictionary in een Dictionary vind ik niet zo heel mooi, dus ik kom nu uit op dit:

C#:

var query = from m in mappingXml.Descendants("entity")
            where (string)m.Attribute("name") == "entity1"
            let mappings= m.Descendants("mapping")
            select new
            {
                Mapping = mappings
            };

Dictionary<string, string> mapping;
foreach (var v in query)
{
    mapping = v.Mapping.ToDictionary(x => x.Element("source").Value, x => x.Element("target").Value);
}     

Alleen die foreach zou ik nog weg willen werken, dan is het volgens mij wel netjes

Maar in die foreach overschrijf je gewoon die mapping var. Wat wil je dat het eindresultaat is dan?

Je zult die mappings op enige wijze moeten groeperen toch?

[Haan]

Door de where clausule is het resultaat altijd maar 1 node Daarom is die foreach ook een beetje nutteloos, maar ik kan niet vinden hoe je dat anders doet.

[Verwijderd]

Haan schreef op vrijdag 24 juli 2009 @ 14:31:
Door de where clausule is het resultaat altijd maar 1 node Daarom is die foreach ook een beetje nutteloos, maar ik kan niet vinden hoe je dat anders doet.

query.First() of query.Single()

[Haan]

Verwijderd schreef op vrijdag 24 juli 2009 @ 15:04:
[...]

query.First() of query.Single()

Thanks!