c# - inner - linq to entities join

¿Cómo usar LINQ para seleccionar un objeto?

Question

Tengo datos que se ven así:

UserId   |  SongId
--------   --------
1          1
1          4
1          12
2          95

También tengo la siguiente clase:

class SongsForUser
{
    public int User;
    public List<int> Songs;
}

Lo que me gustaría hacer es usar LINQ para seleccionar de mis datos para crear una colección de objetos SongsForUser. A continuación es lo que he encontrado hasta ahora:

var userCombos = songs.UserSongs.Select(x => new SongsForUser() { User = x.UserId, 
                                                                  Songs = /*What goes here?*/ });

¿Cómo haría para poblar mi lista de Songs ?

Así que el resultado debe ser dos objetos SongsForUser. Para el usuario 1 tendría 3 elementos en la lista de Songs . Para el usuario 2 tendría 1 elemento en la lista de Songs .

Answer 1

Digamos que tienes lo siguiente:

public class SongsForUser
{
    public int UserId;
    public List<int> Songs;
}

Entonces una función como esta aquí servirá. La lista es solo para tener algunos datos para probar.

    public void Group()
    {
        List<Tuple<int, int>> SongRelations = new List<Tuple<int, int>>();

        SongRelations.Add(new Tuple<int, int>(1, 1));
        SongRelations.Add(new Tuple<int, int>(1, 4));
        SongRelations.Add(new Tuple<int, int>(1, 12));
        SongRelations.Add(new Tuple<int, int>(2, 95));

        var list = SongRelations.GroupBy(s => s.Item1)
                                .Select(r => new SongsForUser()
                                {
                                    UserId = r.Key,
                                    Songs = r.Select(t => t.Item2).ToList(),
                                });
    }

list contiene 2 elementos de tipo SongsForUser después. Uno con el usuario 1 y una lista de canciones que contienen 1, 4 y 12 y otro con el usuario 2 y una lista de canciones que contienen 95.

Answer 2

Sospecho que quieres:

var songsByUser = songs.UserSongs
                       .GroupBy(song => song.UserId, song => song.SongId)
                       .Select(g => new SongsForUser { User = g.Key,
                                                       Songs = g.ToList() });

Para explicar, después de GroupBy tendrás un grupo de grupos, donde la clave de cada grupo es la ID de usuario y los valores dentro del grupo son las ID de canciones:

Key = 1, Values = 1, 4, 12
Key = 2, Value = 95

Entonces solo estás convirtiendo eso en tu tipo SongsForUser . Tenga en cuenta que no necesita incluir explícitamente el () al llamar al constructor en un inicializador de objetos, es implícito a menos que necesite especificar los argumentos del constructor.

Podrías hacer todo esto en una llamada GroupBy , por cierto:

var songsByUser = songs.UserSongs
         .GroupBy(song => song.UserId, song => song.SongId,
                  (user, ids) => new SongsForUser { User = user,
                                                    Songs = ids.ToList() });

Personalmente, generalmente encuentro que una llamada Select separada es más legible.

También puedes hacer todo esto con una expresión de consulta:

var songsByUser = from song in songs.UserSongs
                  group song.SongId by song.UserId into g
                  select new SongsForUser { User = g.Key, Songs = g.ToList() };

EDITAR: Lo anterior es "proveedor neutral" pero parece que no está funcionando con LINQ para Entidades. Es posible que puedas hacer que funcione así:

var songsByUser = songs.UserSongs
                       .GroupBy(song => song.UserId, song => song.SongId)
                       .AsEnumerable()
                       .Select(g => new SongsForUser { User = g.Key,
                                                       Songs = g.ToList() });

La llamada AsEnumerable obligará a que la agrupación se realice en la base de datos, pero la proyección final (incluida la llamada ToList ) se realizará localmente. Sin embargo, debe comprobar la eficacia del SQL generado.

Answer 3

songs.UserSongs.GroupBy(x => x.User).Select(g => new SongsForUser() 
{ 
    User = g.Key,
    Songs = g.Select(s => s.SongId).ToList()
});