Queryable.SelectMany Queryable.SelectMany Queryable.SelectMany Queryable.SelectMany Method

Definizione

Proietta ogni elemento di una sequenza a un IEnumerable<T> e combina le sequenze risultanti in un'unica sequenza di tipo IQueryable<T>.Projects each element of a sequence to an IEnumerable<T> and combines the resulting sequences into one sequence of type IQueryable<T>.

Overload

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

Proietta ogni elemento di una sequenza a un IEnumerable<T> che incorpora l'indice dell'elemento di origine che l'ha prodotta.Projects each element of a sequence to an IEnumerable<T> that incorporates the index of the source element that produced it. Viene richiamata una funzione del selettore di risultato su ogni elemento di ogni sequenza intermedia e i valori risultanti vengono combinati in una singola sequenza unidimensionale e restituiti.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>>) SelectMany<TSource,TCollection,TResult>(IQueryable<TSource>, Expression<Func<TSource,IEnumerable<TCollection>>>, Expression<Func<TSource,TCollection,TResult>>) SelectMany<TSource,TCollection,TResult>(IQueryable<TSource>, Expression<Func<TSource,IEnumerable<TCollection>>>, Expression<Func<TSource,TCollection,TResult>>) SelectMany<TSource,TCollection,TResult>(IQueryable<TSource>, Expression<Func<TSource,IEnumerable<TCollection>>>, Expression<Func<TSource,TCollection,TResult>>)

Proietta ogni elemento di una sequenza a un IEnumerable<T> e richiama una funzione del selettore di risultato su ogni elemento al suo interno.Projects each element of a sequence to an IEnumerable<T> and invokes a result selector function on each element therein. I valori risultanti da ogni sequenza intermedia vengono combinati in una singola sequenza unidimensionale e restituiti.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>>>) SelectMany<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,Int32,IEnumerable<TResult>>>) SelectMany<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,Int32,IEnumerable<TResult>>>) SelectMany<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,Int32,IEnumerable<TResult>>>)

Proietta ogni elemento di una sequenza a un IEnumerable<T> e combina le sequenze risultanti in un'unica sequenza.Projects each element of a sequence to an IEnumerable<T> and combines the resulting sequences into one sequence. L'indice di ogni elemento di origine viene usato nella maschera proiettata di tale elemento.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>>>) SelectMany<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,IEnumerable<TResult>>>) SelectMany<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,IEnumerable<TResult>>>) SelectMany<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,IEnumerable<TResult>>>)

Proietta ogni elemento di una sequenza a un IEnumerable<T> e combina le sequenze risultanti in un'unica sequenza.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>>) SelectMany<TSource,TCollection,TResult>(IQueryable<TSource>, Expression<Func<TSource,Int32,IEnumerable<TCollection>>>, Expression<Func<TSource,TCollection,TResult>>) SelectMany<TSource,TCollection,TResult>(IQueryable<TSource>, Expression<Func<TSource,Int32,IEnumerable<TCollection>>>, Expression<Func<TSource,TCollection,TResult>>) SelectMany<TSource,TCollection,TResult>(IQueryable<TSource>, Expression<Func<TSource,Int32,IEnumerable<TCollection>>>, Expression<Func<TSource,TCollection,TResult>>)

Proietta ogni elemento di una sequenza a un IEnumerable<T> che incorpora l'indice dell'elemento di origine che l'ha prodotta.Projects each element of a sequence to an IEnumerable<T> that incorporates the index of the source element that produced it. Viene richiamata una funzione del selettore di risultato su ogni elemento di ogni sequenza intermedia e i valori risultanti vengono combinati in una singola sequenza unidimensionale e restituiti.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)

Parametri di tipo

TSource

Tipo degli elementi di source.The type of the elements of source.

TCollection

Il tipo degli elementi intermedi raccolti dalla funzione rappresentata da collectionSelector.The type of the intermediate elements collected by the function represented by collectionSelector.

TResult

Il tipo degli elementi della sequenza risultante.The type of the elements of the resulting sequence.

Parametri

source
IQueryable<TSource>

Sequenza di valori da proiettare.A sequence of values to project.

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

Una funzione di proiezione da applicare a ogni elemento della sequenza di input; il secondo parametro di questa funzione rappresenta l'indice dell'elemento di origine.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>>

