Frage Unterschied zwischen Select und SelectMany


Ich habe den Unterschied zwischen gesucht Select und SelectMany aber ich konnte keine passende Antwort finden. Ich muss den Unterschied lernen, wenn ich LINQ To SQL benutze, aber alles, was ich gefunden habe, sind Standard-Array-Beispiele.

Kann jemand ein LINQ To SQL-Beispiel bereitstellen?


796
2018-06-06 03:54


Ursprung


Antworten:


SelectMany flacht Abfragen ab, die Listen mit Listen zurückgeben. Beispielsweise

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

Live Demo auf .NET Fiddle


1283
2018-06-06 05:23



Wählen Sie viele ist wie Cross-Join-Operation in SQL wo es das Kreuzprodukt nimmt.
Zum Beispiel wenn wir haben

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

Wählen Sie viele, um den folgenden Satz zu erhalten

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

Beachten Sie, dass hier alle möglichen Kombinationen aus den Elementen von Menge A und Menge B genommen werden.

Hier ist ein LINQ-Beispiel, das Sie ausprobieren können

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

Die Mischung wird folgende Elemente in einer flachen Struktur haben

{(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. Ballen
  5. Casillas

...


81
2017-10-30 18:31



SelectMany() lässt Sie eine mehrdimensionale Sequenz auf eine Weise zusammenbrechen, die sonst eine Sekunde benötigen würde Select() oder Schleife.

Mehr Details dazu Blogeintrag.


66
2018-06-06 04:42



Es gibt mehrere Überlastungen zu SelectMany. Eine davon ermöglicht es Ihnen, die Beziehung zwischen Eltern und Kindern zu verfolgen, während Sie die Hierarchie durchlaufen.

Beispiel: Angenommen, Sie haben folgende Struktur: League -> Teams -> Player.

Sie können einfach eine flache Sammlung von Spielern zurückgeben. Sie können jedoch jeden Hinweis auf die Mannschaft verlieren, zu der der Spieler gehört.

Glücklicherweise gibt es eine Überlastung für diesen Zweck:

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

Das vorherige Beispiel stammt aus Dans IK-Blog. Ich empfehle dringend, einen Blick darauf zu werfen.


31
2018-06-06 04:04



Ich verstehe SelectMany, um wie eine Verknüpfungsverknüpfung zu funktionieren.

Also kannst du:

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

18
2017-09-25 09:32



Auswahl ist eine einfache Eins-zu-Eins-Projektion vom Quellelement zu einem Ergebniselement. Wählen- Viele werden verwendet, wenn mehrere Aus-Klauseln in einem Abfrageausdruck vorhanden sind: Jedes Element in der ursprünglichen Sequenz wird zum Generieren einer neuen Sequenz verwendet.


12
2017-08-27 19:52



Einige SelectMany sind möglicherweise nicht erforderlich. Unter 2 Abfragen geben das gleiche Ergebnis.

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

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

Für eine 1: n-Beziehung,

  1. Wenn Start von "1", wird SelectMany benötigt, es flacht die Vielen ab.
  2. Wenn Start von "Viele", wird SelectMany nicht benötigt. (kann immer noch von "1" filtern, auch das ist einfacher als unter Standard-Join-Abfrage)

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



Ohne zu technisch zu werden - Datenbank mit vielen Organisationen, jede mit vielen Benutzern: -

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

beide kehren zurück das Gleiche ApplicationUser-Liste für die ausgewählte Organisation.

Die ersten "Projekte" von Organisation zu Benutzern, der zweite fragt die Tabelle Benutzer direkt ab.


3
2017-10-12 07:47



Nur für eine alternative Ansicht, die einigen funktionalen Programmierern da draußen helfen kann:

  • Select ist map
  • SelectMany ist bind (oder flatMap für deine Scala / Kotlin Leute)

2
2017-09-14 13:56



Es ist klarer, wenn die Abfrage eine Zeichenfolge zurückgibt (ein char-Array):

Zum Beispiel, wenn die Liste 'Früchte' 'Apfel' enthält

'Select' gibt den String zurück:

Fruits.Select(s=>s) 

[0]: "apple"

'SelectMany' flacht die Zeichenfolge ab:

Fruits.SelectMany(s=>s)

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

1
2018-02-23 02:11