Queryable.SelectMany Método

Referência

Definição

Namespace:: System.Linq

Assembly:: System.Linq.Queryable.dll

Assembly:: System.Core.dll

Assembly:: netstandard.dll

Importante

Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.

Projeta cada elemento de uma sequência em um IEnumerable<T> e combina as sequências resultantes em uma sequência de tipo IQueryable<T>.

Sobrecargas

SelectMany<TSource,TCollection,TResult>(IQueryable<TSource>, Expression<Func<TSource, IEnumerable<TCollection>>>, Expression<Func<TSource,TCollection, TResult>>)	Projeta cada elemento de uma sequência em um IEnumerable<T> e invoca uma função de seletor de resultado em cada elemento contido nele. Os valores resultantes de cada sequência intermediária são combinados em uma única sequência unidimensional e retornada.
SelectMany<TSource,TCollection,TResult>(IQueryable<TSource>, Expression<Func<TSource, Int32,IEnumerable<TCollection>>>, Expression<Func<TSource,TCollection, TResult>>)	Projeta cada elemento de uma sequência em um IEnumerable<T> que incorpora o índice do elemento de origem que o produziu. Uma função seletora de resultados é invocada em cada elemento de cada sequência intermediária e os valores resultantes são combinados em uma única sequência unidimensional e retornados.
SelectMany<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,IEnumerable<TResult>>>)	Projeta cada elemento de uma sequência em um IEnumerable<T> e combina as sequências resultantes em uma sequência.
SelectMany<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,Int32,IEnumerable<TResult>>>)	Projeta cada elemento de uma sequência em um IEnumerable<T> e combina as sequências resultantes em uma sequência. O índice de cada elemento de origem é usado no formulário projetado desse elemento.

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

Origem:: Queryable.cs

Origem:: Queryable.cs

Origem:: Queryable.cs

Projeta cada elemento de uma sequência em um IEnumerable<T> e invoca uma função de seletor de resultado em cada elemento contido nele. Os valores resultantes de cada sequência intermediária são combinados em uma única sequência unidimensional e retornada.

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)

Parâmetros de tipo

TSource

O tipo dos elementos de source.

TCollection

O tipo dos elementos intermediários coletados pela função representada por collectionSelector.

TResult

O tipo dos elementos da sequência resultante.

Parâmetros

source: IQueryable<TSource>

Uma sequência de valores a serem projetados.

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

Uma função de projeção a ser aplicada a cada elemento da sequência de entrada.

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

Uma função de projeção a ser aplicada a cada elemento de cada sequência intermediária.

Retornos

IQueryable<TResult>

Um IQueryable<T> cujos elementos são o resultado de invocar a função de projeção de um para muitos collectionSelector em cada elemento de source e, em seguida, mapear cada um desses elementos de sequência e seu elemento source correspondente para um elemento de resultado.

Exceções

ArgumentNullException

source, collectionSelector ou resultSelector é null.

Exemplos

O exemplo de código a seguir demonstra como usar SelectMany<TSource,TCollection,TResult>(IQueryable<TSource>, Expression<Func<TSource, IEnumerable<TCollection>>>, Expression<Func<TSource,TCollection, TResult>>) para executar uma projeção um-para-muitos em uma matriz. Este exemplo usa uma função seletora de resultados para manter o elemento de origem que corresponde a cada sequência intermediária no escopo da chamada final para 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

Comentários

Esse método tem pelo menos um parâmetro do tipo Expression<TDelegate> cujo argumento de tipo é um dos Func<T,TResult> tipos. Para esses parâmetros, você pode passar uma expressão lambda e ela será compilada para um Expression<TDelegate>.

O SelectMany<TSource,TCollection,TResult>(IQueryable<TSource>, Expression<Func<TSource, IEnumerable<TCollection>>>, Expression<Func<TSource,TCollection, TResult>>) método gera um MethodCallExpression que representa a própria chamada SelectMany<TSource,TCollection,TResult>(IQueryable<TSource>, Expression<Func<TSource, IEnumerable<TCollection>>>, Expression<Func<TSource,TCollection, TResult>>) como um método genérico construído. Em seguida, ele passa o MethodCallExpression para o CreateQuery(Expression) método do IQueryProvider representado pela Provider propriedade do source parâmetro .

O comportamento da consulta que ocorre como resultado da execução de uma árvore de expressão que representa a chamada SelectMany<TSource,TCollection,TResult>(IQueryable<TSource>, Expression<Func<TSource, IEnumerable<TCollection>>>, Expression<Func<TSource,TCollection, TResult>>) depende da implementação do tipo do source parâmetro. O comportamento esperado é que ele invoca collectionSelector em cada elemento de source para projetá-lo em um formulário enumerável. Em seguida, a função representada por resultSelector é invocada em cada elemento em cada sequência intermediária. Os valores resultantes são concatenados em uma única sequência unidimensional.

Aplica-se a

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

Origem:: Queryable.cs

Origem:: Queryable.cs

Origem:: Queryable.cs

Projeta cada elemento de uma sequência em um IEnumerable<T> que incorpora o índice do elemento de origem que o produziu. Uma função seletora de resultados é invocada em cada elemento de cada sequência intermediária e os valores resultantes são combinados em uma única sequência unidimensional e retornados.

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)

Parâmetros de tipo

TSource

O tipo dos elementos de source.

TCollection

O tipo dos elementos intermediários coletados pela função representada por collectionSelector.

TResult

O tipo dos elementos da sequência resultante.

Parâmetros

source: IQueryable<TSource>

Uma sequência de valores a serem projetados.

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

Uma função de projeção a ser aplicada a cada elemento da sequência de entrada; o segundo parâmetro dessa função representa o índice do elemento de origem.

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

Uma função de projeção a ser aplicada a cada elemento de cada sequência intermediária.

