Queryable.SelectMany Metod

Definition

Namnområde:: System.Linq

Sammansättningar:: System.Core.dll, System.Linq.Queryable.dll

Sammansättning:: System.Core.dll

Sammansättning:: netstandard.dll

Viktigt

En del information gäller för förhandsversionen av en produkt och kan komma att ändras avsevärt innan produkten blir allmänt tillgänglig. Microsoft lämnar inga garantier, uttryckliga eller underförstådda, avseende informationen som visas här.

Projicerar varje element i en sekvens till en IEnumerable<T> och kombinerar resulterande sekvenser till en sekvens av typen IQueryable<T>.

Överlagringar

Name	Description
SelectMany<TSource,TCollection,TResult>(IQueryable<TSource>, Expression<Func<TSource, Int32,IEnumerable<TCollection>>>, Expression<Func<TSource,TCollection, TResult>>)	Projicerar varje element i en sekvens till ett IEnumerable<T> som innehåller indexet för källelementet som producerade det. En resultatväljarfunktion anropas på varje element i varje mellanliggande sekvens och de resulterande värdena kombineras till en enda, endimensionell sekvens och returneras.
SelectMany<TSource,TCollection,TResult>(IQueryable<TSource>, Expression<Func<TSource, IEnumerable<TCollection>>>, Expression<Func<TSource,TCollection, TResult>>)	Projicerar varje element i en sekvens till en IEnumerable<T> och anropar en resultatväljare på varje element däri. De resulterande värdena från varje mellanliggande sekvens kombineras till en enda, endimensionell sekvens och returneras.
SelectMany<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,Int32,IEnumerable<TResult>>>)	Projicerar varje element i en sekvens till en IEnumerable<T> och kombinerar de resulterande sekvenserna i en sekvens. Indexet för varje källelement används i den projekterade formen av det elementet.
SelectMany<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,IEnumerable<TResult>>>)	Projicerar varje element i en sekvens till en IEnumerable<T> och kombinerar de resulterande sekvenserna i en sekvens.

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

Projicerar varje element i en sekvens till ett IEnumerable<T> som innehåller indexet för källelementet som producerade det. En resultatväljarfunktion anropas på varje element i varje mellanliggande sekvens och de resulterande värdena kombineras till en enda, endimensionell sekvens och returneras.

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)

Typparametrar

TSource

Typen av element sourcei .

TCollection

Typen av mellanliggande element som samlas in av funktionen som representeras av collectionSelector.

TResult

Typ av element i den resulterande sekvensen.

Parametrar

source: IQueryable<TSource>

En sekvens med värden som ska projiceras.

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

En projektionsfunktion som ska tillämpas på varje element i indatasekvensen. den andra parametern för den här funktionen representerar källelementets index.

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

En projektionsfunktion som ska tillämpas på varje element i varje mellanliggande sekvens.

Returer

IQueryable<TResult>

En IQueryable<T> vars element är resultatet av att anropa en-till-många-projektionsfunktionen collectionSelector på varje element i source och sedan mappa vart och ett av dessa sekvenselement och deras motsvarande source element till ett resultatelement.

Undantag

ArgumentNullException

source eller collectionSelector är resultSelectornull.

Kommentarer

Den här metoden har minst en parameter av typen Expression<TDelegate> vars typargument är en av typerna Func<T,TResult> . För dessa parametrar kan du skicka ett lambda-uttryck och kompileras till en Expression<TDelegate>.

Metoden SelectMany<TSource,TCollection,TResult>(IQueryable<TSource>, Expression<Func<TSource, Int32,IEnumerable<TCollection>>>, Expression<Func<TSource,TCollection, TResult>>) genererar en MethodCallExpression som representerar att anropa SelectMany<TSource,TCollection,TResult>(IQueryable<TSource>, Expression<Func<TSource, Int32,IEnumerable<TCollection>>>, Expression<Func<TSource,TCollection, TResult>>) sig själv som en konstruerad generisk metod. Den skickar sedan till CreateQuery(Expression) metoden för den IQueryProvider som representeras av Provider egenskapen för parameternsource.MethodCallExpression

Frågebeteendet som uppstår till följd av att ett uttrycksträd som representerar anrop SelectMany<TSource,TCollection,TResult>(IQueryable<TSource>, Expression<Func<TSource, Int32,IEnumerable<TCollection>>>, Expression<Func<TSource,TCollection, TResult>>) körs beror på implementeringen av source parametertypen. Det förväntade beteendet är att det anropar collectionSelector på varje element source i för att projicera det till ett uppräkningsbart formulär. Varje uppräkningsbart resultat innehåller källelementets index. Sedan anropas funktionen som representeras av resultSelector på varje element i varje mellanliggande sekvens. De resulterande värdena sammanfogas till en enda endimensionell sekvens.

Gäller för

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

Projicerar varje element i en sekvens till en IEnumerable<T> och anropar en resultatväljare på varje element däri. De resulterande värdena från varje mellanliggande sekvens kombineras till en enda, endimensionell sekvens och returneras.

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)

Typparametrar

TSource

Typen av element sourcei .

TCollection

Typen av mellanliggande element som samlas in av funktionen som representeras av collectionSelector.

TResult

Typ av element i den resulterande sekvensen.

Parametrar

source: IQueryable<TSource>

En sekvens med värden som ska projiceras.

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

En projektionsfunktion som ska tillämpas på varje element i indatasekvensen.

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

En projektionsfunktion som ska tillämpas på varje element i varje mellanliggande sekvens.

