Queryable.SelectMany Méthode

Définition

Projette chaque élément d'une séquence sur un IEnumerable<T> et combine les séquences résultantes en une séquence de type IQueryable<T>.Projects each element of a sequence to an IEnumerable<T> and combines the resulting sequences into one sequence of type IQueryable<T>.

Surcharges

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

Projette chaque élément d'une séquence en un IEnumerable<T> qui incorpore l'index de l'élément source qui l'a produit.Projects each element of a sequence to an IEnumerable<T> that incorporates the index of the source element that produced it. Une fonction de sélecteur du résultat est appelée sur chaque élément de chaque séquence intermédiaire, et les valeurs résultantes sont combinées en une séquence unique, unidimensionnelle et retournées.A result selector function is invoked on each element of each intermediate sequence, and the resulting values are combined into a single, one-dimensional sequence and returned.

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

Projette chaque élément d'une séquence sur un IEnumerable<T> et appelle une fonction du sélecteur de résultat sur chaque élément obtenu.Projects each element of a sequence to an IEnumerable<T> and invokes a result selector function on each element therein. Les valeurs résultantes de chaque séquence intermédiaire sont combinées en une séquence unique, unidimensionnelle et retournées.The resulting values from each intermediate sequence are combined into a single, one-dimensional sequence and returned.

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

Projette chaque élément d'une séquence sur un IEnumerable<T> et combine les séquences résultantes en une séquence.Projects each element of a sequence to an IEnumerable<T> and combines the resulting sequences into one sequence. L'index de chaque élément source est utilisé dans le formulaire projeté de l'élément.The index of each source element is used in the projected form of that element.

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

Projette chaque élément d'une séquence sur un IEnumerable<T> et combine les séquences résultantes en une séquence.Projects each element of a sequence to an IEnumerable<T> and combines the resulting sequences into one sequence.

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

Projette chaque élément d'une séquence en un IEnumerable<T> qui incorpore l'index de l'élément source qui l'a produit.Projects each element of a sequence to an IEnumerable<T> that incorporates the index of the source element that produced it. Une fonction de sélecteur du résultat est appelée sur chaque élément de chaque séquence intermédiaire, et les valeurs résultantes sont combinées en une séquence unique, unidimensionnelle et retournées.A result selector function is invoked on each element of each intermediate sequence, and the resulting values are combined into a single, one-dimensional sequence and returned.

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

Paramètres de type

TSource

Le type des éléments de source.The type of the elements of source.

TCollection

Type des éléments intermédiaires rassemblé par la fonction représentée par collectionSelector.The type of the intermediate elements collected by the function represented by collectionSelector.

TResult

Type des éléments de la séquence résultante.The type of the elements of the resulting sequence.

Paramètres

source
IQueryable<TSource>

Séquence de valeurs à projeter.A sequence of values to project.

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

Fonction de projection à appliquer à chaque élément de la séquence d'entrée ; le deuxième paramètre de cette fonction représente l'index de l'élément source.A projection function to apply to each element of the input sequence; the second parameter of this function represents the index of the source element.

resultSelector
Expression<Func<TSource,TCollection,TResult>>

Fonction de projection à appliquer à chaque élément de chaque séquence intermédiaire.A projection function to apply to each element of each intermediate sequence.

Retours

IQueryable<TResult>

IQueryable<T> dont les éléments sont le résultat de l'appel de la fonction de projection un-à-plusieurs collectionSelector sur chaque élément de source puis du mappage de chacun de ces éléments de séquence et de leur élément source correspondant en un élément de résultat.An IQueryable<T> whose elements are the result of invoking the one-to-many projection function collectionSelector on each element of source and then mapping each of those sequence elements and their corresponding source element to a result element.

Exceptions

source ou collectionSelector ou resultSelector a la valeur null.source or collectionSelector or resultSelector is null.

Remarques

