Queryable.SelectMany Metoda

Definice

Projekty jednotlivé prvky sekvence IEnumerable<T> a kombinuje výsledné sekvence do jedné sekvence typu IQueryable<T> .Projects each element of a sequence to an IEnumerable<T> and combines the resulting sequences into one sequence of type IQueryable<T>.

Přetížení

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

Projektuje každý prvek sekvence do objektu IEnumerable<T> , který zahrnuje index zdrojového elementu, který ho vytvořil.Projects each element of a sequence to an IEnumerable<T> that incorporates the index of the source element that produced it. Funkce selektor výsledku je vyvolána u každého prvku každé mezilehlé sekvence a výsledné hodnoty jsou zkombinovány do jediné jednorozměrné sekvence a vrácena.A result selector function is invoked on each element of each intermediate sequence, and the resulting values are combined into a single, one-dimensional sequence and returned.

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

Projekty každý prvek sekvence IEnumerable<T> a vyvolá funkci selektor výsledku pro každý prvek v rámci.Projects each element of a sequence to an IEnumerable<T> and invokes a result selector function on each element therein. Výsledné hodnoty z každé mezilehlé sekvence jsou zkombinovány do jediné jednorozměrné sekvence a vrácena.The resulting values from each intermediate sequence are combined into a single, one-dimensional sequence and returned.

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

Projekty jednotlivé prvky sekvence IEnumerable<T> a kombinuje výsledné sekvence do jedné sekvence.Projects each element of a sequence to an IEnumerable<T> and combines the resulting sequences into one sequence. Index každého zdrojového elementu se používá v projektované podobě daného prvku.The index of each source element is used in the projected form of that element.

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

Projekty jednotlivé prvky sekvence IEnumerable<T> a kombinuje výsledné sekvence do jedné sekvence.Projects each element of a sequence to an IEnumerable<T> and combines the resulting sequences into one sequence.

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

Projektuje každý prvek sekvence do objektu IEnumerable<T> , který zahrnuje index zdrojového elementu, který ho vytvořil.Projects each element of a sequence to an IEnumerable<T> that incorporates the index of the source element that produced it. Funkce selektor výsledku je vyvolána u každého prvku každé mezilehlé sekvence a výsledné hodnoty jsou zkombinovány do jediné jednorozměrné sekvence a vrácena.A result selector function is invoked on each element of each intermediate sequence, and the resulting values are combined into a single, one-dimensional sequence and returned.

public:
generic <typename TSource, typename TCollection, typename TResult>
[System::Runtime::CompilerServices::Extension]
 static System::Linq::IQueryable<TResult> ^ SelectMany(System::Linq::IQueryable<TSource> ^ source, System::Linq::Expressions::Expression<Func<TSource, int, System::Collections::Generic::IEnumerable<TCollection> ^> ^> ^ collectionSelector, System::Linq::Expressions::Expression<Func<TSource, TCollection, TResult> ^> ^ resultSelector);
public static System.Linq.IQueryable<TResult> SelectMany<TSource,TCollection,TResult> (this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<Func<TSource,int,System.Collections.Generic.IEnumerable<TCollection>>> collectionSelector, System.Linq.Expressions.Expression<Func<TSource,TCollection,TResult>> resultSelector);
static member SelectMany : System.Linq.IQueryable<'Source> * System.Linq.Expressions.Expression<Func<'Source, int, seq<'Collection>>> * System.Linq.Expressions.Expression<Func<'Source, 'Collection, 'Result>> -> System.Linq.IQueryable<'Result>
<Extension()>
Public Function SelectMany(Of TSource, TCollection, TResult) (source As IQueryable(Of TSource), collectionSelector As Expression(Of Func(Of TSource, Integer, IEnumerable(Of TCollection))), resultSelector As Expression(Of Func(Of TSource, TCollection, TResult))) As IQueryable(Of TResult)

Parametry typu

