c# linq - Différence entre Select et SelectMany




multiple fields (11)

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

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?


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. ( toujours être en mesure de filtrer à partir 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

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.


Select est une projection un-à-un simple de l'élément source à 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.


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 retournent la même liste ApplicationUser pour l'organisation sélectionnée.

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


Sélectionner plusieurs 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)}

SelectMany aplatit les requêtes SelectMany 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


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

...


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

Plus de détails sur ce blog .


Juste pour une vue alternative qui peut aider certains programmeurs fonctionnels là-bas:

  • Select est la map
  • SelectMany est bind (ou flatMap pour vos flatMap Scala / Kotlin)

ASP.net Web API est tout sur HTTP et REST basé sur GET, POST, PUT, DELETE avec le style de programmation ASP.net MVC bien connu et JSON retournable; L'API Web est destinée à tous les processus légers et aux composants purs basés sur HTTP. Pour aller de l'avant avec WCF même pour simple ou simple service web unique, il apportera tous les bagages supplémentaires. Pour un service simple et léger pour les appels ajax ou dynamiques, WebApi résout tout simplement le besoin. Cela complète parfaitement ou aide en parallèle à l'ASP.net MVC.

Découvrez le podcast: Hanselminutes Podcast 264 - Ce n'est pas la WCF de votre père - Tout sur le WebAPI avec Glenn Block par Scott Hanselman pour plus d'informations.







c# linq-to-sql linq