Cette méthode a au moins un paramètre de type Expression<TDelegate> dont l’argument de type est l’un des Func<T,TResult> types.This method has at least one parameter of type Expression<TDelegate> whose type argument is one of the Func<T,TResult> types. Pour ces paramètres, vous pouvez passer une expression lambda et elle sera compilée dans un Expression<TDelegate> .For these parameters, you can pass in a lambda expression and it will be compiled to an Expression<TDelegate>.

La SelectMany<TSource,TCollection,TResult>(IQueryable<TSource>, Expression<Func<TSource,Int32,IEnumerable<TCollection>>>, Expression<Func<TSource,TCollection,TResult>>) méthode génère un MethodCallExpression qui représente l’appel de SelectMany<TSource,TCollection,TResult>(IQueryable<TSource>, Expression<Func<TSource,Int32,IEnumerable<TCollection>>>, Expression<Func<TSource,TCollection,TResult>>) lui-même comme une méthode générique construite.The SelectMany<TSource,TCollection,TResult>(IQueryable<TSource>, Expression<Func<TSource,Int32,IEnumerable<TCollection>>>, Expression<Func<TSource,TCollection,TResult>>) method generates a MethodCallExpression that represents calling SelectMany<TSource,TCollection,TResult>(IQueryable<TSource>, Expression<Func<TSource,Int32,IEnumerable<TCollection>>>, Expression<Func<TSource,TCollection,TResult>>) itself as a constructed generic method. Il passe ensuite MethodCallExpression à la CreateQuery(Expression) méthode de IQueryProvider représenté par la Provider propriété du source paramètre.It then passes the MethodCallExpression to the CreateQuery(Expression) method of the IQueryProvider represented by the Provider property of the source parameter.

Le comportement de la requête qui se produit suite à l’exécution d’une arborescence d’expressions qui représente l’appel de SelectMany<TSource,TCollection,TResult>(IQueryable<TSource>, Expression<Func<TSource,Int32,IEnumerable<TCollection>>>, Expression<Func<TSource,TCollection,TResult>>) dépend de l’implémentation du type du source paramètre.The query behavior that occurs as a result of executing an expression tree that represents calling SelectMany<TSource,TCollection,TResult>(IQueryable<TSource>, Expression<Func<TSource,Int32,IEnumerable<TCollection>>>, Expression<Func<TSource,TCollection,TResult>>) depends on the implementation of the type of the source parameter. Le comportement attendu est qu’il appelle collectionSelector sur chaque élément de source pour le projeter dans un formulaire énumérable.The expected behavior is that it invokes collectionSelector on each element of source to project it into an enumerable form. Chaque résultat énumérable incorpore l’index de l’élément source.Each enumerable result incorporates the source element's index. La fonction représentée par resultSelector est appelée sur chaque élément de chaque séquence intermédiaire.Then the function represented by resultSelector is invoked on each element in each intermediate sequence. Les valeurs résultantes sont concaténées en une seule séquence unidimensionnelle.The resulting values are concatenated into a single, one-dimensional sequence.

S’applique à

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

Projette chaque élément d'une séquence sur un IEnumerable<T> et appelle une fonction du sélecteur de résultat sur chaque élément obtenu.Projects each element of a sequence to an IEnumerable<T> and invokes a result selector function on each element therein. Les valeurs résultantes de chaque séquence intermédiaire sont combinées en une séquence unique, unidimensionnelle et retournées.The resulting values from each intermediate sequence are combined into a single, one-dimensional sequence and returned.

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

Paramètres de type

TSource

Le type des éléments de source.The type of the elements of source.

TCollection

Type des éléments intermédiaires rassemblé par la fonction représentée par collectionSelector.The type of the intermediate elements collected by the function represented by collectionSelector.

TResult

Type des éléments de la séquence résultante.The type of the elements of the resulting sequence.

Paramètres

source
IQueryable<TSource>

Séquence de valeurs à projeter.A sequence of values to project.

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

Fonction de projection à appliquer à chaque élément de la séquence d'entrée.A projection function to apply to each element of the input sequence.

