Enumerable.SelectMany Método

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

Parâmetros

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.An IEnumerable<T> whose elements are the result of invoking the one-to-many transform function collectionSelector on each element of source and then mapping each of those sequence elements and their corresponding source element to a result element.

Exceções

Exemplos

O exemplo de código a seguir demonstra como usar o 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 de seletor de resultado para manter cada elemento correspondente da sequência de origem no escopo da chamada final para Select .The following code example demonstrates how to use SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>) to perform a one-to-many projection over an array and use a result selector function to keep each corresponding element from the source sequence in scope for the final call to 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.This method is implemented by using deferred execution. O valor de retorno imediato é um objeto que armazena todas as informações necessárias para executar a ação.The immediate return value is an object that stores all the information that is required to perform the action. A consulta representada por esse método não é executada até que o objeto seja enumerado chamando o GetEnumerator método diretamente ou usando o foreach no Visual C# ou For Each no Visual Basic.The query represented by this method is not executed until the object is enumerated either by calling its GetEnumerator method directly or by using foreach in Visual C# or For Each in 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 source no escopo para a 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>) .The SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>) method is useful when you have to keep the elements of source in scope for query logic that occurs after the call to SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>). Consulte a seção de exemplo para obter um exemplo de código.See the Example section for a code example. 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 TSource objeto que o produziu, você não precisará dessa sobrecarga de SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>) .If there is a bidirectional relationship between objects of type TSource and objects of type TCollection, that is, if an object of type TCollection provides a property to retrieve the TSource object that produced it, you do not need this overload of 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.Instead, you can use SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TResult>>) and navigate back to the TSource object through the TCollection object.