TSource

Typ prvků source .The type of the elements of source.

TCollection

Typ zprostředkujících prvků shromažďovaných funkcí reprezentovanou collectionSelector .The type of the intermediate elements collected by the function represented by collectionSelector.

TResult

Typ prvků výsledné sekvence.The type of the elements of the resulting sequence.

Parametry

source
IQueryable<TSource>

Sekvence hodnot do projektu.A sequence of values to project.

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

Funkce projekce, která se má použít u každého prvku vstupní sekvence; druhý parametr této funkce představuje index zdrojového elementu.A projection function to apply to each element of the input sequence; the second parameter of this function represents the index of the source element.

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

Funkce projekce, která se má použít u každého prvku v každé mezilehlé sekvenci.A projection function to apply to each element of each intermediate sequence.

Návraty

IQueryable<TResult>

IQueryable<T>Jejichž prvky jsou výsledkem vyvolání funkce projekce 1: n collectionSelector u každého prvku source a poté mapování každého z těchto elementů sekvence a jejich odpovídajícího source prvku na výsledný element.An IQueryable<T> whose elements are the result of invoking the one-to-many projection function collectionSelector on each element of source and then mapping each of those sequence elements and their corresponding source element to a result element.

Výjimky

source nebo collectionSelector resultSelector je null .source or collectionSelector or resultSelector is null.

Poznámky

Tato metoda má alespoň jeden parametr typu, Expression<TDelegate> jehož argumentem typu je jeden z Func<T,TResult> typů.This method has at least one parameter of type Expression<TDelegate> whose type argument is one of the Func<T,TResult> types. Pro tyto parametry můžete předat výraz lambda a bude zkompilován do Expression<TDelegate> .For these parameters, you can pass in a lambda expression and it will be compiled to an Expression<TDelegate>.

SelectMany<TSource,TCollection,TResult>(IQueryable<TSource>, Expression<Func<TSource,Int32,IEnumerable<TCollection>>>, Expression<Func<TSource,TCollection,TResult>>)Metoda generuje MethodCallExpression , který reprezentuje volání SelectMany<TSource,TCollection,TResult>(IQueryable<TSource>, Expression<Func<TSource,Int32,IEnumerable<TCollection>>>, Expression<Func<TSource,TCollection,TResult>>) sebe sama jako vytvořenou obecnou metodu.The SelectMany<TSource,TCollection,TResult>(IQueryable<TSource>, Expression<Func<TSource,Int32,IEnumerable<TCollection>>>, Expression<Func<TSource,TCollection,TResult>>) method generates a MethodCallExpression that represents calling SelectMany<TSource,TCollection,TResult>(IQueryable<TSource>, Expression<Func<TSource,Int32,IEnumerable<TCollection>>>, Expression<Func<TSource,TCollection,TResult>>) itself as a constructed generic method. Poté předá MethodCallExpression CreateQuery(Expression) metodě IQueryProvider reprezentované Provider vlastností source parametru.It then passes the MethodCallExpression to the CreateQuery(Expression) method of the IQueryProvider represented by the Provider property of the source parameter.

Chování dotazu, k němuž dojde v důsledku provádění stromu výrazu, který představuje volání, SelectMany<TSource,TCollection,TResult>(IQueryable<TSource>, Expression<Func<TSource,Int32,IEnumerable<TCollection>>>, Expression<Func<TSource,TCollection,TResult>>) závisí na implementaci typu source parametru.The query behavior that occurs as a result of executing an expression tree that represents calling SelectMany<TSource,TCollection,TResult>(IQueryable<TSource>, Expression<Func<TSource,Int32,IEnumerable<TCollection>>>, Expression<Func<TSource,TCollection,TResult>>) depends on the implementation of the type of the source parameter. Očekávané chování je, že vyvolá collectionSelector v každém elementu source pro jeho projektování do vyčíslitelného formátu.The expected behavior is that it invokes collectionSelector on each element of source to project it into an enumerable form. Každý vyčíslitelné výsledek zahrnuje index zdrojového elementu.Each enumerable result incorporates the source element's index. Poté funkce reprezentovaná funkcí resultSelector je vyvolána pro každý prvek v každé mezilehlé sekvenci.Then the function represented by resultSelector is invoked on each element in each intermediate sequence. Výsledné hodnoty jsou zřetězeny do jediné jednorozměrné sekvence.The resulting values are concatenated into a single, one-dimensional sequence.

