Enumerable.SelectMany Método
Definição
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 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
- Origem:
- SelectMany.cs
- 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.
public:
generic <typename TSource, typename TCollection, typename TResult>
[System::Runtime::CompilerServices::Extension]
static System::Collections::Generic::IEnumerable<TResult> ^ SelectMany(System::Collections::Generic::IEnumerable<TSource> ^ source, Func<TSource, System::Collections::Generic::IEnumerable<TCollection> ^> ^ collectionSelector, Func<TSource, TCollection, TResult> ^ resultSelector);public static System.Collections.Generic.IEnumerable<TResult> SelectMany<TSource,TCollection,TResult> (this System.Collections.Generic.IEnumerable<TSource> source, Func<TSource,System.Collections.Generic.IEnumerable<TCollection>> collectionSelector, Func<TSource,TCollection,TResult> resultSelector);static member SelectMany : seq<'Source> * Func<'Source, seq<'Collection>> * Func<'Source, 'Collection, 'Result> -> seq<'Result><Extension()>
Public Function SelectMany(Of TSource, TCollection, TResult) (source As IEnumerable(Of TSource), collectionSelector As Func(Of TSource, IEnumerable(Of TCollection)), resultSelector As Func(Of TSource, TCollection, TResult)) As IEnumerable(Of TResult)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
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
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.
class PetOwner
{
public string Name { get; set; }
public List<string> Pets { get; set; }
}
public static void SelectManyEx3()
{
PetOwner[] petOwners =
{ new PetOwner { Name="Higa",
Pets = new List<string>{ "Scruffy", "Sam" } },
new PetOwner { Name="Ashkenazi",
Pets = new List<string>{ "Walker", "Sugar" } },
new PetOwner { Name="Price",
Pets = new List<string>{ "Scratches", "Diesel" } },
new PetOwner { Name="Hines",
Pets = new List<string>{ "Dusty" } } };
// Project the pet owner's name and the pet's name.
var query =
petOwners
.SelectMany(petOwner => petOwner.Pets, (petOwner, petName) => new { petOwner, petName })
.Where(ownerAndPet => ownerAndPet.petName.StartsWith("S"))
.Select(ownerAndPet =>
new
{
Owner = ownerAndPet.petOwner.Name,
Pet = ownerAndPet.petName
}
);
// Print the results.
foreach (var obj in query)
{
Console.WriteLine(obj);
}
}
// This code produces the following output:
//
// {Owner=Higa, Pet=Scruffy}
// {Owner=Higa, Pet=Sam}
// {Owner=Ashkenazi, Pet=Sugar}
// {Owner=Price, Pet=Scratches}
Structure PetOwner
Public Name As String
Public Pets() As String
End Structure
Sub SelectManyEx3()
' Create an array of PetOwner objects.
Dim petOwners() As PetOwner =
{New PetOwner With
{.Name = "Higa", .Pets = New String() {"Scruffy", "Sam"}},
New PetOwner With
{.Name = "Ashkenazi", .Pets = New String() {"Walker", "Sugar"}},
New PetOwner With
{.Name = "Price", .Pets = New String() {"Scratches", "Diesel"}},
New PetOwner With
{.Name = "Hines", .Pets = New String() {"Dusty"}}}
' Project an anonymous type that consists of
' the owner's name and the pet's name (string).
Dim query =
petOwners _
.SelectMany(
Function(petOwner) petOwner.Pets,
Function(petOwner, petName) New With {petOwner, petName}) _
.Where(Function(ownerAndPet) ownerAndPet.petName.StartsWith("S")) _
.Select(Function(ownerAndPet) _
New With {.Owner = ownerAndPet.petOwner.Name,
.Pet = ownerAndPet.petName
})
Dim output As New System.Text.StringBuilder
For Each obj In query
output.AppendLine(String.Format("Owner={0}, Pet={1}", obj.Owner, obj.Pet))
Next
' Display the output.
Console.WriteLine(output.ToString())
End Sub
' This code produces the following output:
'
' Owner=Higa, Pet=Scruffy
' Owner=Higa, Pet=Sam
' Owner=Ashkenazi, Pet=Sugar
' Owner=Price, Pet=Scratches
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
Aplica-se a
SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>)
- Origem:
- SelectMany.cs
- Origem:
- SelectMany.cs
- 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.
public:
generic <typename TSource, typename TCollection, typename TResult>
[System::Runtime::CompilerServices::Extension]
static System::Collections::Generic::IEnumerable<TResult> ^ SelectMany(System::Collections::Generic::IEnumerable<TSource> ^ source, Func<TSource, int, System::Collections::Generic::IEnumerable<TCollection> ^> ^ collectionSelector, Func<TSource, TCollection, TResult> ^ resultSelector);public static System.Collections.Generic.IEnumerable<TResult> SelectMany<TSource,TCollection,TResult> (this System.Collections.Generic.IEnumerable<TSource> source, Func<TSource,int,System.Collections.Generic.IEnumerable<TCollection>> collectionSelector, Func<TSource,TCollection,TResult> resultSelector);static member SelectMany : seq<'Source> * Func<'Source, int, seq<'Collection>> * Func<'Source, 'Collection, 'Result> -> seq<'Result><Extension()>
Public Function SelectMany(Of TSource, TCollection, TResult) (source As IEnumerable(Of TSource), collectionSelector As Func(Of TSource, Integer, IEnumerable(Of TCollection)), resultSelector As Func(Of TSource, TCollection, TResult)) As IEnumerable(Of TResult)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
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
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 .
Aplica-se a
SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TResult>>)
- Origem:
- SelectMany.cs
- Origem:
- SelectMany.cs
- Origem:
- SelectMany.cs
Projeta cada elemento de uma sequência em um IEnumerable<T> e nivela as sequências resultantes em uma sequência.
public:
generic <typename TSource, typename TResult>
[System::Runtime::CompilerServices::Extension]
static System::Collections::Generic::IEnumerable<TResult> ^ SelectMany(System::Collections::Generic::IEnumerable<TSource> ^ source, Func<TSource, System::Collections::Generic::IEnumerable<TResult> ^> ^ selector);public static System.Collections.Generic.IEnumerable<TResult> SelectMany<TSource,TResult> (this System.Collections.Generic.IEnumerable<TSource> source, Func<TSource,System.Collections.Generic.IEnumerable<TResult>> selector);static member SelectMany : seq<'Source> * Func<'Source, seq<'Result>> -> seq<'Result><Extension()>
Public Function SelectMany(Of TSource, TResult) (source As IEnumerable(Of TSource), selector As Func(Of TSource, IEnumerable(Of TResult))) As IEnumerable(Of TResult)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
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
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.
class PetOwner
{
public string Name { get; set; }
public List<String> Pets { get; set; }
}
public static void SelectManyEx1()
{
PetOwner[] petOwners =
{ new PetOwner { Name="Higa, Sidney",
Pets = new List<string>{ "Scruffy", "Sam" } },
new PetOwner { Name="Ashkenazi, Ronen",
Pets = new List<string>{ "Walker", "Sugar" } },
new PetOwner { Name="Price, Vernette",
Pets = new List<string>{ "Scratches", "Diesel" } } };
// Query using SelectMany().
IEnumerable<string> query1 = petOwners.SelectMany(petOwner => petOwner.Pets);
Console.WriteLine("Using SelectMany():");
// Only one foreach loop is required to iterate
// through the results since it is a
// one-dimensional collection.
foreach (string pet in query1)
{
Console.WriteLine(pet);
}
// This code shows how to use Select()
// instead of SelectMany().
IEnumerable<List<String>> query2 =
petOwners.Select(petOwner => petOwner.Pets);
Console.WriteLine("\nUsing Select():");
// Notice that two foreach loops are required to
// iterate through the results
// because the query returns a collection of arrays.
foreach (List<String> petList in query2)
{
foreach (string pet in petList)
{
Console.WriteLine(pet);
}
Console.WriteLine();
}
}
/*
This code produces the following output:
Using SelectMany():
Scruffy
Sam
Walker
Sugar
Scratches
Diesel
Using Select():
Scruffy
Sam
Walker
Sugar
Scratches
Diesel
*/
Structure PetOwner
Public Name As String
Public Pets() As String
End Structure
Sub SelectManyEx1()
' Create an array of PetOwner objects.
Dim petOwners() As PetOwner =
{New PetOwner With
{.Name = "Higa, Sidney", .Pets = New String() {"Scruffy", "Sam"}},
New PetOwner With
{.Name = "Ashkenazi, Ronen", .Pets = New String() {"Walker", "Sugar"}},
New PetOwner With
{.Name = "Price, Vernette", .Pets = New String() {"Scratches", "Diesel"}}}
' Call SelectMany() to gather all pets into a "flat" sequence.
Dim query1 As IEnumerable(Of String) =
petOwners.SelectMany(Function(petOwner) petOwner.Pets)
Dim output As New System.Text.StringBuilder("Using SelectMany():" & vbCrLf)
' Only one foreach loop is required to iterate through
' the results because it is a one-dimensional collection.
For Each pet As String In query1
output.AppendLine(pet)
Next
' This code demonstrates how to use Select() instead
' of SelectMany() to get the same result.
Dim query2 As IEnumerable(Of String()) =
petOwners.Select(Function(petOwner) petOwner.Pets)
output.AppendLine(vbCrLf & "Using Select():")
' Notice that two foreach loops are required to iterate through
' the results because the query returns a collection of arrays.
For Each petArray() As String In query2
For Each pet As String In petArray
output.AppendLine(pet)
Next
Next
' Display the output.
Console.WriteLine(output.ToString())
End Sub
' This code produces the following output:
'
' Using SelectMany():
' Scruffy
' Sam
' Walker
' Sugar
' Scratches
' Diesel
'
' Using Select():
' Scruffy
' Sam
' Walker
' Sugar
' Scratches
' Diesel
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
Aplica-se a
SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TResult>>)
- Origem:
- SelectMany.cs
- Origem:
- SelectMany.cs
- 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.
public:
generic <typename TSource, typename TResult>
[System::Runtime::CompilerServices::Extension]
static System::Collections::Generic::IEnumerable<TResult> ^ SelectMany(System::Collections::Generic::IEnumerable<TSource> ^ source, Func<TSource, int, System::Collections::Generic::IEnumerable<TResult> ^> ^ selector);public static System.Collections.Generic.IEnumerable<TResult> SelectMany<TSource,TResult> (this System.Collections.Generic.IEnumerable<TSource> source, Func<TSource,int,System.Collections.Generic.IEnumerable<TResult>> selector);static member SelectMany : seq<'Source> * Func<'Source, int, seq<'Result>> -> seq<'Result><Extension()>
Public Function SelectMany(Of TSource, TResult) (source As IEnumerable(Of TSource), selector As Func(Of TSource, Integer, IEnumerable(Of TResult))) As IEnumerable(Of TResult)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
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
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.
class PetOwner
{
public string Name { get; set; }
public List<string> Pets { get; set; }
}
public static void SelectManyEx2()
{
PetOwner[] petOwners =
{ new PetOwner { Name="Higa, Sidney",
Pets = new List<string>{ "Scruffy", "Sam" } },
new PetOwner { Name="Ashkenazi, Ronen",
Pets = new List<string>{ "Walker", "Sugar" } },
new PetOwner { Name="Price, Vernette",
Pets = new List<string>{ "Scratches", "Diesel" } },
new PetOwner { Name="Hines, Patrick",
Pets = new List<string>{ "Dusty" } } };
// Project the items in the array by appending the index
// of each PetOwner to each pet's name in that petOwner's
// array of pets.
IEnumerable<string> query =
petOwners.SelectMany((petOwner, index) =>
petOwner.Pets.Select(pet => index + pet));
foreach (string pet in query)
{
Console.WriteLine(pet);
}
}
// This code produces the following output:
//
// 0Scruffy
// 0Sam
// 1Walker
// 1Sugar
// 2Scratches
// 2Diesel
// 3Dusty
Structure PetOwner
Public Name As String
Public Pets() As String
End Structure
Sub SelectManyEx2()
' Create an array of PetOwner objects.
Dim petOwners() As PetOwner =
{New PetOwner With
{.Name = "Higa, Sidney", .Pets = New String() {"Scruffy", "Sam"}},
New PetOwner With
{.Name = "Ashkenazi, Ronen", .Pets = New String() {"Walker", "Sugar"}},
New PetOwner With
{.Name = "Price, Vernette", .Pets = New String() {"Scratches", "Diesel"}},
New PetOwner With
{.Name = "Hines, Patrick", .Pets = New String() {"Dusty"}}}
' Project the items in the array by appending the index
' of each PetOwner to each pet's name in that petOwner's
' array of pets.
Dim query As IEnumerable(Of String) =
petOwners.SelectMany(Function(petOwner, index) _
petOwner.Pets.Select(Function(pet) _
index.ToString() + pet))
Dim output As New System.Text.StringBuilder
For Each pet As String In query
output.AppendLine(pet)
Next
' Display the output.
Console.WriteLine(output.ToString())
End Sub
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.
Aplica-se a
Comentários
Brevemente: Ao longo de 2024, vamos descontinuar progressivamente o GitHub Issues como mecanismo de feedback para conteúdos e substituí-lo por um novo sistema de feedback. Para obter mais informações, veja: https://aka.ms/ContentUserFeedback.
Submeter e ver comentários