Queryable.SelectMany Methode

Definition

Namespace:: System.Linq

Assemblys:: System.Core.dll, System.Linq.Queryable.dll

Assemblys:: netstandard.dll, System.Linq.Queryable.dll

Assembly:: System.Linq.Queryable.dll

Assembly:: System.Core.dll

Assembly:: netstandard.dll

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

Projiziert jedes Element einer Sequenz an eine IEnumerable<T> und kombiniert die resultierenden Sequenzen in einer Sequenz vom Typ IQueryable<T>.

Überlädt

Name	Beschreibung
SelectMany<TSource,TCollection,TResult>(IQueryable<TSource>, Expression<Func<TSource, Int32,IEnumerable<TCollection>>>, Expression<Func<TSource,TCollection, TResult>>)	Projiziert jedes Element einer Sequenz auf ein IEnumerable<T> Element, das den Index des Quellelements enthält, das es erzeugt hat. Für jedes Element jeder Zwischensequenz wird eine Ergebnisauswahlfunktion aufgerufen, und die resultierenden Werte werden in einer einzelnen, eindimensionalen Sequenz kombiniert und zurückgegeben.
SelectMany<TSource,TCollection,TResult>(IQueryable<TSource>, Expression<Func<TSource, IEnumerable<TCollection>>>, Expression<Func<TSource,TCollection, TResult>>)	Projiziert jedes Element einer Sequenz an eine IEnumerable<T> und ruft eine Ergebnismarkierfunktion für jedes Element auf. Die resultierenden Werte aus jeder Zwischensequenz werden in einer einzelnen, eindimensionalen Sequenz kombiniert und zurückgegeben.
SelectMany<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,IEnumerable<TResult>>>)	Projiziert jedes Element einer Sequenz an und IEnumerable<T> kombiniert die resultierenden Sequenzen in einer Sequenz.
SelectMany<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,Int32,IEnumerable<TResult>>>)	Projiziert jedes Element einer Sequenz an und IEnumerable<T> kombiniert die resultierenden Sequenzen in einer Sequenz. Der Index der einzelnen Quellelemente wird in der projizierten Form dieses Elements verwendet.

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

Quelle:: Queryable.cs

Quelle:: Queryable.cs

Quelle:: Queryable.cs

Quelle:: Queryable.cs

Quelle:: Queryable.cs

Projiziert jedes Element einer Sequenz auf ein IEnumerable<T> Element, das den Index des Quellelements enthält, das es erzeugt hat. Für jedes Element jeder Zwischensequenz wird eine Ergebnisauswahlfunktion aufgerufen, und die resultierenden Werte werden in einer einzelnen, eindimensionalen Sequenz kombiniert und zurückgegeben.

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);

[System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
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>

[<System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")>]
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)

Typparameter

TSource

Der Typ der Elemente von source.

TCollection

Der Typ der zwischengeschalteten Elemente, die von der durch dargestellten collectionSelectorFunktion gesammelt werden.

TResult

Der Typ der Elemente der resultierenden Sequenz.

Parameter

source: IQueryable<TSource>

Eine Abfolge von Werten, die projiziert werden sollen.

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

Eine Projektionsfunktion, die auf jedes Element der Eingabesequenz angewendet werden soll; Der zweite Parameter dieser Funktion stellt den Index des Quellelements dar.

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

Eine Projektionsfunktion, die auf jedes Element jeder Zwischensequenz angewendet werden soll.

Gibt zurück

IQueryable<TResult>

Ein IQueryable<T> Element, dessen Elemente das Ergebnis des Aufrufens der 1:n-Projektionsfunktion collectionSelector für jedes Element sind source und dann jedes dieser Sequenzelemente und das entsprechende source Element einem Ergebniselement zuordnen.

Attribute: RequiresDynamicCodeAttribute

Ausnahmen

ArgumentNullException

sourceoder collectionSelectorresultSelector ist .null

Hinweise

Diese Methode verfügt über mindestens einen Typparameter Expression<TDelegate> , dessen Typargument einer der Func<T,TResult> Typen ist. Für diese Parameter können Sie einen Lambda-Ausdruck übergeben und zu einem Expression<TDelegate>.

Die SelectMany<TSource,TCollection,TResult>(IQueryable<TSource>, Expression<Func<TSource, Int32,IEnumerable<TCollection>>>, Expression<Func<TSource,TCollection, TResult>>) Methode generiert eine MethodCallExpression , die den Aufruf SelectMany<TSource,TCollection,TResult>(IQueryable<TSource>, Expression<Func<TSource, Int32,IEnumerable<TCollection>>>, Expression<Func<TSource,TCollection, TResult>>) selbst als konstruierte generische Methode darstellt. Anschließend wird die MethodCallExpression Methode der CreateQuery(Expression)IQueryProvider durch die Provider Eigenschaft des source Parameters dargestellten Methode übergeben.

Das Abfrageverhalten, das als Ergebnis der Ausführung einer Ausdrucksstruktur auftritt, die aufruft SelectMany<TSource,TCollection,TResult>(IQueryable<TSource>, Expression<Func<TSource, Int32,IEnumerable<TCollection>>>, Expression<Func<TSource,TCollection, TResult>>) , hängt von der Implementierung des Typs des source Parameters ab. Das erwartete Verhalten besteht darin, dass es für jedes Element aufgerufen wird, das source es in ein aufzählbares Formular projiziertcollectionSelector. Jedes aufzählbare Ergebnis enthält den Index des Quellelements. Anschließend wird die dargestellte resultSelector Funktion für jedes Element in jeder Zwischensequenz aufgerufen. Die resultierenden Werte werden in eine einzelne eindimensionale Sequenz verkettet.

Gilt für:

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

Quelle:: Queryable.cs

Quelle:: Queryable.cs

Quelle:: Queryable.cs

Quelle:: Queryable.cs

Quelle:: Queryable.cs

Projiziert jedes Element einer Sequenz an eine IEnumerable<T> und ruft eine Ergebnismarkierfunktion für jedes Element auf. Die resultierenden Werte aus jeder Zwischensequenz werden in einer einzelnen, eindimensionalen Sequenz kombiniert und zurückgegeben.

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);