Platí pro

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

Projekty každý prvek sekvence IEnumerable<T> a vyvolá funkci selektor výsledku pro každý prvek v rámci.Projects each element of a sequence to an IEnumerable<T> and invokes a result selector function on each element therein. Výsledné hodnoty z každé mezilehlé sekvence jsou zkombinovány do jediné jednorozměrné sekvence a vrácena.The resulting values from each intermediate sequence are combined into a single, one-dimensional sequence and returned.

public:
generic <typename TSource, typename TCollection, typename TResult>
[System::Runtime::CompilerServices::Extension]
 static System::Linq::IQueryable<TResult> ^ SelectMany(System::Linq::IQueryable<TSource> ^ source, System::Linq::Expressions::Expression<Func<TSource, System::Collections::Generic::IEnumerable<TCollection> ^> ^> ^ collectionSelector, System::Linq::Expressions::Expression<Func<TSource, TCollection, TResult> ^> ^ resultSelector);
public static System.Linq.IQueryable<TResult> SelectMany<TSource,TCollection,TResult> (this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<Func<TSource,System.Collections.Generic.IEnumerable<TCollection>>> collectionSelector, System.Linq.Expressions.Expression<Func<TSource,TCollection,TResult>> resultSelector);
static member SelectMany : System.Linq.IQueryable<'Source> * System.Linq.Expressions.Expression<Func<'Source, seq<'Collection>>> * System.Linq.Expressions.Expression<Func<'Source, 'Collection, 'Result>> -> System.Linq.IQueryable<'Result>
<Extension()>
Public Function SelectMany(Of TSource, TCollection, TResult) (source As IQueryable(Of TSource), collectionSelector As Expression(Of Func(Of TSource, IEnumerable(Of TCollection))), resultSelector As Expression(Of Func(Of TSource, TCollection, TResult))) As IQueryable(Of TResult)

Parametry typu

TSource

Typ prvků source .The type of the elements of source.

TCollection

Typ zprostředkujících prvků shromažďovaných funkcí reprezentovanou collectionSelector .The type of the intermediate elements collected by the function represented by collectionSelector.

TResult

Typ prvků výsledné sekvence.The type of the elements of the resulting sequence.

Parametry

source
IQueryable<TSource>

Sekvence hodnot do projektu.A sequence of values to project.

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

Funkce projekce, která se má použít u každého prvku vstupní sekvenceA projection function to apply to each element of the input sequence.

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

Funkce projekce, která se má použít u každého prvku v každé mezilehlé sekvenci.A projection function to apply to each element of each intermediate sequence.

Návraty

IQueryable<TResult>

IQueryable<T>Jejichž prvky jsou výsledkem vyvolání funkce projekce 1: n collectionSelector u každého prvku source a poté mapování každého z těchto elementů sekvence a jejich odpovídajícího source prvku na výsledný element.An IQueryable<T> whose elements are the result of invoking the one-to-many projection function collectionSelector on each element of source and then mapping each of those sequence elements and their corresponding source element to a result element.

Výjimky

source nebo collectionSelector resultSelector je null .source or collectionSelector or resultSelector is null.

Příklady

