Cet article a fait l’objet d’une traduction automatique. Pour afficher l’article en anglais, activez la case d’option Anglais. Vous pouvez également afficher le texte anglais dans une fenêtre contextuelle en faisant glisser le pointeur de la souris sur le texte traduit.
Traduction
Anglais

Enumerable.SelectMany<TSource, TResult> méthode (IEnumerable<TSource>, Func<TSource, IEnumerable<TResult>>)

 

Date de publication : novembre 2016

Projette chaque élément d’une séquence sur un IEnumerable<T> et aplatit les séquences résultantes en une seule séquence.

Espace de noms:   System.Linq
Assembly:  System.Core (dans System.Core.dll)

public static IEnumerable<TResult> SelectMany<TSource, TResult>(
	this IEnumerable<TSource> source,
	Func<TSource, IEnumerable<TResult>> selector
)

Paramètres

source
Type: System.Collections.Generic.IEnumerable<TSource>

Séquence de valeurs à projeter.

selector
Type: System.Func<TSource, IEnumerable<TResult>>

Fonction de transformation à appliquer à chaque élément.

Valeur de retour

Type: System.Collections.Generic.IEnumerable<TResult>

Une IEnumerable<T> dont les éléments sont le résultat de l’appel de la fonction de transformation de type un-à-plusieurs sur chaque élément de la séquence d’entrée.

Paramètres de type

TSource

Le type des éléments de source.

TResult

Le type des éléments de la séquence retournée par selector.

Exception Condition
ArgumentNullException

source ou selector a la valeur null.

Cette méthode est implémentée à l’aide de l’exécution différée. L’exécution valeur de retour est un objet qui stocke toutes les informations qui sont requis pour effectuer l’action. La requête représentée par cette méthode n’est pas exécutée tant que l’objet est énumérée en appelant son GetEnumerator méthode directement ou à l’aide de foreach dans Visual C# ou For Each dans Visual Basic.

Le SelectMany<TSource, TResult>(IEnumerable<TSource>, Func<TSource, IEnumerable<TResult>>) méthode énumère la séquence d’entrée, utilise une fonction de transformation pour mapper chaque élément à un IEnumerable<T>, puis énumère et rapporte les éléments de chacun de ces IEnumerable<T> objet. Autrement dit, pour chaque élément de source, selector est appelé et une séquence de valeurs est retournée. SelectMany<TSource, TResult>(IEnumerable<TSource>, Func<TSource, IEnumerable<TResult>>) aplatit ensuite cette collection en deux dimensions de collections dans une dimension IEnumerable<T> et le retourne. Par exemple, si une requête utilise SelectMany<TSource, TResult>(IEnumerable<TSource>, Func<TSource, IEnumerable<TResult>>) pour obtenir les ordres (de type Order) pour chaque client dans une base de données, le résultat est de type IEnumerable<Order> en c# ou IEnumerable(Of Order) dans Visual Basic. Si la requête utilise à la place Select<TSource, TResult> afin d’obtenir les ordres, la collection de collections d’ordres n’est pas combinée et le résultat est de type IEnumerable<List<Order>> en c# ou IEnumerable(Of List(Of Order)) dans Visual Basic.

Dans la syntaxe d’expression de requête, chaque from clause (Visual C#) ou From clause (Visual Basic) après le premier se traduit en un appel à SelectMany<TSource, TResult>.

L’exemple de code suivant montre comment utiliser SelectMany<TSource, TResult>(IEnumerable<TSource>, Func<TSource, IEnumerable<TResult>>) pour effectuer une projection de type un-à-plusieurs sur un tableau.

class PetOwner
{
    public string Name { get; set; }
    public List<String> Pets { get; set; }
}

public static void SelectManyEx1()
{
    PetOwner[] petOwners = 
        { new PetOwner { Name="Higa, Sidney", 
              Pets = new List<string>{ "Scruffy", "Sam" } },
          new PetOwner { Name="Ashkenazi, Ronen", 
              Pets = new List<string>{ "Walker", "Sugar" } },
          new PetOwner { Name="Price, Vernette", 
              Pets = new List<string>{ "Scratches", "Diesel" } } };

    // Query using SelectMany().
    IEnumerable<string> query1 = petOwners.SelectMany(petOwner => petOwner.Pets);

    Console.WriteLine("Using SelectMany():");

    // Only one foreach loop is required to iterate 
    // through the results since it is a
    // one-dimensional collection.
    foreach (string pet in query1)
    {
        Console.WriteLine(pet);
    }

    // This code shows how to use Select() 
    // instead of SelectMany().
    IEnumerable<List<String>> query2 =
        petOwners.Select(petOwner => petOwner.Pets);

    Console.WriteLine("\nUsing Select():");

    // Notice that two foreach loops are required to 
    // iterate through the results
    // because the query returns a collection of arrays.
    foreach (List<String> petList in query2)
    {
        foreach (string pet in petList)
        {
            Console.WriteLine(pet);
        }
        Console.WriteLine();
    }
}

/*
 This code produces the following output:

 Using SelectMany():
 Scruffy
 Sam
 Walker
 Sugar
 Scratches
 Diesel

 Using Select():
 Scruffy
 Sam

 Walker
 Sugar

 Scratches
 Diesel
*/

Plateforme Windows universelle
Disponible depuis 8
.NET Framework
Disponible depuis 3.5
Bibliothèque de classes portable
Pris en charge dans : plateformes .NET portables
Silverlight
Disponible depuis 2.0
Silverlight pour Windows Phone
Disponible depuis 7.0
Windows Phone
Disponible depuis 8.1
Retour au début
Afficher: