Question

I have a List of objects with this implementation:

 class Locations
    {
        public string Origin { get; set; }
        public string Dest { get; set; }
        public int Total { get; set; }
    }

I need to output a table, in CSV format, that has the Origins as rows, the Destinations as columns, and the Total where the specified Origins and Destinations meet. There could be an arbitrary number of Location objects in my List.

Given the following records in my List:

Origin=A
Dest=B
Total=10

Origin=B
Dest=A
Total=20

My output would look like this (with the ‘-‘ character meaning there’s no Total between identical Origin/Destinations):

Origins/Destinations,A,B
A,-,10
B,20,-

Thus far, I have done the following:

1) Traverse the List to output the Destinations.

2) Traverse the List to output an Origin. For the Origin, traverse the list to find the Total for each Destination related to the Origin.

3) Repeat #2 for the next Origin.

My results aren’t quite working out as the row/column data doesn’t always match up. Is there a simpler solution to this?

Answer 1

Update

After reading your update it seems that there’s no need to sum as there is only going to be one object with a given Origin and Destination. In that case you can keep the code that collects places, do the nested foreach and simply get the total with

var item = locations.FirstOrDefault(l => l.Origin == origin && l.Dest == dest);
var total = item == null ? 0 : item.Total;

Original answer

You can get a list of all locations with

var locations = new List<Locations>(); // assume it's populated
var places = locations.Select(l => l.Origin)
                      .Concat(locations.Select(l => l.Dest))
                      .Distinct()
                      .OrderBy(s => s); // why not sort it as well

At this point you can simply iterate over places for the rows and do another nested iteration for the columns:

foreach (var origin in places)
{
    foreach (var dest in places)
    {
        var total = locations.Where(l => l.Origin == origin && l.Dest == dest)
                             .Sum(l => l.Total);
    }
}

You can immediately see how you can easily construct a table with this structure. The main disadvantage of this approach is that it’s doing a lot more work than strictly necessary; theoretically we can certainly iterate just once over locations, collecting the information as we go. It’s possible to sum up the Total for each pair of Origin and Dest with

var totals = locations.GroupBy(l => new { l.Origin, l.Dest })
             .ToDictionary(g => Tuple.Create(g.Key.Origin, g.Key.Dest),
                           g => g.Sum(r => r.Total));

At this point we can take a page from the first solution:

foreach (var origin in places)
{
    foreach (var dest in places)
    {
        var total = totals[Tuple.Create(origin, dest)]; // almost too easy :)
    }
}