Una funzione di proiezione da applicare a ogni elemento di ogni sequenza intermedia.A projection function to apply to each element of each intermediate sequence.

Restituisce

IQueryable<TResult>

Un' IQueryable<T> cui elementi sono il risultato ottenuto richiamando la funzione di proiezione uno-a-molti collectionSelector su ogni elemento del source e quindi il mapping di ognuno degli elementi di tale sequenza e i relativi source elemento a un elemento di risultato .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.

Eccezioni

Il parametro source, il parametro collectionSelector o il parametro resultSelector è null.source or collectionSelector or resultSelector is null.

Commenti

Questo metodo ha almeno un parametro di tipo Expression<TDelegate> il cui argomento tipo è uno del Func<T,TResult> tipi.This method has at least one parameter of type Expression<TDelegate> whose type argument is one of the Func<T,TResult> types. Per questi parametri, è possibile passare in un'espressione lambda e verrà compilata per un Expression<TDelegate>.For these parameters, you can pass in a lambda expression and it will be compiled to an Expression<TDelegate>.

Il SelectMany<TSource,TCollection,TResult>(IQueryable<TSource>, Expression<Func<TSource,Int32,IEnumerable<TCollection>>>, Expression<Func<TSource,TCollection,TResult>>) metodo genera un MethodCallExpression che rappresenta una chiamata SelectMany<TSource,TCollection,TResult>(IQueryable<TSource>, Expression<Func<TSource,Int32,IEnumerable<TCollection>>>, Expression<Func<TSource,TCollection,TResult>>) stesso come un metodo generico costruito.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. Passa quindi il MethodCallExpression per il CreateQuery(Expression) metodo del IQueryProvider rappresentato dal Provider proprietà del source parametro.It then passes the MethodCallExpression to the CreateQuery(Expression) method of the IQueryProvider represented by the Provider property of the source parameter.

Il comportamento delle query che si verifica in seguito all'esecuzione di un albero delle espressioni che rappresenta una chiamata SelectMany<TSource,TCollection,TResult>(IQueryable<TSource>, Expression<Func<TSource,Int32,IEnumerable<TCollection>>>, Expression<Func<TSource,TCollection,TResult>>) dipende dall'implementazione del tipo del source parametro.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. Il comportamento previsto è che richiami collectionSelector su ogni elemento di source per proiettarlo in un form enumerabile.The expected behavior is that it invokes collectionSelector on each element of source to project it into an enumerable form. Ogni risultato enumerabile incorpora l'indice dell'elemento di origine.Each enumerable result incorporates the source element's index. Quindi la funzione rappresentata da resultSelector viene richiamata su ogni elemento in ogni sequenza intermedia.Then the function represented by resultSelector is invoked on each element in each intermediate sequence. I valori risultanti vengono concatenati in una singola sequenza unidimensionale.The resulting values are concatenated into a single, one-dimensional sequence.

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

Proietta ogni elemento di una sequenza a un IEnumerable<T> e richiama una funzione del selettore di risultato su ogni elemento al suo interno.Projects each element of a sequence to an IEnumerable<T> and invokes a result selector function on each element therein. I valori risultanti da ogni sequenza intermedia vengono combinati in una singola sequenza unidimensionale e restituiti.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)

Parametri di tipo

TSource

Tipo degli elementi di source.The type of the elements of source.

TCollection

Il tipo degli elementi intermedi raccolti dalla funzione rappresentata da collectionSelector.The type of the intermediate elements collected by the function represented by collectionSelector.

TResult

Il tipo degli elementi della sequenza risultante.The type of the elements of the resulting sequence.

Parametri

source
IQueryable<TSource>

Sequenza di valori da proiettare.A sequence of values to project.

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

Una funzione di proiezione da applicare a ogni elemento della sequenza di input.A projection function to apply to each element of the input sequence.

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

Una funzione di proiezione da applicare a ogni elemento di ogni sequenza intermedia.A projection function to apply to each element of each intermediate sequence.

Restituisce

IQueryable<TResult>

Un' IQueryable<T> cui elementi sono il risultato ottenuto richiamando la funzione di proiezione uno-a-molti collectionSelector su ogni elemento del source e quindi il mapping di ognuno degli elementi di tale sequenza e i relativi source elemento a un elemento di risultato .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.

