Linq Group By - sélectionnez un seul enregistrement dans chaque groupe en résultat tapé

Question

La requête ci-dessous est similaire à ce que j'essaie de réaliser, mais simplifiée. Dans mon code actuel, j'ai quatre tables jointes et j'essaie d'obtenir un résultat qui contient la dernière version. J'ai C# version que je suis très proche, mais ne pouvait pas créer une version Vb avec un résultat de type mis

C# Version Cette requête génère SQL appropriée que je voulais, mais n'a pas pu sélectionner des colonnes dont je avais besoin.

var query= from user in Customers join adrs in CustomerAddress 
      on user.Id equals adrs.CustId 
      group user by adrs.CustId into g 
      select g.OrderByDescending(x=>x.adrs.Version).First(); 

VB Version Cette requête échoue dans l'ordre par et appelant la première génère sql moche dans le dos

dim query= from user in Customers Join adrs in CustomerAddress _ 
       on user.Id Equals adrs.CustId _ 
      Group By custId=adrs.CustId Into g = Group _ 
      Order By adrs.version Descending _ 
      Let latestAddress=g.First() _ 
      Select new ResultObject() with _ 
      { _ 
      .AddressId=latestAddress.adrs.Id, _ 
      .Street=latestAddress.adrs.Street _ 
       } 

dim results=query.ToList() 

- Mise à jour

Je cherche SQL similaire à ceci, qui est généré par la requête C# ci-dessus avec l'exception que je veux choisir les noms de colonne.

SELECT [t3].[test], [t3].[ID], [t3].[RequestQueueId], [t3].[CI_RequestType], [t3].[CI_Division], [t3].[CI_Company], 
FROM (
    SELECT [t0].[RequestQueueId] 
    FROM [RequestHeader] AS [t0] 
    GROUP BY [t0].[RequestQueueId] 
    ) AS [t1] 
OUTER APPLY (
    SELECT TOP (1) 1 AS [test], [t2].[ID], [t2].[RequestQueueId], [t2].[CI_RequestType], [t2].[CI_Division], [t2].[CI_Company], 
    FROM [RequestHeader] AS [t2] 
    WHERE [t1].[RequestQueueId] = [t2].[RequestQueueId] 
    ORDER BY [t2].[Version] DESC 
    ) AS [t3] 
ORDER BY [t3].[Version] DESC 

Answer 1

Je suppose que cela résoudra votre problème

var query = 
from customeraddress in db.CustomerAddresses 
join customers in db.Customers on new { CustId = customeraddress.CustId } equals new { CustId = customers.Id } 
join LatestVersion in 
    (
     (from customeraddress_1 in db.CustomerAddresses 
      group customeraddress_1 by new 
      { 
       customeraddress_1.CustId 
      } into g 
      select new 
      { 
       CustId = (System.Int32)g.Key.CustId, 
       MaxVersion = (System.Int32)g.Max(p => p.Version) 
      })) 
     on new { customeraddress.CustId, customeraddress.Version } 
    equals new { CustId = Convert.ToInt32(LatestVersion.CustId), Version = Convert.ToInt32(LatestVersion.MaxVersion) } 
select new 
{ 
    Id = (System.Int32)customers.Id, 
    customers.Field1, 
    customers.Field2, 
    customeraddress.Field3, 
    customeraddress.Field4, 
    Version = (System.Int32)customeraddress.Version 
}; 
var results = query.ToList(); 

Answer 2

Pour commencer, vous pouvez simplement rendre votre version VB identique à votre C# version si vous avez aimé le sql tant, étant donné que les colonnes que vous voulez seront disponibles sur l'objet que les C# de retour de version. Je ne suis pas trop bon avec la syntaxe de requête, mais je pense que c'est quelque chose comme:

Dim query = From user In Customers Join adrs In CustomerAddress _ 
    On user.Id Equals adrs.CustId _ 
    Group user By adrs.CustId Into g _ 
    Select g.OrderByDescending(Function(x) x.adrs.Version).First() 

Cependant, une seule version couramment possible serait quelque chose comme:

C#

var query = Customers 
    .Join(
    CustomerAddress, 
    x => x.Id, 
    x => x.CustId, 
    (o,i) => i 
    ).GroupBy(x => x.CustId) 
    .SelectMany(x => x 
    .OrderByDescending(y => y.version) 
    .First() 
    ).Select(x => new ResultObject() { 
    AddressId = x.Id, 
    Street = x.Street 
    }); 

VB

Dim query = Customers _ 
    .Join(_ 
    CustomerAddress, _ 
    Function(x) x.Id, _ 
    Function(x) x.CustId, _ 
    Function(o,i) i _ 
    ).GroupBy(Function(x) x.CustId) _ 
    .SelectMany(Function(x) x _ 
    .OrderByDescending(Function(y) y.version) _ 
    .First() _ 
    ).Select(Function(x) New ResultObject() With { _ 
    .AddressId = x.Id, _ 
    .Street = x.Street _ 
    }) 

NOTE: Le code ci-dessus n'a pas été testé, mais j'espère que cela aide!