Entity Framework - Linq Abfrage mit Reihenfolge von und Gruppe von

Question

Ich habe Measurement Objekte mit den entsprechenden Eigenschaften CreationTime (DateTime) und Reference (String) und einige andere Werte.

Ich möchte eine effiziente Linq-Abfrage, um eine meiner MeasurementDbContext dass

• Gruppen Objekte schreiben von einem bestimmten Reference
• Aufträge die Gruppen entweder durch die CreationTime Eigentum des ersten Measurement aus der Gruppe oder der Durchschnitt der CreationTime Eigenschaften
• begrenzt die Abfrage auf die neuesten numOfEntries

(In einem späteren Schritt i berechnen Werte über diese zurück Gruppen gemittelt, aber ich denke, dass für mein Problem nicht relevant ist.)

Die DbContext selbst eine DbSet<Measurement> hat Measurements hält alle Measurement Objekte genannt.

Ich kam mit der folgenden Abfrage, die zu einer Liste von Gruppen führt, die korrekt sortiert ist, aber einige Gruppen dazwischen fehlt.

var groupByReference = (from m in context.Measurements 
          orderby m.CreationTime 
          group m by new { m.Reference } into g 
          select g).Take(numOfEntries).ToList(); 

Wie wähle ich die „letzten“ Gruppen von Measurement richtig s?

Ich benutze Entity Framework 4.4 mit einer MySQL-Datenbank (MySql Connector/Net 6.6.4). Dieses Beispiel ist vereinfacht, ich kann mehr ins Detail gehen und/oder ein Beispiel geben, wenn es notwendig ist.

Danke!

Answer 1

Versuchen Sie, die order by nach group by bewegen:

var groupByReference = (from m in context.Measurements 
         group m by new { m.Reference } into g 
         order by g.Avg(i => i.CreationTime) 
         select g).Take(numOfEntries).ToList(); 

Answer 2

Es ist Methode Syntax (die ich einfacher zu lesen), aber dies könnte es

Aktualisiert Beitrag Kommentar

Verwenden .FirstOrDefault() stattdessen tun von .First()

Im Hinblick auf die durchschnittlichen Daten, können Sie, dass eine Bestellung für den Moment fallen lassen, wie ich im Moment zu einer IDE bekommen nicht in der Lage ist

var groupByReference = context.Measurements 
           .GroupBy(m => m.Reference) 
           .Select(g => new {Creation = g.FirstOrDefault().CreationTime, 
//            Avg = g.Average(m => m.CreationTime.Ticks), 
               Items = g }) 
           .OrderBy(x => x.Creation) 
//       .ThenBy(x => x.Avg) 
           .Take(numOfEntries) 
           .ToList(); 

Answer 3

Ihre Anforderungen sind ganz über den Platz, aber das ist die Lösung zu meinem Verständnis von ihnen:

zur Gruppe von Referenzobjekt:

var refGroupQuery = (from m in context.Measurements 
      group m by m.Reference into refGroup 
      select refGroup); 

Jetzt sagen Sie, Sie durch „jüngsten numOfEntries“ begrenzen Ergebnisse wollen - ich dies Sie die zurückgegebenen Messungen wollen bedeuten nehmen begrenzen ...in diesem Fall:

var limitedQuery = from g in refGroupQuery 
        select new 
        { 
         Reference = g.Key, 
         RecentMeasurements = g.OrderByDescending(p => p.CreationTime).Take(numOfEntries) 
        } 

Um Gruppen von ersten Messerstellungszeit zu bestellen (beachten Sie sollten die Messungen bestellen, wenn Sie den frühesten Wert Creation, substitue „g.SomeProperty“ mit „g.CreationTime“ wollen):

var refGroupsOrderedByFirstCreationTimeQuery = limitedQuery.OrderBy(lq => lq.RecentMeasurements.OrderBy(g => g.SomeProperty).First().CreationTime); 

um Gruppen von durchschnittlich Creation zu bestellen, die Ticks-Eigenschaft der Datetime-Struktur verwenden:

var refGroupsOrderedByAvgCreationTimeQuery = limitedQuery.OrderBy(lq => lq.RecentMeasurements.Average(g => g.CreationTime.Ticks)); 

Answer 4

Sie können versuchen, das Ergebnis der GroupBy zu werfen und in ein Take n Enumerable zuerst verarbeiten dann den Rest (Gebäude an der Lösung von NinjaNye bereitgestellt

var groupByReference = (from m in context.Measurements 
           .GroupBy(m => m.Reference) 
           .Take(numOfEntries).AsEnumerable() 
           .Select(g => new {Creation = g.FirstOrDefault().CreationTime, 
              Avg = g.Average(m => m.CreationTime.Ticks), 
               Items = g }) 
           .OrderBy(x => x.Creation) 
           .ThenBy(x => x.Avg) 
           .ToList() select m); 

Ihre SQL-Abfrage wie folgt aussehen würde (je nach Eingabe), um diese

SELECT TOP (3) [t1].[Reference] AS [Key] 
FROM (
    SELECT [t0].[Reference] 
    FROM [Measurements] AS [t0] 
    GROUP BY [t0].[Reference] 
    ) AS [t1] 
GO 

-- Region Parameters 
DECLARE @x1 NVarChar(1000) = 'Ref1' 
-- EndRegion 
SELECT [t0].[CreationTime], [t0].[Id], [t0].[Reference] 
FROM [Measurements] AS [t0] 
WHERE @x1 = [t0].[Reference] 
GO 

-- Region Parameters 
DECLARE @x1 NVarChar(1000) = 'Ref2' 
-- EndRegion 
SELECT [t0].[CreationTime], [t0].[Id], [t0].[Reference] 
FROM [Measurements] AS [t0] 
WHERE @x1 = [t0].[Reference]