Retornos

IQueryable<TResult>

Exceções

ArgumentNullException

source, collectionSelector ou resultSelector é null.

Comentários

O SelectMany<TSource,TCollection,TResult>(IQueryable<TSource>, Expression<Func<TSource, Int32,IEnumerable<TCollection>>>, Expression<Func<TSource,TCollection, TResult>>) método gera um MethodCallExpression que representa a própria chamada SelectMany<TSource,TCollection,TResult>(IQueryable<TSource>, Expression<Func<TSource, Int32,IEnumerable<TCollection>>>, Expression<Func<TSource,TCollection, TResult>>) como um método genérico construído. Em seguida, ele passa o MethodCallExpression para o CreateQuery(Expression) método do IQueryProvider representado pela Provider propriedade do source parâmetro .

O comportamento da consulta que ocorre como resultado da execução de uma árvore de expressão que representa a chamada SelectMany<TSource,TCollection,TResult>(IQueryable<TSource>, Expression<Func<TSource, Int32,IEnumerable<TCollection>>>, Expression<Func<TSource,TCollection, TResult>>) depende da implementação do tipo do source parâmetro. O comportamento esperado é que ele invoca collectionSelector em cada elemento de source para projetá-lo em um formulário enumerável. Cada resultado enumerável incorpora o índice do elemento de origem. Em seguida, a função representada por resultSelector é invocada em cada elemento em cada sequência intermediária. Os valores resultantes são concatenados em uma única sequência unidimensional.

Aplica-se a

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

Origem:: Queryable.cs

Origem:: Queryable.cs

Origem:: Queryable.cs

Projeta cada elemento de uma sequência em um IEnumerable<T> e combina as sequências resultantes em uma sequência.

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)

Parâmetros de tipo

TSource

O tipo dos elementos de source.

TResult

O tipo dos elementos da sequência retornada pela função representada por selector.

Parâmetros

source: IQueryable<TSource>

Uma sequência de valores a serem projetados.

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

Uma função de projeção a ser aplicada a cada elemento.

Retornos

IQueryable<TResult>

Um IQueryable<T> cujos elementos são resultado da invocação de uma função de projeção de um para muitos em cada elemento da sequência de entrada.

Exceções

ArgumentNullException

source ou selector é null.

Exemplos

O exemplo de código a seguir demonstra como usar SelectMany<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,IEnumerable<TResult>>>) para executar uma projeção um-para-muitos em uma matriz.

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

Comentários

O SelectMany<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,IEnumerable<TResult>>>) método gera um MethodCallExpression que representa a própria chamada SelectMany<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,IEnumerable<TResult>>>) como um método genérico construído. Em seguida, ele passa o MethodCallExpression para o CreateQuery(Expression) método do IQueryProvider representado pela Provider propriedade do source parâmetro .

O comportamento da consulta que ocorre como resultado da execução de uma árvore de expressão que representa a chamada SelectMany<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,IEnumerable<TResult>>>) depende da implementação do tipo do source parâmetro. O comportamento esperado é que ele invoca selector em cada elemento de source para projetá-lo em um formulário enumerável. Em seguida, concatena os resultados enumeráveis em uma única sequência unidimensional.

Aplica-se a

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

Origem:: Queryable.cs

Origem:: Queryable.cs

Origem:: Queryable.cs

Projeta cada elemento de uma sequência em um IEnumerable<T> e combina as sequências resultantes em uma sequência. O índice de cada elemento de origem é usado no formulário projetado desse elemento.

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)

Parâmetros de tipo

TSource

O tipo dos elementos de source.

TResult

O tipo dos elementos da sequência retornada pela função representada por selector.

Parâmetros

source: IQueryable<TSource>

Uma sequência de valores a serem projetados.

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

Uma função de projeção a ser aplicada a cada elemento; o segundo parâmetro dessa função representa o índice do elemento de origem.

Retornos

IQueryable<TResult>

Um IQueryable<T> cujos elementos são resultado da invocação de uma função de projeção de um para muitos em cada elemento da sequência de entrada.

Exceções

ArgumentNullException

source ou selector é null.

Exemplos

O exemplo de código a seguir demonstra como usar SelectMany<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,Int32,IEnumerable<TResult>>>) para executar uma projeção um-para-muitos em uma matriz e usar o índice de cada elemento de origem.

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

Comentários

O SelectMany<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,Int32,IEnumerable<TResult>>>) método gera um MethodCallExpression que representa a própria chamada SelectMany<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,Int32,IEnumerable<TResult>>>) como um método genérico construído. Em seguida, ele passa o MethodCallExpression para o CreateQuery(Expression) método do IQueryProvider representado pela Provider propriedade do source parâmetro .

O comportamento da consulta que ocorre como resultado da execução de uma árvore de expressão que representa a chamada SelectMany<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,Int32,IEnumerable<TResult>>>) depende da implementação do tipo do source parâmetro. O comportamento esperado é que ele invoca selector em cada elemento de source para projetá-lo em um formulário enumerável. Cada resultado enumerável incorpora o índice do elemento de origem. Em seguida, concatena os resultados enumeráveis em uma única sequência unidimensional.

Aplica-se a

Compartilhar via

Queryable.SelectMany Método

Definição

Sobrecargas

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

Parâmetros de tipo

Parâmetros

Retornos

Exceções

Exemplos

Comentários

Aplica-se a

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

Parâmetros de tipo

Parâmetros

Retornos

Exceções

Comentários

Aplica-se a

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

Parâmetros de tipo

Parâmetros

Retornos

Exceções

Exemplos

Comentários

Aplica-se a

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

Parâmetros de tipo

Parâmetros

Retornos

Exceções

Exemplos

Comentários

Aplica-se a

Recursos adicionais