Následující příklad kódu ukazuje, jak použít SelectMany<TSource,TCollection,TResult>(IQueryable<TSource>, Expression<Func<TSource,IEnumerable<TCollection>>>, Expression<Func<TSource,TCollection,TResult>>) k provedení projekce 1: n nad polem.The following code example demonstrates how to use SelectMany<TSource,TCollection,TResult>(IQueryable<TSource>, Expression<Func<TSource,IEnumerable<TCollection>>>, Expression<Func<TSource,TCollection,TResult>>) to perform a one-to-many projection over an array. Tento příklad používá funkci selektor výsledku k udržení zdrojového elementu, který odpovídá každé mezilehlé sekvenci v rozsahu pro konečné volání Select .This example uses a result selector function to keep the source element that corresponds to each intermediate sequence in scope for the final call to Select.

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

class Pet
{
    public string Name { get; set; }
    public string Breed { get; set; }
}

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

    // This query demonstrates how to obtain a sequence of
    // the names of all the pets whose breed is "Collie", while
    // keeping an association with the owner that owns the pet.
    var query =
        petOwners.AsQueryable()
        // Create a sequence of ALL the Pet objects. Then
        // project an anonymous type that consists of each
        // Pet in the new sequence and the PetOwner object
        // from the initial array that corresponds to that pet.
       .SelectMany(owner => owner.Pets,
                   (owner, pet) => new { owner, pet })
        // Filter the sequence of anonymous types to only
        // keep pets whose breed is "Collie".
        .Where(ownerAndPet => ownerAndPet.pet.Breed == "Collie")
        // Project an anonymous type that consists
        // of the pet owner's name and the pet's name.
        .Select(ownerAndPet => new
        {
            Owner = ownerAndPet.owner.Name,
            Pet = ownerAndPet.pet.Name
        });

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

/* This code produces the following output:

    { Owner = Ashkenazi, Pet = Walker }
    { Owner = Price, Pet = Diesel }
    { Owner = Hines, Pet = Dusty }
*/

Structure PetOwner
    Public Name As String
    Public Pets As List(Of Pet)
End Structure

Structure Pet
    Public Name As String
    Public Breed As String
End Structure

Shared Sub SelectManyEx3()
    Dim petOwners() As PetOwner = _
                {New PetOwner With {.Name = "Higa", _
                      .Pets = New List(Of Pet)(New Pet() { _
                          New Pet With {.Name = "Scruffy", .Breed = "Poodle"}, _
                          New Pet With {.Name = "Sam", .Breed = "Hound"}})}, _
                  New PetOwner With {.Name = "Ashkenazi", _
                      .Pets = New List(Of Pet)(New Pet() { _
                          New Pet With {.Name = "Walker", .Breed = "Collie"}, _
                          New Pet With {.Name = "Sugar", .Breed = "Poodle"}})}, _
                  New PetOwner With {.Name = "Price", _
                      .Pets = New List(Of Pet)(New Pet() { _
                          New Pet With {.Name = "Scratches", .Breed = "Dachshund"}, _
                          New Pet With {.Name = "Diesel", .Breed = "Collie"}})}, _
                  New PetOwner With {.Name = "Hines", _
                      .Pets = New List(Of Pet)(New Pet() { _
                          New Pet With {.Name = "Dusty", .Breed = "Collie"}})} _
                }

    ' This query demonstrates how to obtain a sequence of
    ' the names of all the pets whose breed is "Collie", while
    ' keeping an association with the owner that owns the pet.
    Dim query = petOwners.AsQueryable() _
        .SelectMany(Function(owner) owner.Pets, _
               Function(owner, pet) New With {owner, pet}) _
        .Where(Function(ownerAndPet) ownerAndPet.pet.Breed = "Collie") _
        .Select(Function(ownerAndPet) New With { _
            .Owner = ownerAndPet.owner.Name, _
            .Pet = ownerAndPet.pet.Name})

    Dim output As New System.Text.StringBuilder
    For Each obj In query
        output.AppendLine(String.Format("Owner={0}, Pet={1}", obj.Owner, obj.Pet))
    Next

    ' Display the output.
    MsgBox(output.ToString())
