实体框架按日期获得每种组合之一

Question

I'm using Entity Framework in ASP.NET. I have something like a table like this:

+----+--------------------------+-------+-------+------------+
| id |         content          | type1 | type2 |    date    |
+----+--------------------------+-------+-------+------------+
|  0 | Some text                | TypeA | TypeB | 2013-04-01 |
|  1 | Some older text          | TypeB | TypeA | 2012-03-01 |
|  2 | Some even older texttext | TypeB | TypeC | 2011-01-01 |
|  3 | A dog                    | TypeC | TypeB | 2013-04-01 |
|  4 | And older dog            | TypeC | TypeB | 2012-03-01 |
|  5 | An even older dog        | TypeA | TypeC | 2011-01-01 |
|  6 | More text                | TypeA | TypeB | 2013-03-01 |
+----+--------------------------+-------+-------+------------+

I already can obtain the most recent occurrence of type 1 or type 2, but I want to query the database to obtain the most recent occurrence of the combination of two types:

 +----+--------------------------+-------+-------+------------+ | id | content | type1 | type2 | date | +----+--------------------------+-------+-------+------------+ | 0 | Some text | TypeA | TypeB | 2013-04-01 | | 3 | A dog | TypeC | TypeB | 2013-04-01 | | 5 | An even older dog | TypeA | TypeC | 2011-01-01 | +----+--------------------------+-------+-------+------------+ 

Thanks!

EDIT: The columns type1 or type2 are basically the same, so if Type1=A and Type2=B it's the same as Type1=B and Type2=A.

Answer 1

This would do the trick, except for one little issue, which I'll describe after the code sample.

var grouped = datacontext.Table
    .GroupBy(
        item => new { item.Type1, item.Type2 },
        (key, groupData) => groupData.OrderBy(x => x.TheDate).First())
    .ToArray();

The problem is that this way the grouping is done on the combination of Type1 and Type2, in that order . So what you are saying in the comments, which is that Type1=A AND Type2=B is equal to Type1=B AND Type2=A is a problem.

I really have no idea if EF (or L2S) can compile this, but it is worth a try.

var grouped = datacontext.Table
    .Select(x => new Data // TODO: Update to the correct typename
    {
        x.Id,
        x.Content,
        Type1 = x.Type1.CompareTo(x.Type2) > 0 ? x.Type2 : x.Type1,
        Type2 = x.Type1.CompareTo(x.Type2) > 0 ? x.Type1 : x.Type2,
        x.TheDate
    })
    .GroupBy(
        item => new { item.Type1, item.Type2 },
        (key, groupData) => groupData.OrderBy(x => x.TheDate).First())
    .ToArray();

If the above doesn't compile, then an alternative option is to correct the Type1/Type2 values after the database-grouping, and perform the grouping again in-memory. Yes, this means it will group twice (once by the database, once in-memory), but it will work, and won't require to import the complete table into memory.

var grouped = datacontext.Table
    .GroupBy(
        item => new { item.Type1, item.Type2 },
        (key, groupData) => groupData.OrderBy(x => x.TheDate).First())
    .AsEnumerable()
    .GroupBy(
        item => new {
            // Group by the possible-swapped-values of Type1 and Type2
            Type1 = x.Type1.CompareTo(x.Type2) > 0 ? x.Type2 : x.Type1
            Type2 = x.Type1.CompareTo(x.Type2) > 0 ? x.Type1 : x.Type2
        },
        (key, groupData) => groupData.OrderBy(x => x.TheDate).First())
    .ToArray();

I think I like the last option the best, since:

• it can be translated to sql (no special features like string.CompareTo )
• at most it will be twice the amount of records that the database will yield, not anymore (which in my opinion is acceptable without knowing the amount of total data we're talking about)