LINQ- Combine Multiple List<T> and order by a value (.Net 3.5)

Question

Hi, all

I'm trying to combine a number of List<T> where T:IGetTime (i.e T will always have method getTime()).

Then I'm trying order the items by the DateTime that getTime() returns.

My LINQ looks like this:

public static List<T> Combine(List<T> one, List<T> two, List<T> three)
    {
        var result = from IGetTime item in one
                     from IGetTime item2 in two
                     from IGetTime item3 in three
                     select new{ item, item2, item3 };

        return result.ToList();
    }

I've yet to add an orderby. Which should look somthing like this:

var thestream = from T item in this
                orderby item.getTime() descending
                select item;

Is there anyway to both combine and order the final list????

Thanks in advance,

Roberto

Answer 1

You've got three lists here - what exactly are you trying to order by?

Your cast is incorrect too - the result will be an IEnumerable<X> where X is an anonymous type with three Ts in.

If the idea is really to concatenate the three lists and then sort, you want:

return one.Concat(two)
          .Concat(three)
          .OrderByDescending(x => x.GetTime())
          .ToList();

Answer 2

Here's how I'd do it:

public static List<T> Combine<T, TKey>
(
  Func<T, TKey> orderingFunction,
  params IEnumerable<T>[] theParams
)
  where TKey : IComparable
{
  return theParams
    .SelectMany(x => x)
    .OrderBy(orderingFunction)
    .ToList();
}

Here's some test code:

    public static void Test1()
    {
        List<int> a = new List<int>() { 1, 2, 3 };
        List<int> b = new List<int>() { 3, 2, 1 };
        List<int> c = CombineLists.Combine(i => i, a, b);
        c.ForEach(i => Console.WriteLine(i));
    }

Here's the story:

public static List<T> Combine<T, TKey>
(
  Func<T, TKey> orderingFunction,
  params IEnumerable<T>[] theParams
)
  where TKey : IComparable

This signature declares a method that takes two type parameters, some ordering function and a bunch of collections. Notice that the types T and TKey are not specified explicitly in the test call. The compiler has a little puzzle to figure out what these types are. First it inspects the IEnumerables that it has been given (a and b) and discovers they are IEnumerable of int. Aha, T must be int. Then it inspects the ordering function and sees that it returns the same type that it is passed. Aha, TKey must be int.

The where is kind of funny. OrderBy should check (at compile time) that TKey is IComparable. It only checks at runtime, so we get to do the compile time check in our code.

params takes as many parameters as you like and refers to them be creating an array. Who wants to be limited to three lists?

        return theParams
            .SelectMany(x => x)
            .OrderBy(orderingFunction)
            .ToList();

SelectMany unpacks a collection of collections. This is a way to flatten one level of hierarchy. OrderBy takes some function that projects each element to an orderable value, and orders the elements according to those values. ToList enumerates the query and returns the list. No surprises there.