End Sub

' This code produces the following output:

' Owner=Ashkenazi, Pet=Walker
' Owner=Price, Pet=Diesel
' Owner=Hines, Pet=Dusty

Poznámky

Tato metoda má alespoň jeden parametr typu, Expression<TDelegate> jehož argumentem typu je jeden z Func<T,TResult> typů.This method has at least one parameter of type Expression<TDelegate> whose type argument is one of the Func<T,TResult> types. Pro tyto parametry můžete předat výraz lambda a bude zkompilován do Expression<TDelegate> .For these parameters, you can pass in a lambda expression and it will be compiled to an Expression<TDelegate>.

SelectMany<TSource,TCollection,TResult>(IQueryable<TSource>, Expression<Func<TSource,IEnumerable<TCollection>>>, Expression<Func<TSource,TCollection,TResult>>)Metoda generuje MethodCallExpression , který reprezentuje volání SelectMany<TSource,TCollection,TResult>(IQueryable<TSource>, Expression<Func<TSource,IEnumerable<TCollection>>>, Expression<Func<TSource,TCollection,TResult>>) sebe sama jako vytvořenou obecnou metodu.The SelectMany<TSource,TCollection,TResult>(IQueryable<TSource>, Expression<Func<TSource,IEnumerable<TCollection>>>, Expression<Func<TSource,TCollection,TResult>>) method generates a MethodCallExpression that represents calling SelectMany<TSource,TCollection,TResult>(IQueryable<TSource>, Expression<Func<TSource,IEnumerable<TCollection>>>, Expression<Func<TSource,TCollection,TResult>>) itself as a constructed generic method. Poté předá MethodCallExpression CreateQuery(Expression) metodě IQueryProvider reprezentované Provider vlastností source parametru.It then passes the MethodCallExpression to the CreateQuery(Expression) method of the IQueryProvider represented by the Provider property of the source parameter.

Chování dotazu, k němuž dojde v důsledku provádění stromu výrazu, který představuje volání, SelectMany<TSource,TCollection,TResult>(IQueryable<TSource>, Expression<Func<TSource,IEnumerable<TCollection>>>, Expression<Func<TSource,TCollection,TResult>>) závisí na implementaci typu source parametru.The query behavior that occurs as a result of executing an expression tree that represents calling SelectMany<TSource,TCollection,TResult>(IQueryable<TSource>, Expression<Func<TSource,IEnumerable<TCollection>>>, Expression<Func<TSource,TCollection,TResult>>) depends on the implementation of the type of the source parameter. Očekávané chování je, že vyvolá collectionSelector v každém elementu source pro jeho projektování do vyčíslitelného formátu.The expected behavior is that it invokes collectionSelector on each element of source to project it into an enumerable form. Poté funkce reprezentovaná funkcí resultSelector je vyvolána pro každý prvek v každé mezilehlé sekvenci.Then the function represented by resultSelector is invoked on each element in each intermediate sequence. Výsledné hodnoty jsou zřetězeny do jediné jednorozměrné sekvence.The resulting values are concatenated into a single, one-dimensional sequence.

Platí pro

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

Projekty jednotlivé prvky sekvence IEnumerable<T> a kombinuje výsledné sekvence do jedné sekvence.Projects each element of a sequence to an IEnumerable<T> and combines the resulting sequences into one sequence. Index každého zdrojového elementu se používá v projektované podobě daného prvku.The index of each source element is used in the projected form of that element.

public:
generic <typename TSource, typename TResult>
[System::Runtime::CompilerServices::Extension]
 static System::Linq::IQueryable<TResult> ^ SelectMany(System::Linq::IQueryable<TSource> ^ source, System::Linq::Expressions::Expression<Func<TSource, int, System::Collections::Generic::IEnumerable<TResult> ^> ^> ^ selector);
