Enumerable.SelectMany Méthode

Définition

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

Surcharges

SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>)

Projette chaque élément d'une séquence sur un IEnumerable<T>, aplatit les séquences résultantes en une seule séquence et appelle une fonction de sélection de résultat sur chaque élément inclus. L'index de chaque élément source est utilisé dans le formulaire intermédiaire projeté de l'élément.

SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>)

Projette chaque élément d'une séquence sur un IEnumerable<T>, aplatit les séquences résultantes en une seule séquence et appelle une fonction de sélection de résultat sur chaque élément inclus.

SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TResult>>)

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

SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TResult>>)

Projette chaque élément d'une séquence sur un IEnumerable<T> et aplatit les séquences résultantes en une seule séquence. L'index de chaque élément source est utilisé dans le formulaire projeté de l'élément.

SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>)

Projette chaque élément d'une séquence sur un IEnumerable<T>, aplatit les séquences résultantes en une seule séquence et appelle une fonction de sélection de résultat sur chaque élément inclus. L'index de chaque élément source est utilisé dans le formulaire intermédiaire projeté de l'élément.

public:
generic <typename TSource, typename TCollection, typename TResult>
[System::Runtime::CompilerServices::Extension]
 static System::Collections::Generic::IEnumerable<TResult> ^ SelectMany(System::Collections::Generic::IEnumerable<TSource> ^ source, Func<TSource, int, System::Collections::Generic::IEnumerable<TCollection> ^> ^ collectionSelector, Func<TSource, TCollection, TResult> ^ resultSelector);
public static System.Collections.Generic.IEnumerable<TResult> SelectMany<TSource,TCollection,TResult> (this System.Collections.Generic.IEnumerable<TSource> source, Func<TSource,int,System.Collections.Generic.IEnumerable<TCollection>> collectionSelector, Func<TSource,TCollection,TResult> resultSelector);
static member SelectMany : seq<'Source> * Func<'Source, int, seq<'Collection>> * Func<'Source, 'Collection, 'Result> -> seq<'Result>
<Extension()>
Public Function SelectMany(Of TSource, TCollection, TResult) (source As IEnumerable(Of TSource), collectionSelector As Func(Of TSource, Integer, IEnumerable(Of TCollection)), resultSelector As Func(Of TSource, TCollection, TResult)) As IEnumerable(Of TResult)

Paramètres de type

TSource

Le type des éléments de source.

TCollection

Type des éléments intermédiaires collectés par collectionSelector.

TResult

Type des éléments de la séquence résultante.

Paramètres

source
IEnumerable<TSource>

Séquence de valeurs à projeter.

collectionSelector
Func<TSource,Int32,IEnumerable<TCollection>>

Fonction de transformation à appliquer à chaque élément source ; le deuxième paramètre de la fonction représente l'index de l'élément source.

resultSelector
Func<TSource,TCollection,TResult>

Fonction de transformation à appliquer à chaque élément de la séquence intermédiaire.

Retours

IEnumerable<TResult>

IEnumerable<T> dont les éléments résultent d'un appel de la fonction de transformation collectionSelector de type un-à-plusieurs sur chaque élément de source et qui mappe ensuite chaque élément de la séquence et l'élément source correspondant avec un élément de résultat.

Exceptions

source ou collectionSelector ou resultSelector a la valeur null.

Remarques

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

La SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>) méthode est utile lorsque vous devez conserver les éléments de source dans la portée pour la logique de requête qui se produit après l’appel à SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>) . Pour obtenir un exemple de code, consultez la section Exemple. S’il existe une relation bidirectionnelle entre des objets de type TSource et des objets de type TCollection , autrement dit, si un objet de type TCollection fournit une propriété pour récupérer l' TSource objet qui l’a généré, vous n’avez pas besoin de cette surcharge de SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>) . Au lieu de cela, vous pouvez utiliser SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TResult>>) et revenir à l' TSource objet via l' TCollection objet.

S’applique à

SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>)

Projette chaque élément d'une séquence sur un IEnumerable<T>, aplatit les séquences résultantes en une seule séquence et appelle une fonction de sélection de résultat sur chaque élément inclus.

public:
generic <typename TSource, typename TCollection, typename TResult>
[System::Runtime::CompilerServices::Extension]
 static System::Collections::Generic::IEnumerable<TResult> ^ SelectMany(System::Collections::Generic::IEnumerable<TSource> ^ source, Func<TSource, System::Collections::Generic::IEnumerable<TCollection> ^> ^ collectionSelector, Func<TSource, TCollection, TResult> ^ resultSelector);
