Question Différence entre Select et SelectMany


J'ai cherché la différence entre Select et SelectMany mais je n'ai pas été capable de trouver une réponse appropriée. J'ai besoin d'apprendre la différence en utilisant LINQ To SQL mais tout ce que j'ai trouvé sont des exemples de tableaux standard.

Quelqu'un peut-il fournir un exemple LINQ To SQL?


796
2018-06-06 03:54


origine


Réponses:


SelectMany aplatit les requêtes qui renvoient des listes de listes. Par exemple

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 });

Démo en direct sur .NET Fiddle


1283
2018-06-06 05:23



Sélectionnez beaucoup est comme opération de jointure croisée dans SQL où il prend le produit croisé.
Par exemple si nous avons

Set A={a,b,c}
Set B={x,y}

Sélectionnez plusieurs peuvent être utilisés pour obtenir le jeu suivant

{ (x,a) , (x,b) , (x,c) , (y,a) , (y,b) , (y,c) }

Notez que nous prenons ici toutes les combinaisons possibles qui peuvent être faites à partir des éléments de l'ensemble A et de l'ensemble B.

Voici un exemple LINQ que vous pouvez essayer

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 });

le mélange aura les éléments suivants dans la structure plane comme

{(10,cat), (10,dog), (10,donkey), (20,cat), (20,dog), (20,donkey)}

142
2017-10-23 16:37



enter image description here

var players = db.SoccerTeams.Where( c=> c.Country == "Spain")
                            .SelectMany( c => c.players);

foreach(var player in players)
{
    Console.WriteLine( player.LastName);
}
  1. Ronaldo
  2. Messi
  3. Fabregas
  4. Balle
  5. Casillas

...


81
2017-10-30 18:31



SelectMany() vous permet de réduire une séquence multidimensionnelle d'une manière qui nécessiterait sinon une seconde Select() ou boucle.

Plus de détails à ce sujet article de blog.


66
2018-06-06 04:42



Il y a plusieurs surcharges à SelectMany. L'un d'entre eux vous permet de garder trace de toute relation entre parent et enfant tout en traversant la hiérarchie.

Exemple: supposons que vous avez la structure suivante: League -> Teams -> Player.

Vous pouvez facilement retourner une collection de joueurs à plat. Cependant, vous pouvez perdre toute référence à l'équipe dont le joueur fait partie.

Heureusement, il y a une surcharge à cette 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 
                                   };

L'exemple précédent est tiré de Le blog IK de Dan. Je vous recommande fortement de le regarder.


31
2018-06-06 04:04



Je comprends que SelectMany fonctionne comme un raccourci de jointure.

Afin que vous puissiez:

var orders = customers
             .Where(c => c.CustomerName == "Acme")
             .SelectMany(c => c.Orders);

18
2017-09-25 09:32



Select est une projection un-à-un simple de l'élément source à un élément résultat. Sélectionner- Plusieurs sont utilisés lorsqu'il existe plusieurs clauses from dans une expression de requête: chaque élément de la séquence d'origine est utilisé pour générer une nouvelle séquence.


12
2017-08-27 19:52



Certains SelectMany peuvent ne pas être nécessaires. En dessous de 2 requêtes donnent le même résultat.

Customers.Where(c=>c.Name=="Tom").SelectMany(c=>c.Orders)

Orders.Where(o=>o.Customer.Name=="Tom")

Pour une relation 1-à-plusieurs,

  1. Si Start from "1", SelectMany est nécessaire, il aplatit le nombre.
  2. Si Start from "Many", SelectMany n'est pas nécessaire. (encore être en mesure de filtrer de "1", c'est aussi plus simple que sous la requête de jointure standard)

from o in Orders
join c in Customers on o.CustomerID equals c.ID
where c.Name == "Tom"
select o

7
2018-03-11 15:35