public static System.Linq.IQueryable<TResult> SelectMany<TSource,TResult> (this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<Func<TSource,int,System.Collections.Generic.IEnumerable<TResult>>> selector);
static member SelectMany : System.Linq.IQueryable<'Source> * System.Linq.Expressions.Expression<Func<'Source, int, seq<'Result>>> -> System.Linq.IQueryable<'Result>
<Extension()>
Public Function SelectMany(Of TSource, TResult) (source As IQueryable(Of TSource), selector As Expression(Of Func(Of TSource, Integer, IEnumerable(Of TResult)))) As IQueryable(Of TResult)

Parametry typu

TSource

Typ prvků source .The type of the elements of source.

TResult

Typ prvků sekvence vrácených funkcí reprezentovanou selector .The type of the elements of the sequence returned by the function represented by selector.

Parametry

source
IQueryable<TSource>

Sekvence hodnot do projektu.A sequence of values to project.

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

Funkce projekce, která se má použít u každého prvku; druhý parametr této funkce představuje index zdrojového elementu.A projection function to apply to each element; the second parameter of this function represents the index of the source element.

Návraty

IQueryable<TResult>

IQueryable<T>Jejichž prvky jsou výsledkem vyvolání funkce projekce 1:1 u každého prvku vstupní sekvence.An IQueryable<T> whose elements are the result of invoking a one-to-many projection function on each element of the input sequence.

Výjimky

source nebo selector je null .source or selector is null.

Příklady

Následující příklad kódu ukazuje, jak použít SelectMany<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,Int32,IEnumerable<TResult>>>) k provedení projekce 1: n nad polem a použití indexu každého zdrojového elementu.The following code example demonstrates how to use SelectMany<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,Int32,IEnumerable<TResult>>>) to perform a one-to-many projection over an array and use the index of each source element.

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

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

    // For each PetOwner element in the source array,
    // project a sequence of strings where each string
    // consists of the index of the PetOwner element in the
    // source array and the name of each pet in PetOwner.Pets.
    IEnumerable<string> query =
        petOwners.AsQueryable()
        .SelectMany(
        (petOwner, index) => petOwner.Pets.Select(pet => index + pet)
        );

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

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

Structure PetOwner
    Public Name As String
    Public Pets() As String
End Structure

Shared Sub SelectManyEx2()
    Dim petOwners() As PetOwner = _
        {New PetOwner With _
         {.Name = "Higa, Sidney", .Pets = New String() {"Scruffy", "Sam"}}, _
         New PetOwner With _
         {.Name = "Ashkenazi, Ronen", .Pets = New String() {"Walker", "Sugar"}}, _
         New PetOwner With _
         {.Name = "Price, Vernette", .Pets = New String() {"Scratches", "Diesel"}}, _
         New PetOwner With _
         {.Name = "Hines, Patrick", .Pets = New String() {"Dusty"}}}

    ' For each PetOwner element in the source array,
    ' project a sequence of strings where each string
    ' consists of the index of the PetOwner element in the
    ' source array and the name of each pet in PetOwner.Pets.
    Dim query As IEnumerable(Of String) = _
        petOwners.AsQueryable() _
        .SelectMany(Function(petOwner, index) petOwner.Pets.Select(Function(pet) index.ToString() + pet))

    Dim output As New System.Text.StringBuilder
    For Each pet As String In query
        output.AppendLine(pet)
    Next

    ' Display the output.
    MsgBox(output.ToString())
End Sub

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

Poznámky

Tato metoda má alespoň jeden parametr typu, Expression<TDelegate> jehož argumentem typu je jeden z Func<T,TResult> typů.This method has at least one parameter of type Expression<TDelegate> whose type argument is one of the Func<T,TResult> types. Pro tyto parametry můžete předat výraz lambda a bude zkompilován do Expression<TDelegate> .For these parameters, you can pass in a lambda expression and it will be compiled to an Expression<TDelegate>.

