Diferencia entre seleccionar y seleccionar muchos
He estado buscando la diferencia entre Selecty SelectManypero no he podido encontrar una respuesta adecuada. Necesito aprender la diferencia al usar LINQ To SQL, pero todo lo que encontré son ejemplos de matrices estándar.
¿Alguien puede proporcionar un ejemplo de LINQ To SQL?
SelectManyaplana consultas que devuelven listas de listas. Por ejemplo
public class PhoneNumber
{
public string Number { get; set; }
}
public class Person
{
public IEnumerable<PhoneNumber> PhoneNumbers { get; set; }
public string Name { get; set; }
}
IEnumerable<Person> people = new List<Person>();
// Select gets a list of lists of phone numbers
IEnumerable<IEnumerable<PhoneNumber>> phoneLists = people.Select(p => p.PhoneNumbers);
// SelectMany flattens it to just a list of phone numbers.
IEnumerable<PhoneNumber> phoneNumbers = people.SelectMany(p => p.PhoneNumbers);
// And to include data from the parent in the result:
// pass an expression to the second parameter (resultSelector) in the overload:
var directory = people
.SelectMany(p => p.PhoneNumbers,
(parent, child) => new { parent.Name, child.Number });
Demostración en vivo en .NET Fiddle
Seleccionar muchos es como una operación de unión cruzada en SQL donde toma el producto cruzado.
Por ejemplo si tenemos
Set A={a,b,c}
Set B={x,y}
Seleccionar muchos se puede usar para obtener el siguiente conjunto
{ (x,a) , (x,b) , (x,c) , (y,a) , (y,b) , (y,c) }
Tenga en cuenta que aquí tomamos todas las combinaciones posibles que se pueden hacer a partir de los elementos del conjunto A y del conjunto B.
Aquí hay un ejemplo de LINQ que puedes probar
List<string> animals = new List<string>() { "cat", "dog", "donkey" };
List<int> number = new List<int>() { 10, 20 };
var mix = number.SelectMany(num => animals, (n, a) => new { n, a });
la mezcla tendrá los siguientes elementos en estructura plana como
{(10,cat), (10,dog), (10,donkey), (20,cat), (20,dog), (20,donkey)}
var players = db.SoccerTeams.Where(c => c.Country == "Spain")
.SelectMany(c => c.players);
foreach(var player in players)
{
Console.WriteLine(player.LastName);
}
- De Gea
- Alba
- Costa
- Villa
- Busquets
...
SelectMany()le permite colapsar una secuencia multidimensional de una manera que de otro modo requeriría un segundo Select()bucle.
Más detalles en esta publicación de blog .
Hay varias sobrecargas SelectMany. Uno de ellos le permite realizar un seguimiento de cualquier relación entre padres e hijos mientras recorre la jerarquía.
Ejemplo : supongamos que tiene la siguiente estructura: League -> Teams -> Player.
Puedes devolver fácilmente una colección plana de jugadores. Sin embargo puedes perder cualquier referencia al equipo del que forma parte el jugador.
Afortunadamente existe una sobrecarga para tal fin:
var teamsAndTheirLeagues =
from helper in leagues.SelectMany
( l => l.Teams
, ( league, team ) => new { league, team } )
where helper.team.Players.Count > 2
&& helper.league.Teams.Count < 10
select new
{ LeagueID = helper.league.ID
, Team = helper.team
};
El ejemplo anterior está tomado del blog IK de Dan . Te recomiendo encarecidamente que le eches un vistazo.