Eccezioni

Il parametro source, il parametro collectionSelector o il parametro resultSelector è null.source or collectionSelector or resultSelector is null.

Esempi

Esempio di codice seguente viene illustrato come utilizzare SelectMany<TSource,TCollection,TResult>(IQueryable<TSource>, Expression<Func<TSource,IEnumerable<TCollection>>>, Expression<Func<TSource,TCollection,TResult>>) per eseguire una proiezione di uno-a-molti su una matrice.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. Questo esempio Usa una funzione del selettore di risultato per mantenere l'elemento di origine che corrisponde a ogni sequenza intermedia nell'ambito per la chiamata finale al 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

Commenti

Questo metodo ha almeno un parametro di tipo Expression<TDelegate> il cui argomento tipo è uno del Func<T,TResult> tipi.This method has at least one parameter of type Expression<TDelegate> whose type argument is one of the Func<T,TResult> types. Per questi parametri, è possibile passare in un'espressione lambda e verrà compilata per un Expression<TDelegate>.For these parameters, you can pass in a lambda expression and it will be compiled to an Expression<TDelegate>.

Il SelectMany<TSource,TCollection,TResult>(IQueryable<TSource>, Expression<Func<TSource,IEnumerable<TCollection>>>, Expression<Func<TSource,TCollection,TResult>>) metodo genera un MethodCallExpression che rappresenta una chiamata SelectMany<TSource,TCollection,TResult>(IQueryable<TSource>, Expression<Func<TSource,IEnumerable<TCollection>>>, Expression<Func<TSource,TCollection,TResult>>) stesso come un metodo generico costruito.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. Passa quindi il MethodCallExpression per il CreateQuery(Expression) metodo del IQueryProvider rappresentato dal Provider proprietà del source parametro.It then passes the MethodCallExpression to the CreateQuery(Expression) method of the IQueryProvider represented by the Provider property of the source parameter.

Il comportamento delle query che si verifica in seguito all'esecuzione di un albero delle espressioni che rappresenta una chiamata SelectMany<TSource,TCollection,TResult>(IQueryable<TSource>, Expression<Func<TSource,IEnumerable<TCollection>>>, Expression<Func<TSource,TCollection,TResult>>) dipende dall'implementazione del tipo del source parametro.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. Il comportamento previsto è che richiami collectionSelector su ogni elemento di source per proiettarlo in un form enumerabile.The expected behavior is that it invokes collectionSelector on each element of source to project it into an enumerable form. Quindi la funzione rappresentata da resultSelector viene richiamata su ogni elemento in ogni sequenza intermedia.Then the function represented by resultSelector is invoked on each element in each intermediate sequence. I valori risultanti vengono concatenati in una singola sequenza unidimensionale.The resulting values are concatenated into a single, one-dimensional sequence.

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

Proietta ogni elemento di una sequenza a un IEnumerable<T> e combina le sequenze risultanti in un'unica sequenza.Projects each element of a sequence to an IEnumerable<T> and combines the resulting sequences into one sequence. L'indice di ogni elemento di origine viene usato nella maschera proiettata di tale elemento.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)

Parametri di tipo

TSource

Tipo degli elementi di source.The type of the elements of source.

TResult

Il tipo degli elementi della sequenza restituita dalla funzione rappresentata da selector.The type of the elements of the sequence returned by the function represented by selector.

Parametri

source
IQueryable<TSource>

Sequenza di valori da proiettare.A sequence of values to project.

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

Una funzione di proiezione da applicare a ogni elemento. il secondo parametro di questa funzione rappresenta l'indice dell'elemento di origine.A projection function to apply to each element; the second parameter of this function represents the index of the source element.

Restituisce

IQueryable<TResult>

Un IQueryable<T> cui elementi sono il risultato ottenuto richiamando una funzione di proiezione uno-a-molti su ogni elemento della sequenza di input.An IQueryable<T> whose elements are the result of invoking a one-to-many projection function on each element of the input sequence.

Eccezioni

source o selector è null.source or selector is null.

Esempi

Esempio di codice seguente viene illustrato come utilizzare SelectMany<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,Int32,IEnumerable<TResult>>>) per eseguire una proiezione di uno-a-molti su una matrice e usare l'indice di ogni elemento di origine.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

Commenti

