c# - example - selectmany vb




Differenza tra Select e SelectMany (9)

È il modo migliore per capire penso.

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

Esempio di tabella di moltiplicazione.

Ho cercato la differenza tra Select e SelectMany ma non sono stato in grado di trovare una risposta adeguata. Devo imparare la differenza quando uso LINQ to SQL, ma tutto quello che ho trovato sono esempi di array standard.

Qualcuno può fornire un esempio LINQ To SQL?


È più chiaro quando la query restituisce una stringa (una matrice di caratteri):

Ad esempio se l'elenco "Frutta" contiene "mela"

'Seleziona' restituisce la stringa:

Fruits.Select(s=>s) 

[0]: "apple"

'SelectMany' appiattisce la stringa:

Fruits.SelectMany(s=>s)

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

Capisco che SelectMany funzioni come una scorciatoia di join.

Così puoi:

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

Ci sono diversi sovraccarichi per SelectMany . Uno di questi ti consente di tenere traccia di qualsiasi relazione tra genitore e figli mentre attraversi la gerarchia.

Esempio : supponiamo di avere la seguente struttura: League -> Teams -> Player .

Puoi facilmente restituire una collezione di giocatori piatta. Tuttavia potresti perdere ogni riferimento alla squadra di cui il giocatore fa parte.

Fortunatamente c'è un sovraccarico per tale scopo:

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'esempio precedente è tratto dal blog di IK di Dan . Vi consiglio vivamente di dargli un'occhiata.


Selezionare molti è come un'operazione di unione incrociata in SQL in cui prende il prodotto incrociato.
Per esempio se abbiamo

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

Selezionare molti possono essere utilizzati per ottenere il seguente set

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

Nota che qui prendiamo tutte le possibili combinazioni che possono essere fatte dagli elementi del set A e del set B.

Ecco un esempio LINQ che puoi provare

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

il mix avrà i seguenti elementi in struttura piatta come

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

Senza diventare troppo tecnico - database con molte organizzazioni, ognuna con molti utenti: -

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

entrambi restituiscono lo stesso elenco ApplicationUser per l'organizzazione selezionata.

I primi "progetti" da Organizzazione a Utenti, il secondo interroga direttamente la tabella Utenti.


Un altro esempio di come SelectMany + Select può essere utilizzato per accumulare dati sugli oggetti subarray.

Supponiamo di avere utenti con questi telefoni:

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

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

Ora dobbiamo selezionare tutti i telefoni di BaseParts di tutti gli utenti:

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

SelectMany() ti consente di comprimere una sequenza multidimensionale in un modo che altrimenti richiederebbe un secondo Select() o loop.

Maggiori dettagli in questo post del blog .


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

...





linq