resultSelector
Expression<Func<TSource,TCollection,TResult>>

Fonction de projection à appliquer à chaque élément de chaque séquence intermédiaire.A projection function to apply to each element of each intermediate sequence.

Retours

IQueryable<TResult>

IQueryable<T> dont les éléments sont le résultat de l'appel de la fonction de projection un-à-plusieurs collectionSelector sur chaque élément de source puis du mappage de chacun de ces éléments de séquence et de leur élément source correspondant en un élément de résultat.An IQueryable<T> whose elements are the result of invoking the one-to-many projection function collectionSelector on each element of source and then mapping each of those sequence elements and their corresponding source element to a result element.

Exceptions

source ou collectionSelector ou resultSelector a la valeur null.source or collectionSelector or resultSelector is null.

Exemples

L’exemple de code suivant montre comment utiliser SelectMany<TSource,TCollection,TResult>(IQueryable<TSource>, Expression<Func<TSource,IEnumerable<TCollection>>>, Expression<Func<TSource,TCollection,TResult>>) pour effectuer une projection un-à-plusieurs sur un tableau.The following code example demonstrates how to use SelectMany<TSource,TCollection,TResult>(IQueryable<TSource>, Expression<Func<TSource,IEnumerable<TCollection>>>, Expression<Func<TSource,TCollection,TResult>>) to perform a one-to-many projection over an array. Cet exemple utilise une fonction de sélection de résultat pour conserver l’élément source qui correspond à chaque séquence intermédiaire dans la portée pour l’appel final à Select .This example uses a result selector function to keep the source element that corresponds to each intermediate sequence in scope for the final call to Select.

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

class Pet
{
    public string Name { get; set; }
    public string Breed { get; set; }
}

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

    // This query demonstrates how to obtain a sequence of
    // the names of all the pets whose breed is "Collie", while
    // keeping an association with the owner that owns the pet.
    var query =
        petOwners.AsQueryable()
        // Create a sequence of ALL the Pet objects. Then
        // project an anonymous type that consists of each
        // Pet in the new sequence and the PetOwner object
        // from the initial array that corresponds to that pet.
       .SelectMany(owner => owner.Pets,
                   (owner, pet) => new { owner, pet })
        // Filter the sequence of anonymous types to only
        // keep pets whose breed is "Collie".
        .Where(ownerAndPet => ownerAndPet.pet.Breed == "Collie")
        // Project an anonymous type that consists
        // of the pet owner's name and the pet's name.
        .Select(ownerAndPet => new
        {
            Owner = ownerAndPet.owner.Name,
            Pet = ownerAndPet.pet.Name
        });

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

/* This code produces the following output:

    { Owner = Ashkenazi, Pet = Walker }
    { Owner = Price, Pet = Diesel }
    { Owner = Hines, Pet = Dusty }
*/

Structure PetOwner
    Public Name As String
    Public Pets As List(Of Pet)
End Structure

Structure Pet
    Public Name As String
    Public Breed As String
End Structure

Shared Sub SelectManyEx3()
    Dim petOwners() As PetOwner = _
                {New PetOwner With {.Name = "Higa", _
                      .Pets = New List(Of Pet)(New Pet() { _
                          New Pet With {.Name = "Scruffy", .Breed = "Poodle"}, _
                          New Pet With {.Name = "Sam", .Breed = "Hound"}})}, _
                  New PetOwner With {.Name = "Ashkenazi", _
                      .Pets = New List(Of Pet)(New Pet() { _
                          New Pet With {.Name = "Walker", .Breed = "Collie"}, _
                          New Pet With {.Name = "Sugar", .Breed = "Poodle"}})}, _
                  New PetOwner With {.Name = "Price", _
                      .Pets = New List(Of Pet)(New Pet() { _
                          New Pet With {.Name = "Scratches", .Breed = "Dachshund"}, _
                          New Pet With {.Name = "Diesel", .Breed = "Collie"}})}, _
                  New PetOwner With {.Name = "Hines", _
                      .Pets = New List(Of Pet)(New Pet() { _
                          New Pet With {.Name = "Dusty", .Breed = "Collie"}})} _
                }

    ' This query demonstrates how to obtain a sequence of
    ' the names of all the pets whose breed is "Collie", while
    ' keeping an association with the owner that owns the pet.
    Dim query = petOwners.AsQueryable() _
        .SelectMany(Function(owner) owner.Pets, _
               Function(owner, pet) New With {owner, pet}) _
        .Where(Function(ownerAndPet) ownerAndPet.pet.Breed = "Collie") _
        .Select(Function(ownerAndPet) New With { _
            .Owner = ownerAndPet.owner.Name, _
            .Pet = ownerAndPet.pet.Name})

    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.
    MsgBox(output.ToString())
