Question

I have an XDocument with a fragment that resembles:

<Data>
    <Row Id="0" ParentId="-1">
        <!-- stuff -->
    </Row>
    <Row Id="1" ParentId="0">
        <!-- stuff -->
    </Row>
    <Row Id="2" ParentId="0">
        <!-- stuff -->
    </Row>
    <Row Id="3" ParentId="-1">
        <!-- stuff -->
    </Row>
    <Row Id="4" ParentId="3">
        <!-- stuff -->
    </Row>
</Data>

Assume nesting is limited to the example above.
I want to create a data structure – IDictionary<Parent, List<Child>>. I can’t seem to get anything to join correctly. What I have to this point is:

// get lists of data nodes
List<XElement> pRows = xData.Elements(XName.Get("Row"))
                            .Where(e => e.Attribute(XParentId).Value == "-1")
                            .Select(e => e)
                            .ToList();
List<XElement> cRows = xData.Elements(XName.Get("Row"))
                            .Where(e => e.Attribute(XParentId).Value != "-1")
                            .Select(e => e)
                            .ToList();

var dataSets = pRows.GroupJoin(cRows,
                               p => p,
                               c => c.Attribute(XParentId).Value,
                               (p, children) => new {
                                 ParentID = p.Attribute(XId).Value,
                                 Children = children.Select(c => c)
                               });

The compiler is complaining:

The type arguments for method
‘System.Linq.Enumerable.GroupJoin(System.Collections.Generic.IEnumerable,
System.Collections.Generic.IEnumerable,
System.Func, System.Func,
System.Func,TResult>)’
cannot be inferred from the usage. Try specifying the type arguments
explicitly.

I followed a sample from MSDN using the GroupJoin. I didn’t want to use 2 lists – I’d prefer to use a single list of List<XElement> containing all the rows.

Answer 1

I think the 2 list approach is cleaner, except I would avoid calling ToList() until the final step or when the list is really needed. You could turn it into one statement, but it would be long and harder to follow.

To fix your query, you need to change the outer key selector for pRows from p => p to p => p.Attribute(XId).Value, which is the actual ID. Currently it selects the entire element, which cannot be compared to c => c.Attribute(XParentId).Value since they are different types. The updated query would be:

var dataSets = pRows.GroupJoin(cRows,
                               p => p.Attribute(XId).Value,
                               c => c.Attribute(XParentId).Value,
                               (p, children) => new {
                                 ParentID = p.Attribute(XId).Value,
                                 Children = children.Select(c => c)
                               });

To avoid using 2 lists you could modify the query above and replace pRows and cRows with their respective queries, but that makes it long and harder on the eyes. In this particular case I prefer expressing the GroupJoin using query syntax since it is much easier to read than the fluent syntax:

var query = from root in xData.Elements("Row").Where(e => e.Attribute("ParentId").Value == "-1")
            join child in xData.Elements("Row").Where(e => e.Attribute("ParentId").Value != "-1")
            on root.Attribute("Id").Value equals child.Attribute("ParentId").Value
            into rootChild
            select new 
            {
                ParentId = root.Attribute("Id").Value,
                Children = rootChild.Select(o => o)
            };

var dict = query.ToDictionary(o => o.ParentId, o => o.Children.ToList());

Should your real problem have more nesting, LINQ probably won’t be the ideal solution.