Na sintaxe de expressão de consulta, cada from cláusula (Visual C#) ou From cláusula (Visual Basic) após a inicial é convertida em uma invocação de SelectMany .In query expression syntax, each from clause (Visual C#) or From clause (Visual Basic) after the initial one translates to an invocation of SelectMany.

Confira também

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

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

Parâmetros

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.An IEnumerable<T> whose elements are the result of invoking the one-to-many transform function collectionSelector on each element of source and then mapping each of those sequence elements and their corresponding source element to a result element.

Exceções

Comentários

Esse método é implementado usando a execução adiada.This method is implemented by using deferred execution. O valor de retorno imediato é um objeto que armazena todas as informações necessárias para executar a ação.The immediate return value is an object that stores all the information that is required to perform the action. A consulta representada por esse método não é executada até que o objeto seja enumerado chamando o GetEnumerator método diretamente ou usando o foreach no Visual C# ou For Each no Visual Basic.The query represented by this method is not executed until the object is enumerated either by calling its GetEnumerator method directly or by using foreach in Visual C# or For Each in 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 source no escopo para a 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>) .The SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>) method is useful when you have to keep the elements of source in scope for query logic that occurs after the call to SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>). Consulte a seção de exemplo para obter um exemplo de código.See the Example section for a code example. 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 TSource objeto que o produziu, você não precisará dessa sobrecarga de SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>) .If there is a bidirectional relationship between objects of type TSource and objects of type TCollection, that is, if an object of type TCollection provides a property to retrieve the TSource object that produced it, you do not need this overload of 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.Instead, you can use SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TResult>>) and navigate back to the TSource object through the TCollection object.

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

Parâmetros

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.An IEnumerable<T> whose elements are the result of invoking the one-to-many transform function on each element of the input sequence.

Exceções

Exemplos

O exemplo de código a seguir demonstra como usar SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TResult>>) o para executar uma projeção de um para muitos em uma matriz.The following code example demonstrates how to use SelectMany<TSource,TResult>(IEnumerable<TSource>, 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.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.This method is implemented by using deferred execution. O valor de retorno imediato é um objeto que armazena todas as informações necessárias para executar a ação.The immediate return value is an object that stores all the information that is required to perform the action. A consulta representada por esse método não é executada até que o objeto seja enumerado chamando o GetEnumerator método diretamente ou usando o foreach no Visual C# ou For Each no Visual Basic.The query represented by this method is not executed until the object is enumerated either by calling its GetEnumerator method directly or by using foreach in Visual C# or For Each in 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 gera os elementos de cada IEnumerable<T> objeto.The SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TResult>>) method enumerates the input sequence, uses a transform function to map each element to an IEnumerable<T>, and then enumerates and yields the elements of each such IEnumerable<T> object. Ou seja, para cada elemento de source , selector é invocado e uma sequência de valores é retornada.That is, for each element of source, selector is invoked and a sequence of values is returned. SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TResult>>) em seguida, achata essa coleção bidimensional de coleções para uma unidimensional IEnumerable<T> e a retorna.SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TResult>>) then flattens this two-dimensional collection of collections into a one-dimensional IEnumerable<T> and returns it. Por exemplo, se uma consulta usar SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TResult>>) para obter os pedidos (do tipo Order ) para cada cliente em um banco de dados, o resultado será do tipo IEnumerable<Order> em C# ou IEnumerable(Of Order) em Visual Basic.For example, if a query uses SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TResult>>) to obtain the orders (of type Order) for each customer in a database, the result is of type IEnumerable<Order> in C# or IEnumerable(Of Order) in Visual Basic. Se, em vez disso, a consulta usar Select para obter os pedidos, 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)) em Visual Basic.If instead the query uses Select to obtain the orders, the collection of collections of orders is not combined and the result is of type IEnumerable<List<Order>> in C# or IEnumerable(Of List(Of Order)) in Visual Basic.

Na sintaxe de expressão de consulta, cada from cláusula (Visual C#) ou From cláusula (Visual Basic) após a inicial é convertida em uma invocação de SelectMany .In query expression syntax, each from clause (Visual C#) or From clause (Visual Basic) after the initial one translates to an invocation of SelectMany.

Confira também

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

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

Parâmetros

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.An IEnumerable<T> whose elements are the result of invoking the one-to-many transform function on each element of an input sequence.

Exceções

Exemplos

O exemplo de código a seguir demonstra como usar SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TResult>>) o para executar uma projeção de um para muitos em uma matriz e usar o índice de cada elemento externo.The following code example demonstrates how to use SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TResult>>) to perform a one-to-many projection over an array and use the index of each outer 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" } } };

    // 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.This method is implemented by using deferred execution. O valor de retorno imediato é um objeto que armazena todas as informações necessárias para executar a ação.The immediate return value is an object that stores all the information that is required to perform the action. A consulta representada por esse método não é executada até que o objeto seja enumerado chamando o GetEnumerator método diretamente ou usando o foreach no Visual C# ou For Each no Visual Basic.The query represented by this method is not executed until the object is enumerated either by calling its GetEnumerator method directly or by using foreach in Visual C# or For Each in 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 gera os elementos de cada IEnumerable<T> objeto.The SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TResult>>) method enumerates the input sequence, uses a transform function to map each element to an IEnumerable<T>, and then enumerates and yields the elements of each such IEnumerable<T> object. Ou seja, para cada elemento de source , selector é invocado e uma sequência de valores é retornada.That is, for each element of source, selector is invoked and a sequence of values is returned. SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TResult>>) em seguida, achata essa coleção bidimensional de coleções para uma unidimensional IEnumerable<T> e a retorna.SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TResult>>) then flattens this two-dimensional collection of collections into a one-dimensional IEnumerable<T> and returns it. Por exemplo, se uma consulta usar SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TResult>>) para obter os pedidos (do tipo Order ) para cada cliente em um banco de dados, o resultado será do tipo IEnumerable<Order> em C# ou IEnumerable(Of Order) em Visual Basic.For example, if a query uses SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TResult>>) to obtain the orders (of type Order) for each customer in a database, the result is of type IEnumerable<Order> in C# or IEnumerable(Of Order) in Visual Basic. Se, em vez disso, a consulta usar Select para obter os pedidos, 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)) em Visual Basic.If instead the query uses Select to obtain the orders, the collection of collections of orders is not combined and the result is of type IEnumerable<List<Order>> in C# or IEnumerable(Of List(Of Order)) in Visual Basic.

O primeiro argumento para selector representa o elemento a ser processado.The first argument to selector represents the element to process. O segundo argumento para selector representar o índice de base zero desse elemento na sequência de origem.The second argument to selector represents the zero-based index of that element in the source sequence. Isso pode ser útil se os elementos estiverem em uma ordem conhecida e você desejar fazer algo com um elemento em um índice específico, por exemplo.This can be useful if the elements are in a known order and you want to do something with an element at a particular index, for example. Ele também pode ser útil se você quiser recuperar o índice de um ou mais elementos.It can also be useful if you want to retrieve the index of one or more elements.