Unterschied zwischen Select und SelectMany

Habe ich gesucht, die den Unterschied zwischen Select und SelectMany aber ich habe nicht in der Lage zu finden, eine passende Antwort. Ich muss lernen, den Unterschied bei der Verwendung von LINQ To SQL aber alle die ich gefunden habe, sind standard-array-Beispiele.

Kann jemand bieten eine LINQ To SQL-Beispiel?

InformationsquelleAutor der Frage Tarik | 2009-06-06

c#linq linq-to-sql

SelectMany flacht Abfragen zurückgeben von Listen von Listen. Zum Beispiel

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 .NETTO-Fiddle

InformationsquelleAutor der Antwort Mike Two

141

Wählen viele wie cross join-operation in SQLwo es das Kreuz-Produkt.

Zum Beispiel, wenn wir
```
Set A={a,b,c}
Set B={x,y}
```
Wählen viele können verwendet werden, um den folgenden Satz
```
{ (x,a) , (x,b) , (x,c) , (y,a) , (y,b) , (y,c) }
```
Beachten Sie, dass wir das hier nehmen alle möglichen Kombinationen aus den Elementen von set A und set B.

Hier ist eine LINQ-Beispiel können Sie versuchen,
```
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 mit folgenden Elementen in flachen Struktur wie
```
{(10,cat), (10,dog), (10,donkey), (20,cat), (20,dog), (20,donkey)}
```
InformationsquelleAutor der Antwort Sriwantha Attanayake

Unterschied zwischen Select und SelectMany

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

foreach(var player in players)
{
    Console.WriteLine( player.LastName);
}

Ronaldo
Messi
Fabregas
Bale
Casillas

...

InformationsquelleAutor der Antwort AlejandroR

66

SelectMany() können Sie collapse eine mehrdimensionale Sequenz in einer Weise, die sonst erfordern würde ein zweites Select() oder Schleife.

Mehr details zu diesem blog-post.

InformationsquelleAutor der Antwort Michael Petrotta

Gibt es mehrere überladungen zu SelectMany. Einer von Ihnen erlaubt Ihnen, zu halten Spur von jede Beziehung zwischen Elternteil und Kindern während der Traversierung der Hierarchie.

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

Können Sie einfach wieder einen flachen Sammlung von Spielern. Jedoch können Sie verlieren jeden Bezug auf das team, der Spieler Teil.

Glücklicherweise gibt es eine überlastung, die 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 
                                   };

Vorherigen Beispiel ist entnommen aus Dan die IK-blog. Ich empfehle Ihnen dringend einen Blick drauf werfen.

InformationsquelleAutor der Antwort

Verstehe ich SelectMany funktioniert wie eine join-Verknüpfung.

So können Sie:

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

InformationsquelleAutor der Antwort Nathan Koop

12

Wählen Sie eine einfache eins-zu-eins-Projektion von Quell-element zu einem Ergebnis-element. Wählen Sie-
Viele wird verwendet, wenn es mehrere from-Klauseln in der Abfrage-Ausdrucks: jedes element in der ursprünglichen Sequenz, die verwendet wird zum erzeugen einer neuen Sequenz.

InformationsquelleAutor der Antwort Alexandr
7

Einige SelectMany nicht notwendig sein. Unten 2 Abfragen das gleiche Ergebnis.
```
Customers.Where(c=>c.Name=="Tom").SelectMany(c=>c.Orders)

Orders.Where(o=>o.Customer.Name=="Tom")
```
Für 1-zu-Viele-Beziehung,
1. wenn Start von "1", SelectMany benötigt wird, flacht sich das viele.
2. wenn Start von "Vielen", SelectMany ist nicht erforderlich. (noch in der Lage sein, um den filter von "1"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
```
InformationsquelleAutor der Antwort Rm558

Ohne zu technisch - Datenbank mit vielen Organisationen mit vielen Nutzern:-

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 zurück die gleichen ApplicationUser Liste für die ausgewählte Organisation.

Den ersten "Projekte" von der Organisation-Benutzer, der zweite fragt den Benutzer Tabelle direkt.

InformationsquelleAutor der Antwort RickL

2

Nur für eine Alternative Ansicht, die helfen können, einige funktionale Programmierer, die es gibt:
- Select ist map
- SelectMany ist bind (oder flatMap für Ihre Scala/Kotlin Menschen)
InformationsquelleAutor der Antwort Matt Klein
1

Es ist mehr klar, wenn die Abfrage eine Zeichenkette (array von char):

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

'Select' liefert den string:
```
Fruits.Select(s=>s) 

[0]: "apple"
```
'SelectMany' flacht die Zeichenfolge:
```
Fruits.SelectMany(s=>s)

[0]: 97  'a'
[1]: 112 'p'
[2]: 112 'p'
[3]: 108 'l'
[4]: 101 'e'
```
InformationsquelleAutor der Antwort Eric Bole-Feysot

-3

Es ist der beste Weg, um zu verstehen, denke ich.

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

Einmaleins Beispiel.

InformationsquelleAutor der Antwort user5966157

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.