Enumerable.SelectMany Método

Definição

Namespace:

System.Linq

Assembly:

System.Linq.dll

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

Sobrecargas

SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>)	Projeta cada elemento de uma sequência em um IEnumerable<T>, mescla as sequências resultantes em uma sequência e chama uma função de seletor de resultado em cada elemento contido nele.
SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>)	Projeta cada elemento de uma sequência em um IEnumerable<T>, mescla as sequências resultantes em uma sequência e chama uma função de seletor de resultado em cada elemento contido nele. O índice de cada elemento de origem é usado no formulário projetado intermediário do elemento.
SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TResult>>)	Projeta cada elemento de uma sequência em um IEnumerable<T> e nivela as sequências resultantes em uma sequência.
SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TResult>>)	Projeta cada elemento de uma sequência em um IEnumerable<T> e nivela 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>(IEnumerable<TSource>, Func<TSource,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>)

Origem:

SelectMany.cs

Projeta cada elemento de uma sequência em um IEnumerable<T>, mescla as sequências resultantes em uma sequência e chama uma função de seletor de resultado em cada elemento contido nele.

C#

public static System.Collections.Generic.IEnumerable<TResult> SelectMany<TSource,TCollection,TResult> (this System.Collections.Generic.IEnumerable<TSource> source, Func<TSource,System.Collections.Generic.IEnumerable<TCollection>> collectionSelector, Func<TSource,TCollection,TResult> resultSelector);

Parâmetros de tipo

TSource

O tipo dos elementos de source.

TCollection

O tipo dos elementos intermediários coletados por collectionSelector.

TResult

O tipo dos elementos da sequência resultante.

Parâmetros

source

IEnumerable<TSource>

Uma sequência de valores a serem projetados.

collectionSelector

Func<TSource,IEnumerable<TCollection>>

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

resultSelector

Func<TSource,TCollection,TResult>

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

Retornos

IEnumerable<TResult>

Um IEnumerable<T> cujos elementos são o resultado de chamar a função de transformaçã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 de origem 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>(IEnumerable<TSource>, Func<TSource,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>) para executar uma projeção de um para muitos em uma matriz e usar uma função seletora de resultados para manter cada elemento correspondente da sequência de origem no escopo da chamada final para Select.

C#

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

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

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

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

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

Comentários

Esse método é implementado usando a execução adiada. O valor retornado imediato é um objeto que armazena todas as informações necessárias para executar a ação. A consulta representada por esse método não é executada até que o objeto seja enumerado chamando seu GetEnumerator método diretamente ou usando foreach em C# ou For Each no Visual Basic.

O SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>) método é útil quando você precisa manter os elementos de no escopo da source lógica de consulta que ocorre após a chamada para SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>). Consulte a seção Exemplo para obter um exemplo de código. Se houver uma relação bidirecional entre objetos do tipo TSource e objetos do tipo TCollection, ou seja, se um objeto do tipo TCollection fornecer uma propriedade para recuperar o objeto que o TSource produziu, você não precisará dessa sobrecarga de SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>). Em vez disso, você pode usar SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TResult>>) e navegar de volta para o TSource objeto por meio do TCollection objeto .

Na sintaxe da expressão de consulta, cada from cláusula (C#) ou From cláusula (Visual Basic) após a inicial é convertida em uma invocação de SelectMany.

Confira também

• Cláusula from (Referência de C#)
• Cláusula From (Visual Basic)

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

Origem:

SelectMany.cs

Projeta cada elemento de uma sequência em um IEnumerable<T>, mescla as sequências resultantes em uma sequência e chama uma função de seletor de resultado em cada elemento contido nele. O índice de cada elemento de origem é usado no formulário projetado intermediário do elemento.

C#

public static System.Collections.Generic.IEnumerable<TResult> SelectMany<TSource,TCollection,TResult> (this System.Collections.Generic.IEnumerable<TSource> source, Func<TSource,int,System.Collections.Generic.IEnumerable<TCollection>> collectionSelector, Func<TSource,TCollection,TResult> resultSelector);

Parâmetros de tipo

TSource

O tipo dos elementos de source.

TCollection

O tipo dos elementos intermediários coletados por collectionSelector.

TResult

O tipo dos elementos da sequência resultante.

Parâmetros

source

IEnumerable<TSource>

Uma sequência de valores a serem projetados.

collectionSelector

Func<TSource,Int32,IEnumerable<TCollection>>

Uma função de transformação para aplicar a cada elemento de origem; o segundo parâmetro da função representa o índice do elemento de origem.

resultSelector

Func<TSource,TCollection,TResult>

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

Retornos

IEnumerable<TResult>

Um IEnumerable<T> cujos elementos são o resultado de chamar a função de transformaçã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 de origem correspondente para um elemento de resultado.

Exceções

ArgumentNullException

source, collectionSelector ou resultSelector é null.

Comentários

Esse método é implementado usando a execução adiada. O valor retornado imediato é um objeto que armazena todas as informações necessárias para executar a ação. A consulta representada por esse método não é executada até que o objeto seja enumerado chamando seu GetEnumerator método diretamente ou usando foreach em C# ou For Each no Visual Basic.

O SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>) método é útil quando você precisa manter os elementos de no escopo da source lógica de consulta que ocorre após a chamada para SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>). Consulte a seção Exemplo para obter um exemplo de código. Se houver uma relação bidirecional entre objetos do tipo TSource e objetos do tipo TCollection, ou seja, se um objeto do tipo TCollection fornecer uma propriedade para recuperar o objeto que o TSource produziu, você não precisará dessa sobrecarga de SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>). Em vez disso, você pode usar SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TResult>>) e navegar de volta para o TSource objeto por meio do TCollection objeto .

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