SelectMany<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,Int32,IEnumerable<TResult>>>)Metoda generuje MethodCallExpression , který reprezentuje volání SelectMany<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,Int32,IEnumerable<TResult>>>) sebe sama jako vytvořenou obecnou metodu.The SelectMany<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,Int32,IEnumerable<TResult>>>) method generates a MethodCallExpression that represents calling SelectMany<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,Int32,IEnumerable<TResult>>>) itself as a constructed generic method. Poté předá MethodCallExpression CreateQuery(Expression) metodě IQueryProvider reprezentované Provider vlastností source parametru.It then passes the MethodCallExpression to the CreateQuery(Expression) method of the IQueryProvider represented by the Provider property of the source parameter.

Chování dotazu, k němuž dojde v důsledku provádění stromu výrazu, který představuje volání, SelectMany<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,Int32,IEnumerable<TResult>>>) závisí na implementaci typu source parametru.The query behavior that occurs as a result of executing an expression tree that represents calling SelectMany<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,Int32,IEnumerable<TResult>>>) depends on the implementation of the type of the source parameter. Očekávané chování je, že vyvolá selector v každém elementu source pro jeho projektování do vyčíslitelného formátu.The expected behavior is that it invokes selector on each element of source to project it into an enumerable form. Každý vyčíslitelné výsledek zahrnuje index zdrojového elementu.Each enumerable result incorporates the index of the source element. Poté zřetězí výčtové výsledky do jediné jednorozměrné sekvence.It then concatenates the enumerable results into a single, one-dimensional sequence.

Platí pro

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

Projekty jednotlivé prvky sekvence IEnumerable<T> a kombinuje výsledné sekvence do jedné sekvence.Projects each element of a sequence to an IEnumerable<T> and combines the resulting sequences into one sequence.

public:
generic <typename TSource, typename TResult>
[System::Runtime::CompilerServices::Extension]
 static System::Linq::IQueryable<TResult> ^ SelectMany(System::Linq::IQueryable<TSource> ^ source, System::Linq::Expressions::Expression<Func<TSource, System::Collections::Generic::IEnumerable<TResult> ^> ^> ^ selector);
public static System.Linq.IQueryable<TResult> SelectMany<TSource,TResult> (this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<Func<TSource,System.Collections.Generic.IEnumerable<TResult>>> selector);
static member SelectMany : System.Linq.IQueryable<'Source> * System.Linq.Expressions.Expression<Func<'Source, seq<'Result>>> -> System.Linq.IQueryable<'Result>
<Extension()>
Public Function SelectMany(Of TSource, TResult) (source As IQueryable(Of TSource), selector As Expression(Of Func(Of TSource, IEnumerable(Of TResult)))) As IQueryable(Of TResult)

Parametry typu

TSource

Typ prvků source .The type of the elements of source.

TResult

Typ prvků sekvence vrácených funkcí reprezentovanou selector .The type of the elements of the sequence returned by the function represented by selector.

Parametry

source
IQueryable<TSource>

Sekvence hodnot do projektu.A sequence of values to project.

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

Funkce projekce, která se má použít u každého prvkuA projection function to apply to each element.

Návraty

IQueryable<TResult>

IQueryable<T>Jejichž prvky jsou výsledkem vyvolání funkce projekce 1:1 u každého prvku vstupní sekvence.An IQueryable<T> whose elements are the result of invoking a one-to-many projection function on each element of the input sequence.

Výjimky

source nebo selector je null .source or selector is null.

Příklady

Následující příklad kódu ukazuje, jak použít SelectMany<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,IEnumerable<TResult>>>) k provedení projekce 1: n nad polem.The following code example demonstrates how to use SelectMany<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,IEnumerable<TResult>>>) to perform a one-to-many projection over an array.

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

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

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

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

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

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

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

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