End Sub

' This code produces the following output:

' Owner=Ashkenazi, Pet=Walker
' Owner=Price, Pet=Diesel
' Owner=Hines, Pet=Dusty

Remarques

Cette méthode a au moins un paramètre de type Expression<TDelegate> dont l’argument de type est l’un des Func<T,TResult> types.This method has at least one parameter of type Expression<TDelegate> whose type argument is one of the Func<T,TResult> types. Pour ces paramètres, vous pouvez passer une expression lambda et elle sera compilée dans un Expression<TDelegate> .For these parameters, you can pass in a lambda expression and it will be compiled to an Expression<TDelegate>.

La SelectMany<TSource,TCollection,TResult>(IQueryable<TSource>, Expression<Func<TSource,IEnumerable<TCollection>>>, Expression<Func<TSource,TCollection,TResult>>) méthode génère un MethodCallExpression qui représente l’appel de SelectMany<TSource,TCollection,TResult>(IQueryable<TSource>, Expression<Func<TSource,IEnumerable<TCollection>>>, Expression<Func<TSource,TCollection,TResult>>) lui-même comme une méthode générique construite.The SelectMany<TSource,TCollection,TResult>(IQueryable<TSource>, Expression<Func<TSource,IEnumerable<TCollection>>>, Expression<Func<TSource,TCollection,TResult>>) method generates a MethodCallExpression that represents calling SelectMany<TSource,TCollection,TResult>(IQueryable<TSource>, Expression<Func<TSource,IEnumerable<TCollection>>>, Expression<Func<TSource,TCollection,TResult>>) itself as a constructed generic method. Il passe ensuite MethodCallExpression à la CreateQuery(Expression) méthode de IQueryProvider représenté par la Provider propriété du source paramètre.It then passes the MethodCallExpression to the CreateQuery(Expression) method of the IQueryProvider represented by the Provider property of the source parameter.

Le comportement de la requête qui se produit suite à l’exécution d’une arborescence d’expressions qui représente l’appel de SelectMany<TSource,TCollection,TResult>(IQueryable<TSource>, Expression<Func<TSource,IEnumerable<TCollection>>>, Expression<Func<TSource,TCollection,TResult>>) dépend de l’implémentation du type du source paramètre.The query behavior that occurs as a result of executing an expression tree that represents calling SelectMany<TSource,TCollection,TResult>(IQueryable<TSource>, Expression<Func<TSource,IEnumerable<TCollection>>>, Expression<Func<TSource,TCollection,TResult>>) depends on the implementation of the type of the source parameter. Le comportement attendu est qu’il appelle collectionSelector sur chaque élément de source pour le projeter dans un formulaire énumérable.The expected behavior is that it invokes collectionSelector on each element of source to project it into an enumerable form. La fonction représentée par resultSelector est appelée sur chaque élément de chaque séquence intermédiaire.Then the function represented by resultSelector is invoked on each element in each intermediate sequence. Les valeurs résultantes sont concaténées en une seule séquence unidimensionnelle.The resulting values are concatenated into a single, one-dimensional sequence.

S’applique à

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