public static System.Collections.Generic.IEnumerable<TResult> SelectMany<TSource,TCollection,TResult> (this System.Collections.Generic.IEnumerable<TSource> source, Func<TSource,System.Collections.Generic.IEnumerable<TCollection>> collectionSelector, Func<TSource,TCollection,TResult> resultSelector);
static member SelectMany : seq<'Source> * Func<'Source, seq<'Collection>> * Func<'Source, 'Collection, 'Result> -> seq<'Result>
<Extension()>
Public Function SelectMany(Of TSource, TCollection, TResult) (source As IEnumerable(Of TSource), collectionSelector As Func(Of TSource, IEnumerable(Of TCollection)), resultSelector As Func(Of TSource, TCollection, TResult)) As IEnumerable(Of TResult)

Paramètres de type

TSource

Le type des éléments de source.

TCollection

Type des éléments intermédiaires collectés par collectionSelector.

TResult

Type des éléments de la séquence résultante.

Paramètres

source
IEnumerable<TSource>

Séquence de valeurs à projeter.

collectionSelector
Func<TSource,IEnumerable<TCollection>>

Fonction de transformation à appliquer à chaque élément de la séquence d'entrée.

resultSelector
Func<TSource,TCollection,TResult>

Fonction de transformation à appliquer à chaque élément de la séquence intermédiaire.

Retours

IEnumerable<TResult>

IEnumerable<T> dont les éléments résultent d'un appel de la fonction de transformation collectionSelector de type un-à-plusieurs sur chaque élément de source et qui mappe ensuite chaque élément de la séquence et l'élément source correspondant avec un élément de résultat.

Exceptions

source ou collectionSelector ou resultSelector a la valeur null.

Exemples

L’exemple de code suivant montre comment utiliser SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>) pour effectuer une projection un-à-plusieurs sur un tableau et utiliser une fonction de sélection de résultat pour conserver chaque élément correspondant de la séquence source dans la portée de l’appel final à Select .

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

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

    // Project the pet owner's name and the pet's name.
    var query =
        petOwners
        .SelectMany(petOwner => petOwner.Pets, (petOwner, petName) => new { petOwner, petName })
        .Where(ownerAndPet => ownerAndPet.petName.StartsWith("S"))
        .Select(ownerAndPet =>
                new
                {
                    Owner = ownerAndPet.petOwner.Name,
                    Pet = ownerAndPet.petName
                }
        );

    // Print the results.
    foreach (var obj in query)
    {
        Console.WriteLine(obj);
    }
}

// This code produces the following output:
//
// {Owner=Higa, Pet=Scruffy}
// {Owner=Higa, Pet=Sam}
// {Owner=Ashkenazi, Pet=Sugar}
// {Owner=Price, Pet=Scratches}
Structure PetOwner
    Public Name As String
    Public Pets() As String
End Structure

Sub SelectManyEx3()
    ' Create an array of PetOwner objects.
    Dim petOwners() As PetOwner =
{New PetOwner With
 {.Name = "Higa", .Pets = New String() {"Scruffy", "Sam"}},
 New PetOwner With
 {.Name = "Ashkenazi", .Pets = New String() {"Walker", "Sugar"}},
 New PetOwner With
 {.Name = "Price", .Pets = New String() {"Scratches", "Diesel"}},
 New PetOwner With
 {.Name = "Hines", .Pets = New String() {"Dusty"}}}

    ' Project an anonymous type that consists of
    ' the owner's name and the pet's name (string).
    Dim query =
petOwners _
.SelectMany(
    Function(petOwner) petOwner.Pets,
    Function(petOwner, petName) New With {petOwner, petName}) _
.Where(Function(ownerAndPet) ownerAndPet.petName.StartsWith("S")) _
.Select(Function(ownerAndPet) _
       New With {.Owner = ownerAndPet.petOwner.Name,
                 .Pet = ownerAndPet.petName
       })

    Dim output As New System.Text.StringBuilder
    For Each obj In query
        output.AppendLine(String.Format("Owner={0}, Pet={1}", obj.Owner, obj.Pet))
    Next

    ' Display the output.
    Console.WriteLine(output.ToString())
End Sub

' This code produces the following output:
'
' Owner=Higa, Pet=Scruffy
' Owner=Higa, Pet=Sam
' Owner=Ashkenazi, Pet=Sugar
' Owner=Price, Pet=Scratches

Remarques

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

La SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>) méthode est utile lorsque vous devez conserver les éléments de source dans la portée pour la logique de requête qui se produit après l’appel à SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>) . Pour obtenir un exemple de code, consultez la section Exemple. S’il existe une relation bidirectionnelle entre des objets de type TSource et des objets de type TCollection , autrement dit, si un objet de type TCollection fournit une propriété pour récupérer l' TSource objet qui l’a généré, vous n’avez pas besoin de cette surcharge de SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>) . Au lieu de cela, vous pouvez utiliser SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TResult>>) et revenir à l' TSource objet via l' TCollection objet.

dans la syntaxe d’expression de requête, chaque from clause (Visual C#) ou From la clause (Visual Basic) après la première se traduit en un appel de SelectMany .

Voir aussi

S’applique à

SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TResult>>)

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

public:
generic <typename TSource, typename TResult>
[System::Runtime::CompilerServices::Extension]
 static System::Collections::Generic::IEnumerable<TResult> ^ SelectMany(System::Collections::Generic::IEnumerable<TSource> ^ source, Func<TSource, System::Collections::Generic::IEnumerable<TResult> ^> ^ selector);
public static System.Collections.Generic.IEnumerable<TResult> SelectMany<TSource,TResult> (this System.Collections.Generic.IEnumerable<TSource> source, Func<TSource,System.Collections.Generic.IEnumerable<TResult>> selector);
static member SelectMany : seq<'Source> * Func<'Source, seq<'Result>> -> seq<'Result>
<Extension()>
Public Function SelectMany(Of TSource, TResult) (source As IEnumerable(Of TSource), selector As Func(Of TSource, IEnumerable(Of TResult))) As IEnumerable(Of TResult)

Paramètres de type

TSource

Le type des éléments de source.

TResult

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

Paramètres

source
IEnumerable<TSource>

Séquence de valeurs à projeter.

selector
Func<TSource,IEnumerable<TResult>>

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

Retours

IEnumerable<TResult>

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

Exceptions

source ou selector est null.

Exemples

L’exemple de code suivant montre comment utiliser SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TResult>>) pour effectuer une projection 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
*/
Structure PetOwner
    Public Name As String
    Public Pets() As String
End Structure

Sub SelectManyEx1()
    ' Create an array of PetOwner objects.
    Dim petOwners() As PetOwner =
{New PetOwner With
 {.Name = "Higa, Sidney", .Pets = New String() {"Scruffy", "Sam"}},
 New PetOwner With
 {.Name = "Ashkenazi, Ronen", .Pets = New String() {"Walker", "Sugar"}},
 New PetOwner With
 {.Name = "Price, Vernette", .Pets = New String() {"Scratches", "Diesel"}}}

    ' Call SelectMany() to gather all pets into a "flat" sequence.
    Dim query1 As IEnumerable(Of String) =
petOwners.SelectMany(Function(petOwner) petOwner.Pets)

    Dim output As New System.Text.StringBuilder("Using SelectMany():" & vbCrLf)
    ' Only one foreach loop is required to iterate through 
    ' the results because it is a one-dimensional collection.
    For Each pet As String In query1
        output.AppendLine(pet)
    Next

    ' This code demonstrates how to use Select() instead 
    ' of SelectMany() to get the same result.
    Dim query2 As IEnumerable(Of String()) =
petOwners.Select(Function(petOwner) petOwner.Pets)
    output.AppendLine(vbCrLf & "Using Select():")
    ' Notice that two foreach loops are required to iterate through 
    ' the results because the query returns a collection of arrays.
    For Each petArray() As String In query2
        For Each pet As String In petArray
            output.AppendLine(pet)
        Next
    Next

    ' Display the output.
    Console.WriteLine(output.ToString())
End Sub

' This code produces the following output:
'
' Using SelectMany():
' Scruffy
' Sam
' Walker
' Sugar
' Scratches
' Diesel
'
' Using Select():
' Scruffy
' Sam
' Walker
' Sugar
' Scratches
' Diesel

Remarques

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

La 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 produit les éléments de chaque objet de ce type IEnumerable<T> . 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 à deux dimensions de collections en une unidimensionnelle IEnumerable<T> et la retourne. Par exemple, si une requête utilise SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TResult>>) pour obtenir les commandes (de type Order ) pour chaque client d’une base de données, le résultat est de type IEnumerable<Order> en C# ou IEnumerable(Of Order) dans Visual Basic. Si, à la place, la requête utilise Select pour obtenir les commandes, la collection de collections de commandes 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 la clause (Visual Basic) après la première se traduit en un appel de SelectMany .

Voir aussi

S’applique à

SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TResult>>)

Projette chaque élément d'une séquence sur un IEnumerable<T> et aplatit les séquences résultantes en une seule séquence. L'index de chaque élément source est utilisé dans le formulaire projeté de l'élément.