Returer

IQueryable<TResult>

Undantag

ArgumentNullException

source eller collectionSelector är resultSelectornull.

Exempel

Följande kodexempel visar hur du använder SelectMany<TSource,TCollection,TResult>(IQueryable<TSource>, Expression<Func<TSource, IEnumerable<TCollection>>>, Expression<Func<TSource,TCollection, TResult>>) för att utföra en en-till-många-projektion över en matris. I det här exemplet används en resultatväljare för att behålla källelementet som motsvarar varje mellanliggande sekvens i omfånget för det sista anropet till 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

Kommentarer

Metoden SelectMany<TSource,TCollection,TResult>(IQueryable<TSource>, Expression<Func<TSource, IEnumerable<TCollection>>>, Expression<Func<TSource,TCollection, TResult>>) genererar en MethodCallExpression som representerar att anropa SelectMany<TSource,TCollection,TResult>(IQueryable<TSource>, Expression<Func<TSource, IEnumerable<TCollection>>>, Expression<Func<TSource,TCollection, TResult>>) sig själv som en konstruerad generisk metod. Den skickar sedan till CreateQuery(Expression) metoden för den IQueryProvider som representeras av Provider egenskapen för parameternsource.MethodCallExpression

Frågebeteendet som uppstår till följd av att ett uttrycksträd som representerar anrop SelectMany<TSource,TCollection,TResult>(IQueryable<TSource>, Expression<Func<TSource, IEnumerable<TCollection>>>, Expression<Func<TSource,TCollection, TResult>>) körs beror på implementeringen av source parametertypen. Det förväntade beteendet är att det anropar collectionSelector på varje element source i för att projicera det till ett uppräkningsbart formulär. Sedan anropas funktionen som representeras av resultSelector på varje element i varje mellanliggande sekvens. De resulterande värdena sammanfogas till en enda endimensionell sekvens.

Gäller för

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

Projicerar varje element i en sekvens till en IEnumerable<T> och kombinerar de resulterande sekvenserna i en sekvens. Indexet för varje källelement används i den projekterade formen av det elementet.

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)

Typparametrar

TSource

Typen av element sourcei .

TResult

Typen av element i sekvensen som returneras av funktionen som representeras av selector.

Parametrar

source: IQueryable<TSource>

En sekvens med värden som ska projiceras.

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

En projektionsfunktion som ska tillämpas på varje element. den andra parametern för den här funktionen representerar källelementets index.

Returer

IQueryable<TResult>

En IQueryable<T> vars element är resultatet av att anropa en en-till-många-projektionsfunktion på varje element i indatasekvensen.

Undantag

ArgumentNullException

source eller selector är null.

Exempel

I följande kodexempel visas hur du använder SelectMany<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,Int32,IEnumerable<TResult>>>) för att utföra en en-till-många-projektion över en matris och använda indexet för varje källelement.

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

Kommentarer

Metoden SelectMany<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,Int32,IEnumerable<TResult>>>) genererar en MethodCallExpression som representerar att anropa SelectMany<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,Int32,IEnumerable<TResult>>>) sig själv som en konstruerad generisk metod. Den skickar sedan till CreateQuery(Expression) metoden för den IQueryProvider som representeras av Provider egenskapen för parameternsource.MethodCallExpression

Frågebeteendet som uppstår till följd av att ett uttrycksträd som representerar anrop SelectMany<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,Int32,IEnumerable<TResult>>>) körs beror på implementeringen av source parametertypen. Det förväntade beteendet är att det anropar selector på varje element source i för att projicera det till ett uppräkningsbart formulär. Varje uppräkningsbart resultat innehåller källelementets index. Den sammanfogar sedan de uppräkningsbara resultaten till en enda, endimensionell sekvens.

Gäller för

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

Projicerar varje element i en sekvens till en IEnumerable<T> och kombinerar de resulterande sekvenserna i en sekvens.

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)

Typparametrar

TSource

Typen av element sourcei .

TResult

Typen av element i sekvensen som returneras av funktionen som representeras av selector.

Parametrar

source: IQueryable<TSource>

En sekvens med värden som ska projiceras.

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

En projektionsfunktion som ska tillämpas på varje element.

Returer

IQueryable<TResult>

En IQueryable<T> vars element är resultatet av att anropa en en-till-många-projektionsfunktion på varje element i indatasekvensen.

Undantag

ArgumentNullException

source eller selector är null.

Exempel

Följande kodexempel visar hur du använder SelectMany<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,IEnumerable<TResult>>>) för att utföra en en-till-många-projektion över en matris.

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

Kommentarer

Metoden SelectMany<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,IEnumerable<TResult>>>) genererar en MethodCallExpression som representerar att anropa SelectMany<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,IEnumerable<TResult>>>) sig själv som en konstruerad generisk metod. Den skickar sedan till CreateQuery(Expression) metoden för den IQueryProvider som representeras av Provider egenskapen för parameternsource.MethodCallExpression

Frågebeteendet som uppstår till följd av att ett uttrycksträd som representerar anrop SelectMany<TSource,TResult>(IQueryable<TSource>, Expression<Func<TSource,IEnumerable<TResult>>>) körs beror på implementeringen av source parametertypen. Det förväntade beteendet är att det anropar selector på varje element source i för att projicera det till ett uppräkningsbart formulär. Den sammanfogar sedan de uppräkningsbara resultaten till en enda, endimensionell sekvens.

Gäller för

Feedback

Var den här sidan till hjälp?