Projette chaque élément d'une séquence sur un IEnumerable<T> et combine les séquences résultantes en une séquence.Projects each element of a sequence to an IEnumerable<T> and combines the resulting sequences into one sequence. L'index de chaque élément source est utilisé dans le formulaire projeté de l'élément.The index of each source element is used in the projected form of that element.

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

Paramètres de type

TSource

Le type des éléments de source.The type of the elements of source.

TResult

Type des éléments de la séquence retournée par la fonction représentée par selector.The type of the elements of the sequence returned by the function represented by selector.

Paramètres

source
IQueryable<TSource>

Séquence de valeurs à projeter.A sequence of values to project.

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

Fonction de projection à appliquer à chaque élément ; le deuxième paramètre de cette fonction représente l'index de l'élément source.A projection function to apply to each element; the second parameter of this function represents the index of the source element.

Retours

IQueryable<TResult>

IQueryable<T> dont les éléments sont le résultat de l'appel d'une fonction de projection d'un-à-plusieurs sur chaque élément de la séquence d'entrée.An IQueryable<T> whose elements are the result of invoking a one-to-many projection function on each element of the input sequence.

Exceptions

source ou selector est null.source or selector is null.

Exemples

L’exemple de code suivant montre comment utiliser SelectMany<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,Int32,IEnumerable<TResult>>>) pour effectuer une projection un-à-plusieurs sur un tableau et utiliser l’index de chaque élément source.The following code example demonstrates how to use SelectMany<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,Int32,IEnumerable<TResult>>>) to perform a one-to-many projection over an array and use the index of each source element.

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

    // For each PetOwner element in the source array,
    // project a sequence of strings where each string
    // consists of the index of the PetOwner element in the
    // source array and the name of each pet in PetOwner.Pets.
    IEnumerable<string> query =
        petOwners.AsQueryable()
        .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

Shared Sub SelectManyEx2()
    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"}}}

    ' For each PetOwner element in the source array,
    ' project a sequence of strings where each string
    ' consists of the index of the PetOwner element in the
    ' source array and the name of each pet in PetOwner.Pets.
    Dim query As IEnumerable(Of String) = _
        petOwners.AsQueryable() _
        .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.
    MsgBox(output.ToString())
End Sub

' This code produces the following output:
'
' 0Scruffy
' 0Sam
' 1Walker
' 1Sugar
' 2Scratches
' 2Diesel
' 3Dusty

Remarques

Cette méthode a au moins un paramètre de type Expression<TDelegate> dont l’argument de type est l’un des Func<T,TResult> types.This method has at least one parameter of type Expression<TDelegate> whose type argument is one of the Func<T,TResult> types. Pour ces paramètres, vous pouvez passer une expression lambda et elle sera compilée dans un Expression<TDelegate> .For these parameters, you can pass in a lambda expression and it will be compiled to an Expression<TDelegate>.

La SelectMany<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,Int32,IEnumerable<TResult>>>) méthode génère un MethodCallExpression qui représente l’appel de SelectMany<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,Int32,IEnumerable<TResult>>>) lui-même comme une méthode générique construite.The SelectMany<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,Int32,IEnumerable<TResult>>>) method generates a MethodCallExpression that represents calling SelectMany<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,Int32,IEnumerable<TResult>>>) itself as a constructed generic method. Il passe ensuite MethodCallExpression à la CreateQuery(Expression) méthode de IQueryProvider représenté par la Provider propriété du source paramètre.It then passes the MethodCallExpression to the CreateQuery(Expression) method of the IQueryProvider represented by the Provider property of the source parameter.

Le comportement de la requête qui se produit suite à l’exécution d’une arborescence d’expressions qui représente l’appel de SelectMany<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,Int32,IEnumerable<TResult>>>) dépend de l’implémentation du type du source paramètre.The query behavior that occurs as a result of executing an expression tree that represents calling SelectMany<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,Int32,IEnumerable<TResult>>>) depends on the implementation of the type of the source parameter. Le comportement attendu est qu’il appelle selector sur chaque élément de source pour le projeter dans un formulaire énumérable.The expected behavior is that it invokes selector on each element of source to project it into an enumerable form. Chaque résultat énumérable incorpore l’index de l’élément source.Each enumerable result incorporates the index of the source element. Il concatène ensuite les résultats énumérables en une seule séquence unidimensionnelle.It then concatenates the enumerable results into a single, one-dimensional sequence.