[System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
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>

[<System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")>]
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)

Typparameter

TSource

Der Typ der Elemente von source.

TCollection

Der Typ der zwischengeschalteten Elemente, die von der durch dargestellten collectionSelectorFunktion gesammelt werden.

TResult

Der Typ der Elemente der resultierenden Sequenz.

Parameter

source: IQueryable<TSource>

Eine Abfolge von Werten, die projiziert werden sollen.

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

Eine Projektionsfunktion, die auf jedes Element der Eingabesequenz angewendet werden soll.

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

Eine Projektionsfunktion, die auf jedes Element jeder Zwischensequenz angewendet werden soll.

Gibt zurück

IQueryable<TResult>

Attribute: RequiresDynamicCodeAttribute

Ausnahmen

ArgumentNullException

sourceoder collectionSelectorresultSelector ist .null

Beispiele

Im folgenden Codebeispiel wird veranschaulicht, wie Sie SelectMany<TSource,TCollection,TResult>(IQueryable<TSource>, Expression<Func<TSource, IEnumerable<TCollection>>>, Expression<Func<TSource,TCollection, TResult>>) eine 1:n-Projektion über ein Array ausführen. In diesem Beispiel wird eine Ergebnisauswahlfunktion verwendet, um das Quellelement beizubehalten, das jeder Zwischensequenz im Bereich für den endgültigen Aufruf Selectentspricht.

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

Hinweise

Die SelectMany<TSource,TCollection,TResult>(IQueryable<TSource>, Expression<Func<TSource, IEnumerable<TCollection>>>, Expression<Func<TSource,TCollection, TResult>>) Methode generiert eine MethodCallExpression , die den Aufruf SelectMany<TSource,TCollection,TResult>(IQueryable<TSource>, Expression<Func<TSource, IEnumerable<TCollection>>>, Expression<Func<TSource,TCollection, TResult>>) selbst als konstruierte generische Methode darstellt. Anschließend wird die MethodCallExpression Methode der CreateQuery(Expression)IQueryProvider durch die Provider Eigenschaft des source Parameters dargestellten Methode übergeben.

Das Abfrageverhalten, das als Ergebnis der Ausführung einer Ausdrucksstruktur auftritt, die aufruft SelectMany<TSource,TCollection,TResult>(IQueryable<TSource>, Expression<Func<TSource, IEnumerable<TCollection>>>, Expression<Func<TSource,TCollection, TResult>>) , hängt von der Implementierung des Typs des source Parameters ab. Das erwartete Verhalten besteht darin, dass es für jedes Element aufgerufen wird, das source es in ein aufzählbares Formular projiziertcollectionSelector. Anschließend wird die dargestellte resultSelector Funktion für jedes Element in jeder Zwischensequenz aufgerufen. Die resultierenden Werte werden in eine einzelne eindimensionale Sequenz verkettet.

Gilt für:

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

Quelle:: Queryable.cs

Quelle:: Queryable.cs

Quelle:: Queryable.cs

Quelle:: Queryable.cs

Quelle:: Queryable.cs

Projiziert jedes Element einer Sequenz an und IEnumerable<T> kombiniert die resultierenden Sequenzen in einer Sequenz.

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);