Questo metodo ha almeno un parametro di tipo Expression<TDelegate> il cui argomento tipo è uno del Func<T,TResult> tipi.This method has at least one parameter of type Expression<TDelegate> whose type argument is one of the Func<T,TResult> types. Per questi parametri, è possibile passare in un'espressione lambda e verrà compilata per un Expression<TDelegate>.For these parameters, you can pass in a lambda expression and it will be compiled to an Expression<TDelegate>.

Il SelectMany<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,Int32,IEnumerable<TResult>>>) metodo genera un MethodCallExpression che rappresenta una chiamata SelectMany<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,Int32,IEnumerable<TResult>>>) stesso come un metodo generico costruito.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. Passa quindi il MethodCallExpression per il CreateQuery(Expression) metodo del IQueryProvider rappresentato dal Provider proprietà del source parametro.It then passes the MethodCallExpression to the CreateQuery(Expression) method of the IQueryProvider represented by the Provider property of the source parameter.

Il comportamento delle query che si verifica in seguito all'esecuzione di un albero delle espressioni che rappresenta una chiamata SelectMany<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,Int32,IEnumerable<TResult>>>) dipende dall'implementazione del tipo del source parametro.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. Il comportamento previsto è che richiami selector su ogni elemento di source per proiettarlo in un form enumerabile.The expected behavior is that it invokes selector on each element of source to project it into an enumerable form. Ogni risultato enumerabile incorpora l'indice dell'elemento di origine.Each enumerable result incorporates the index of the source element. Concatena quindi i risultati enumerabili in una singola sequenza unidimensionale.It then concatenates the enumerable results into a single, one-dimensional sequence.

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

Proietta ogni elemento di una sequenza a un IEnumerable<T> e combina le sequenze risultanti in un'unica sequenza.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)

Parametri di tipo

TSource

Tipo degli elementi di source.The type of the elements of source.

TResult

Il tipo degli elementi della sequenza restituita dalla funzione rappresentata da selector.The type of the elements of the sequence returned by the function represented by selector.

Parametri

source
IQueryable<TSource>

Sequenza di valori da proiettare.A sequence of values to project.

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

Una funzione di proiezione da applicare a ogni elemento.A projection function to apply to each element.

Restituisce

IQueryable<TResult>

Un IQueryable<T> cui elementi sono il risultato ottenuto richiamando una funzione di proiezione uno-a-molti su ogni elemento della sequenza di input.An IQueryable<T> whose elements are the result of invoking a one-to-many projection function on each element of the input sequence.

Eccezioni

source o selector è null.source or selector is null.

Esempi

Esempio di codice seguente viene illustrato come utilizzare SelectMany<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,IEnumerable<TResult>>>) per eseguire una proiezione di uno-a-molti su una matrice.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

Commenti

Questo metodo ha almeno un parametro di tipo Expression<TDelegate> il cui argomento tipo è uno del Func<T,TResult> tipi.This method has at least one parameter of type Expression<TDelegate> whose type argument is one of the Func<T,TResult> types. Per questi parametri, è possibile passare in un'espressione lambda e verrà compilata per un Expression<TDelegate>.For these parameters, you can pass in a lambda expression and it will be compiled to an Expression<TDelegate>.

Il SelectMany<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,IEnumerable<TResult>>>) metodo genera un MethodCallExpression che rappresenta una chiamata SelectMany<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,IEnumerable<TResult>>>) stesso come un metodo generico costruito.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. Passa quindi il MethodCallExpression per il CreateQuery(Expression) metodo del IQueryProvider rappresentato dal Provider proprietà del source parametro.It then passes the MethodCallExpression to the CreateQuery(Expression) method of the IQueryProvider represented by the Provider property of the source parameter.

Il comportamento delle query che si verifica in seguito all'esecuzione di un albero delle espressioni che rappresenta una chiamata SelectMany<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,IEnumerable<TResult>>>) dipende dall'implementazione del tipo del source parametro.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. Il comportamento previsto è che richiami selector su ogni elemento di source per proiettarlo in un form enumerabile.The expected behavior is that it invokes selector on each element of source to project it into an enumerable form. Concatena quindi i risultati enumerabili in una singola sequenza unidimensionale.It then concatenates the enumerable results into a single, one-dimensional sequence.

Si applica a