S’applique à

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

Projette chaque élément d'une séquence sur un IEnumerable<T> et combine les séquences résultantes en une séquence.Projects each element of a sequence to an IEnumerable<T> and combines the resulting sequences into one sequence.

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

Paramètres de type

TSource

Le type des éléments de source.The type of the elements of source.

TResult

Type des éléments de la séquence retournée par la fonction représentée par selector.The type of the elements of the sequence returned by the function represented by selector.

Paramètres

source
IQueryable<TSource>

Séquence de valeurs à projeter.A sequence of values to project.

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

Fonction de projection à appliquer à chaque élément.A projection function to apply to each element.

Retours

IQueryable<TResult>

IQueryable<T> dont les éléments sont le résultat de l'appel d'une fonction de projection d'un-à-plusieurs sur chaque élément de la séquence d'entrée.An IQueryable<T> whose elements are the result of invoking a one-to-many projection function on each element of the input sequence.

Exceptions

source ou selector est null.source or selector is null.

Exemples

L’exemple de code suivant montre comment utiliser SelectMany<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,IEnumerable<TResult>>>) pour effectuer une projection un-à-plusieurs sur un tableau.The following code example demonstrates how to use SelectMany<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,IEnumerable<TResult>>>) to perform a one-to-many projection over an array.

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.AsQueryable().SelectMany(petOwner => petOwner.Pets);

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

    // Only one foreach loop is required to iterate through the
    // results because 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.AsQueryable().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

Shared Sub SelectManyEx1()
    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"}}}

    ' Query using SelectMany().
    Dim query1 As IEnumerable(Of String) = _
                petOwners.AsQueryable().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 shows how to use Select() instead of SelectMany().
    Dim query2 As IEnumerable(Of String()) = _
                petOwners.AsQueryable().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.
    MsgBox(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 a au moins un paramètre de type Expression<TDelegate> dont l’argument de type est l’un des Func<T,TResult> types.This method has at least one parameter of type Expression<TDelegate> whose type argument is one of the Func<T,TResult> types. Pour ces paramètres, vous pouvez passer une expression lambda et elle sera compilée dans un Expression<TDelegate> .For these parameters, you can pass in a lambda expression and it will be compiled to an Expression<TDelegate>.

La SelectMany<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,IEnumerable<TResult>>>) méthode génère un MethodCallExpression qui représente l’appel de SelectMany<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,IEnumerable<TResult>>>) lui-même comme une méthode générique construite.The SelectMany<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,IEnumerable<TResult>>>) method generates a MethodCallExpression that represents calling SelectMany<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,IEnumerable<TResult>>>) itself as a constructed generic method. Il passe ensuite MethodCallExpression à la CreateQuery(Expression) méthode de IQueryProvider représenté par la Provider propriété du source paramètre.It then passes the MethodCallExpression to the CreateQuery(Expression) method of the IQueryProvider represented by the Provider property of the source parameter.

Le comportement de la requête qui se produit suite à l’exécution d’une arborescence d’expressions qui représente l’appel de SelectMany<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,IEnumerable<TResult>>>) dépend de l’implémentation du type du source paramètre.The query behavior that occurs as a result of executing an expression tree that represents calling SelectMany<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,IEnumerable<TResult>>>) depends on the implementation of the type of the source parameter. Le comportement attendu est qu’il appelle selector sur chaque élément de source pour le projeter dans un formulaire énumérable.The expected behavior is that it invokes selector on each element of source to project it into an enumerable form. Il concatène ensuite les résultats énumérables en une seule séquence unidimensionnelle.It then concatenates the enumerable results into a single, one-dimensional sequence.

S’applique à