Différence entre Select et SelectMany

J'ai cherché la différence entre Selectet SelectManymais je n'ai pas pu trouver de réponse appropriée. J'ai besoin d'apprendre la différence lors de l'utilisation de 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?

SelectManyaplatit 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

Sélectionner plusieurs, c'est comme une 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 l'ensemble 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 une structure plate comme

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

1. De Gea
2. Alba
3. Costa
4. Villa
5. Busquets

...

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

Plus de détails sur ce billet de blog .

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

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

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

Heureusement, il existe 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é du blog IK de Dan . Je vous recommande fortement d'y jeter un œil.

Je comprends que je SelectManytravaille comme un raccourci de jointure.

Afin que vous puissiez:

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

Select est une simple projection biunivoque de l'élément source vers un élément résultat. Select- Many est utilisé 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.

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 plus.
2. si Start from "Many", SelectMany n'est pas nécessaire. ( toujours pouvoir filtrer à partir de "1" , c'est aussi plus simple que ci-dessous 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

Sans devenir trop technique - base de données avec de nombreuses organisations, chacune avec de nombreux utilisateurs: -

var orgId = "123456789";

var userList1 = db.Organizations
                   .Where(a => a.OrganizationId == orgId)
                   .SelectMany(a => a.Users)
                   .ToList();

var userList2 = db.Users
                   .Where(a => a.OrganizationId == orgId)
                   .ToList();

les deux renvoient la même liste ApplicationUser pour l'organisation sélectionnée.

Le premier "projets" de l'organisation aux utilisateurs, le second interroge directement la table des utilisateurs.

Il est plus clair lorsque la requête renvoie une chaîne (un tableau de caractères):

Par exemple, si la liste «Fruits» contient «pomme»

'Select' renvoie la chaîne:

Fruits.Select(s=>s) 

[0]: "apple"

'SelectMany' aplatit la chaîne:

Fruits.SelectMany(s=>s)

[0]: 97  'a'
[1]: 112 'p'
[2]: 112 'p'
[3]: 108 'l'
[4]: 101 'e'

Juste pour une autre vue qui peut aider certains programmeurs fonctionnels:

• Select est map
• SelectManyest bind(ou flatMappour votre peuple Scala / Kotlin)

Considérez cet exemple:

        var array = new string[2]
        {
            "I like what I like",
            "I like what you like"
        };
        //query1 returns two elements sth like this:
        //fisrt element would be array[5]  :[0] = "I" "like" "what" "I" "like"
        //second element would be array[5] :[1] = "I" "like" "what" "you" "like"
        IEnumerable<string[]> query1 = array.Select(s => s.Split(' ')).Distinct();

        //query2 return back flat result sth like this :
        // "I" "like" "what" "you"
        IEnumerable<string> query2 = array.SelectMany(s => s.Split(' ')).Distinct();

Ainsi, comme vous voyez des valeurs en double comme "I" ou "j'aime" ont été supprimées de query2 parce que "SelectMany" s'aplatit et se projette sur plusieurs séquences. Mais query1 renvoie une séquence de tableaux de chaînes. et comme il y a deux tableaux différents dans query1 (premier et deuxième élément), rien ne serait supprimé.

Un autre exemple de la façon dont SelectMany + Select peut être utilisé afin d'accumuler des données d'objets de sous-tableau.

Supposons que nous ayons des utilisateurs avec leurs téléphones:

class Phone { 
    public string BasePart = "555-xxx-xxx"; 
}

class User { 
    public string Name = "Xxxxx";
    public List<Phone> Phones; 
}

Maintenant, nous devons sélectionner les BaseParts de tous les téléphones de tous les utilisateurs:

var usersArray = new List<User>(); // array of arrays
List<string> allBaseParts = usersArray.SelectMany(ua => ua.Phones).Select(p => p.BasePart).ToList();

Voici un exemple de code avec une petite collection initialisée pour les tests:

class Program
{
    static void Main(string[] args)
    {
        List<Order> orders = new List<Order>
        {
            new Order
            {
                OrderID = "orderID1",
                OrderLines = new List<OrderLine>
                {
                    new OrderLine
                    {
                        ProductSKU = "SKU1",
                        Quantity = 1
                    },
                    new OrderLine
                    {
                        ProductSKU = "SKU2",
                        Quantity = 2
                    },
                    new OrderLine
                    {
                        ProductSKU = "SKU3",
                        Quantity = 3
                    }
                }
            },
            new Order
            {
                OrderID = "orderID2",
                OrderLines = new List<OrderLine>
                {
                    new OrderLine
                    {
                        ProductSKU = "SKU4",
                        Quantity = 4
                    },
                    new OrderLine
                    {
                        ProductSKU = "SKU5",
                        Quantity = 5
                    }
                }
            }
        };

        //required result is the list of all SKUs in orders
        List<string> allSKUs = new List<string>();

        //With Select case 2 foreach loops are required
        var flattenedOrdersLinesSelectCase = orders.Select(o => o.OrderLines);
        foreach (var flattenedOrderLine in flattenedOrdersLinesSelectCase)
        {
            foreach (OrderLine orderLine in flattenedOrderLine)
            {
                allSKUs.Add(orderLine.ProductSKU);
            }
        }

        //With SelectMany case only one foreach loop is required
        allSKUs = new List<string>();
        var flattenedOrdersLinesSelectManyCase = orders.SelectMany(o => o.OrderLines);
        foreach (var flattenedOrderLine in flattenedOrdersLinesSelectManyCase)
        {
            allSKUs.Add(flattenedOrderLine.ProductSKU);
        }

       //If the required result is flattened list which has OrderID, ProductSKU and Quantity,
       //SelectMany with selector is very helpful to get the required result
       //and allows avoiding own For loops what according to my experience do code faster when
       // hundreds of thousands of data rows must be operated
        List<OrderLineForReport> ordersLinesForReport = (List<OrderLineForReport>)orders.SelectMany(o => o.OrderLines,
            (o, ol) => new OrderLineForReport
            {
                OrderID = o.OrderID,
                ProductSKU = ol.ProductSKU,
                Quantity = ol.Quantity
            }).ToList();
    }
}
class Order
{
    public string OrderID { get; set; }
    public List<OrderLine> OrderLines { get; set; }
}
class OrderLine
{
    public string ProductSKU { get; set; }
    public int Quantity { get; set; }
}
class OrderLineForReport
{
    public string OrderID { get; set; }
    public string ProductSKU { get; set; }
    public int Quantity { get; set; }
}

La SelectManyméthode fait tomber un IEnumerable<IEnumerable<T>>dans IEnumerable<T>, comme le communisme, chaque élément se comporte de la même manière (un gars stupide a les mêmes droits qu'un génie).

var words = new [] { "a,b,c", "d,e", "f" };
var splitAndCombine = words.SelectMany(x => x.Split(','));
// returns { "a", "b", "c", "d", "e", "f" }

C'est la meilleure façon de comprendre je pense.

            var query =
            Enumerable
                .Range(1, 10)
                .SelectMany(ints => Enumerable.Range(1, 10), (a, b) => $"{a} * {b} = {a * b}")
                .ToArray();

        Console.WriteLine(string.Join(Environment.NewLine, query));

        Console.Read();

Exemple de table de multiplication.