/*
    This code produces the following output:

    Using SelectMany():
    Scruffy
    Sam
    Walker
    Sugar
    Scratches
    Diesel

    Using Select():
    Scruffy
    Sam

    Walker
    Sugar

    Scratches
    Diesel
*/

Structure PetOwner
    Public Name As String
    Public Pets() As String
End Structure

Shared Sub SelectManyEx1()
    Dim petOwners() As PetOwner = _
        {New PetOwner With _
         {.Name = "Higa, Sidney", .Pets = New String() {"Scruffy", "Sam"}}, _
         New PetOwner With _
         {.Name = "Ashkenazi, Ronen", .Pets = New String() {"Walker", "Sugar"}}, _
         New PetOwner With _
         {.Name = "Price, Vernette", .Pets = New String() {"Scratches", "Diesel"}}}

    ' Query using SelectMany().
    Dim query1 As IEnumerable(Of String) = _
                petOwners.AsQueryable().SelectMany(Function(petOwner) petOwner.Pets)

    Dim output As New System.Text.StringBuilder("Using SelectMany():" & vbCrLf)
    ' Only one foreach loop is required to iterate through 
    ' the results because it is a one-dimensional collection.
    For Each pet As String In query1
        output.AppendLine(pet)
    Next

    ' This code shows how to use Select() instead of SelectMany().
    Dim query2 As IEnumerable(Of String()) = _
                petOwners.AsQueryable().Select(Function(petOwner) petOwner.Pets)

    output.AppendLine(vbCrLf & "Using Select():")
    ' Notice that two foreach loops are required to iterate through 
    ' the results because the query returns a collection of arrays.
    For Each petArray() As String In query2
        For Each pet As String In petArray
            output.AppendLine(pet)
        Next
    Next

    ' Display the output.
    MsgBox(output.ToString())
End Sub

' This code produces the following output:

' Using SelectMany():
' Scruffy
' Sam
' Walker
' Sugar
' Scratches
' Diesel

' Using Select():
' Scruffy
' Sam
' Walker
' Sugar
' Scratches
' Diesel

Poznámky

Tato metoda má alespoň jeden parametr typu, Expression<TDelegate> jehož argumentem typu je jeden z Func<T,TResult> typů.This method has at least one parameter of type Expression<TDelegate> whose type argument is one of the Func<T,TResult> types. Pro tyto parametry můžete předat výraz lambda a bude zkompilován do Expression<TDelegate> .For these parameters, you can pass in a lambda expression and it will be compiled to an Expression<TDelegate>.

SelectMany<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,IEnumerable<TResult>>>)Metoda generuje MethodCallExpression , který reprezentuje volání SelectMany<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,IEnumerable<TResult>>>) sebe sama jako vytvořenou obecnou metodu.The SelectMany<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,IEnumerable<TResult>>>) method generates a MethodCallExpression that represents calling SelectMany<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,IEnumerable<TResult>>>) itself as a constructed generic method. Poté předá MethodCallExpression CreateQuery(Expression) metodě IQueryProvider reprezentované Provider vlastností source parametru.It then passes the MethodCallExpression to the CreateQuery(Expression) method of the IQueryProvider represented by the Provider property of the source parameter.

Chování dotazu, k němuž dojde v důsledku provádění stromu výrazu, který představuje volání, SelectMany<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,IEnumerable<TResult>>>) závisí na implementaci typu source parametru.The query behavior that occurs as a result of executing an expression tree that represents calling SelectMany<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,IEnumerable<TResult>>>) depends on the implementation of the type of the source parameter. Očekávané chování je, že vyvolá selector v každém elementu source pro jeho projektování do vyčíslitelného formátu.The expected behavior is that it invokes selector on each element of source to project it into an enumerable form. Poté zřetězí výčtové výsledky do jediné jednorozměrné sekvence.It then concatenates the enumerable results into a single, one-dimensional sequence.

Platí pro