public:
generic <typename TSource, typename TResult>
[System::Runtime::CompilerServices::Extension]
 static System::Collections::Generic::IEnumerable<TResult> ^ SelectMany(System::Collections::Generic::IEnumerable<TSource> ^ source, Func<TSource, int, System::Collections::Generic::IEnumerable<TResult> ^> ^ selector);
public static System.Collections.Generic.IEnumerable<TResult> SelectMany<TSource,TResult> (this System.Collections.Generic.IEnumerable<TSource> source, Func<TSource,int,System.Collections.Generic.IEnumerable<TResult>> selector);
static member SelectMany : seq<'Source> * Func<'Source, int, seq<'Result>> -> seq<'Result>
<Extension()>
Public Function SelectMany(Of TSource, TResult) (source As IEnumerable(Of TSource), selector As Func(Of TSource, Integer, IEnumerable(Of TResult))) As IEnumerable(Of TResult)

Paramètres de type

TSource

Le type des éléments de source.

TResult

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

Paramètres

source
IEnumerable<TSource>

Séquence de valeurs à projeter.

selector
Func<TSource,Int32,IEnumerable<TResult>>

Fonction de transformation à appliquer à chaque élément source ; le deuxième paramètre de la fonction représente l'index de l'élément source.

Retours

IEnumerable<TResult>

IEnumerable<T> dont les éléments résultent d'un appel de la fonction de transformation de type un-à-plusieurs sur chaque élément d'une séquence d'entrée.

Exceptions

source ou selector est null.

Exemples

L’exemple de code suivant montre comment utiliser SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TResult>>) pour effectuer une projection un-à-plusieurs sur un tableau et utiliser l’index de chaque élément externe.

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

public static void SelectManyEx2()
{
    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" } },
          new PetOwner { Name="Hines, Patrick",
              Pets = new List<string>{ "Dusty" } } };

    // Project the items in the array by appending the index
    // of each PetOwner to each pet's name in that petOwner's
    // array of pets.
    IEnumerable<string> query =
        petOwners.SelectMany((petOwner, index) =>
                                 petOwner.Pets.Select(pet => index + pet));

    foreach (string pet in query)
    {
        Console.WriteLine(pet);
    }
}

// This code produces the following output:
//
// 0Scruffy
// 0Sam
// 1Walker
// 1Sugar
// 2Scratches
// 2Diesel
// 3Dusty
Structure PetOwner
    Public Name As String
    Public Pets() As String
End Structure

Sub SelectManyEx2()
    ' Create an array of PetOwner objects.
    Dim petOwners() As PetOwner =
{New PetOwner With
 {.Name = "Higa, Sidney", .Pets = New String() {"Scruffy", "Sam"}},
 New PetOwner With
 {.Name = "Ashkenazi, Ronen", .Pets = New String() {"Walker", "Sugar"}},
 New PetOwner With
 {.Name = "Price, Vernette", .Pets = New String() {"Scratches", "Diesel"}},
 New PetOwner With
 {.Name = "Hines, Patrick", .Pets = New String() {"Dusty"}}}

    ' Project the items in the array by appending the index 
    ' of each PetOwner to each pet's name in that petOwner's 
    ' array of pets.
    Dim query As IEnumerable(Of String) =
petOwners.SelectMany(Function(petOwner, index) _
                         petOwner.Pets.Select(Function(pet) _
                                                  index.ToString() + pet))

    Dim output As New System.Text.StringBuilder
    For Each pet As String In query
        output.AppendLine(pet)
    Next

    ' Display the output.
    Console.WriteLine(output.ToString())
End Sub

Remarques

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

La SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,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 produit les éléments de chaque objet de ce type IEnumerable<T> . 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,Int32,IEnumerable<TResult>>) aplatit ensuite cette collection à deux dimensions de collections en une unidimensionnelle IEnumerable<T> et la retourne. Par exemple, si une requête utilise SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TResult>>) pour obtenir les commandes (de type Order ) pour chaque client d’une base de données, le résultat est de type IEnumerable<Order> en C# ou IEnumerable(Of Order) dans Visual Basic. Si, à la place, la requête utilise Select pour obtenir les commandes, la collection de collections de commandes 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.

Le premier argument de selector représente l’élément à traiter. Le deuxième argument de selector représente l’index de base zéro de cet élément dans la séquence source. Cela peut être utile si les éléments sont dans un ordre connu et que vous souhaitez effectuer une opération avec un élément à un index particulier, par exemple. Cela peut également être utile si vous souhaitez récupérer l’index d’un ou plusieurs éléments.

S’applique à