Origem:

SelectMany.cs

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

C#

public static System.Collections.Generic.IEnumerable<TResult> SelectMany<TSource,TResult> (this System.Collections.Generic.IEnumerable<TSource> source, Func<TSource,System.Collections.Generic.IEnumerable<TResult>> selector);

Parâmetros de tipo

TSource

O tipo dos elementos de source.

TResult

O tipo dos elementos da sequência retornada por selector.

Parâmetros

source

IEnumerable<TSource>

Uma sequência de valores a serem projetados.

selector

Func<TSource,IEnumerable<TResult>>

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

Retornos

IEnumerable<TResult>

Um IEnumerable<T> cujos elementos são resultado da invocação da função de transformaçã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>(IEnumerable<TSource>, Func<TSource,IEnumerable<TResult>>) para executar uma projeção um-para-muitos em uma matriz.

C#

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

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

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

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

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

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

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

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

/*
 This code produces the following output:

 Using SelectMany():
 Scruffy
 Sam
 Walker
 Sugar
 Scratches
 Diesel

 Using Select():
 Scruffy
 Sam

 Walker
 Sugar

 Scratches
 Diesel
*/

Comentários

Esse método é implementado usando a execução adiada. O valor retornado imediato é um objeto que armazena todas as informações necessárias para executar a ação. A consulta representada por esse método não é executada até que o objeto seja enumerado chamando seu GetEnumerator método diretamente ou usando foreach em C# ou For Each no Visual Basic.

O SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TResult>>) método enumera a sequência de entrada, usa uma função de transformação para mapear cada elemento para um IEnumerable<T>e, em seguida, enumera e produz os elementos de cada objeto desse tipo IEnumerable<T> . Ou seja, para cada elemento de source, selector é invocado e uma sequência de valores é retornada. SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TResult>>) em seguida, nivela essa coleção bidimensional de coleções em uma unidimensional IEnumerable<T> e a retorna. Por exemplo, se uma consulta usar para obter os pedidos SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TResult>>) (do tipo Order) para cada cliente em um banco de dados, o resultado será do tipo IEnumerable<Order> em C# ou IEnumerable(Of Order) no Visual Basic. Se, em vez disso, a consulta usar para obter os pedidos Select , a coleção de coleções de pedidos não será combinada e o resultado será do tipo IEnumerable<List<Order>> em C# ou IEnumerable(Of List(Of Order)) no Visual Basic.

Na sintaxe da expressão de consulta, cada from cláusula (C#) ou From cláusula (Visual Basic) após a inicial é convertida em uma invocação de SelectMany.

Confira também

• Cláusula from (Referência de C#)
• Cláusula From (Visual Basic)

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

Origem:

SelectMany.cs

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

C#

public static System.Collections.Generic.IEnumerable<TResult> SelectMany<TSource,TResult> (this System.Collections.Generic.IEnumerable<TSource> source, Func<TSource,int,System.Collections.Generic.IEnumerable<TResult>> selector);

Parâmetros de tipo

TSource

O tipo dos elementos de source.

TResult

O tipo dos elementos da sequência retornada por selector.

Parâmetros

source

IEnumerable<TSource>

Uma sequência de valores a serem projetados.

selector

Func<TSource,Int32,IEnumerable<TResult>>

Uma função de transformação para aplicar a cada elemento de origem; o segundo parâmetro da função representa o índice do elemento de origem.

Retornos

IEnumerable<TResult>

Um IEnumerable<T> cujos elementos são o resultado da invocação da função de transformação um-para-muitos em cada elemento de uma 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>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TResult>>) para executar uma projeção um-para-muitos em uma matriz e usar o índice de cada elemento externo.

C#

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

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

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

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

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

Comentários

Esse método é implementado usando a execução adiada. O valor retornado imediato é um objeto que armazena todas as informações necessárias para executar a ação. A consulta representada por esse método não é executada até que o objeto seja enumerado chamando seu GetEnumerator método diretamente ou usando foreach em C# ou For Each no Visual Basic.

O SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TResult>>) método enumera a sequência de entrada, usa uma função de transformação para mapear cada elemento para um IEnumerable<T>e, em seguida, enumera e produz os elementos de cada objeto desse tipo IEnumerable<T> . Ou seja, para cada elemento de source, selector é invocado e uma sequência de valores é retornada. SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TResult>>) em seguida, nivela essa coleção bidimensional de coleções em uma unidimensional IEnumerable<T> e a retorna. Por exemplo, se uma consulta usar para obter os pedidos SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TResult>>) (do tipo Order) para cada cliente em um banco de dados, o resultado será do tipo IEnumerable<Order> em C# ou IEnumerable(Of Order) no Visual Basic. Se, em vez disso, a consulta usar para obter os pedidos Select , a coleção de coleções de pedidos não será combinada e o resultado será do tipo IEnumerable<List<Order>> em C# ou IEnumerable(Of List(Of Order)) no Visual Basic.

O primeiro argumento a selector representar o elemento a ser processado. O segundo argumento a selector representar o índice baseado em zero desse elemento na sequência de origem. Isso pode ser útil se os elementos estiverem em uma ordem conhecida e você quiser fazer algo com um elemento em um índice específico, por exemplo. Também pode ser útil se você quiser recuperar o índice de um ou mais elementos.