[System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
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>

[<System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")>]
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)

Typparameter

TSource

Der Typ der Elemente von source.

TResult

Der Typ der Elemente der Sequenz, die von der funktion zurückgegeben wird, dargestellt durch selector.

Parameter

source: IQueryable<TSource>

Eine Abfolge von Werten, die projiziert werden sollen.

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

Eine Projektionsfunktion, die auf jedes Element angewendet werden soll.

Gibt zurück

IQueryable<TResult>

Ein IQueryable<T> Element, dessen Elemente das Ergebnis des Aufrufens einer 1:n-Projektionsfunktion für jedes Element der Eingabesequenz sind.

Attribute: RequiresDynamicCodeAttribute

Ausnahmen

ArgumentNullException

source oder selector ist null.

Beispiele

Im folgenden Codebeispiel wird veranschaulicht, wie Sie SelectMany<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,IEnumerable<TResult>>>) eine 1:n-Projektion über ein Array ausführen.

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

Hinweise

Die SelectMany<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,IEnumerable<TResult>>>) Methode generiert eine MethodCallExpression , die den Aufruf SelectMany<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,IEnumerable<TResult>>>) selbst als konstruierte generische Methode darstellt. Anschließend wird die MethodCallExpression Methode der CreateQuery(Expression)IQueryProvider durch die Provider Eigenschaft des source Parameters dargestellten Methode übergeben.

Das Abfrageverhalten, das als Ergebnis der Ausführung einer Ausdrucksstruktur auftritt, die aufruft SelectMany<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,IEnumerable<TResult>>>) , hängt von der Implementierung des Typs des source Parameters ab. Das erwartete Verhalten besteht darin, dass es für jedes Element aufgerufen wird, das source es in ein aufzählbares Formular projiziertselector. Anschließend verkettet sie die aufzählbaren Ergebnisse in einer einzelnen, eindimensionalen Sequenz.

Gilt für:

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

Quelle:: Queryable.cs

Quelle:: Queryable.cs

Quelle:: Queryable.cs

Quelle:: Queryable.cs

Quelle:: Queryable.cs

Projiziert jedes Element einer Sequenz an und IEnumerable<T> kombiniert die resultierenden Sequenzen in einer Sequenz. Der Index der einzelnen Quellelemente wird in der projizierten Form dieses Elements verwendet.

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);

[System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")]
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>

[<System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")>]
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)

Typparameter

TSource

Der Typ der Elemente von source.

TResult

Der Typ der Elemente der Sequenz, die von der funktion zurückgegeben wird, dargestellt durch selector.

Parameter

source: IQueryable<TSource>

Eine Abfolge von Werten, die projiziert werden sollen.

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

Eine Projektionsfunktion, die auf jedes Element angewendet werden soll; Der zweite Parameter dieser Funktion stellt den Index des Quellelements dar.

Gibt zurück

IQueryable<TResult>

Ein IQueryable<T> Element, dessen Elemente das Ergebnis des Aufrufens einer 1:n-Projektionsfunktion für jedes Element der Eingabesequenz sind.

Attribute: RequiresDynamicCodeAttribute

Ausnahmen

ArgumentNullException

source oder selector ist null.

Beispiele

Im folgenden Codebeispiel wird veranschaulicht, wie Sie SelectMany<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,Int32,IEnumerable<TResult>>>) eine 1:n-Projektion über ein Array ausführen und den Index der einzelnen Quellelemente verwenden.

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

Hinweise

Die SelectMany<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,Int32,IEnumerable<TResult>>>) Methode generiert eine MethodCallExpression , die den Aufruf SelectMany<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,Int32,IEnumerable<TResult>>>) selbst als konstruierte generische Methode darstellt. Anschließend wird die MethodCallExpression Methode der CreateQuery(Expression)IQueryProvider durch die Provider Eigenschaft des source Parameters dargestellten Methode übergeben.

Das Abfrageverhalten, das als Ergebnis der Ausführung einer Ausdrucksstruktur auftritt, die aufruft SelectMany<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,Int32,IEnumerable<TResult>>>) , hängt von der Implementierung des Typs des source Parameters ab. Das erwartete Verhalten besteht darin, dass es für jedes Element aufgerufen wird, das source es in ein aufzählbares Formular projiziertselector. Jedes aufzählbare Ergebnis enthält den Index des Quellelements. Anschließend verkettet sie die aufzählbaren Ergebnisse in einer einzelnen, eindimensionalen Sequenz.

Gilt für:

Feedback

War diese Seite hilfreich?

Freigeben über

Queryable.SelectMany Methode

Definition

Überlädt

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

Typparameter

Parameter

Gibt zurück

Ausnahmen

Hinweise

Gilt für:

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

Typparameter

Parameter

Gibt zurück

Ausnahmen

Beispiele

Hinweise

Gilt für:

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

Typparameter

Parameter

Gibt zurück

Ausnahmen

Beispiele

Hinweise

Gilt für:

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

Typparameter

Parameter

Gibt zurück

Ausnahmen

Beispiele

Hinweise

Gilt für:

Feedback