Enumerable.SelectMany Metod

public:
generic <typename TSource, typename TCollection, typename TResult>
[System::Runtime::CompilerServices::Extension]
 static System::Collections::Generic::IEnumerable<TResult> ^ SelectMany(System::Collections::Generic::IEnumerable<TSource> ^ source, Func<TSource, System::Collections::Generic::IEnumerable<TCollection> ^> ^ collectionSelector, Func<TSource, TCollection, TResult> ^ resultSelector);

public static System.Collections.Generic.IEnumerable<TResult> SelectMany<TSource,TCollection,TResult>(this System.Collections.Generic.IEnumerable<TSource> source, Func<TSource,System.Collections.Generic.IEnumerable<TCollection>> collectionSelector, Func<TSource,TCollection,TResult> resultSelector);

static member SelectMany : seq<'Source> * Func<'Source, seq<'Collection>> * Func<'Source, 'Collection, 'Result> -> seq<'Result>

<Extension()>
Public Function SelectMany(Of TSource, TCollection, TResult) (source As IEnumerable(Of TSource), collectionSelector As Func(Of TSource, IEnumerable(Of TCollection)), resultSelector As Func(Of TSource, TCollection, TResult)) As IEnumerable(Of TResult)

Typparametrar

Parametrar

Returer

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

Undantag

Exempel

Följande kodexempel visar hur du använder SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>) för att utföra en en-till-många-projektion över en matris och använder en resultatväljare för att hålla varje motsvarande element från källsekvensen i omfånget för det slutliga anropet till Select.

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

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

    // Project the pet owner's name and the pet's name.
    var query =
        petOwners
        .SelectMany(petOwner => petOwner.Pets, (petOwner, petName) => new { petOwner, petName })
        .Where(ownerAndPet => ownerAndPet.petName.StartsWith("S"))
        .Select(ownerAndPet =>
                new
                {
                    Owner = ownerAndPet.petOwner.Name,
                    Pet = ownerAndPet.petName
                }
        );

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

// This code produces the following output:
//
// {Owner=Higa, Pet=Scruffy}
// {Owner=Higa, Pet=Sam}
// {Owner=Ashkenazi, Pet=Sugar}
// {Owner=Price, Pet=Scratches}

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

Sub SelectManyEx3()
    ' Create an array of PetOwner objects.
    Dim petOwners() As PetOwner =
{New PetOwner With
 {.Name = "Higa", .Pets = New String() {"Scruffy", "Sam"}},
 New PetOwner With
 {.Name = "Ashkenazi", .Pets = New String() {"Walker", "Sugar"}},
 New PetOwner With
 {.Name = "Price", .Pets = New String() {"Scratches", "Diesel"}},
 New PetOwner With
 {.Name = "Hines", .Pets = New String() {"Dusty"}}}

    ' Project an anonymous type that consists of
    ' the owner's name and the pet's name (string).
    Dim query =
petOwners _
.SelectMany(
    Function(petOwner) petOwner.Pets,
    Function(petOwner, petName) New With {petOwner, petName}) _
.Where(Function(ownerAndPet) ownerAndPet.petName.StartsWith("S")) _
.Select(Function(ownerAndPet) _
       New With {.Owner = ownerAndPet.petOwner.Name,
                 .Pet = ownerAndPet.petName
       })

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

    ' Display the output.
    Console.WriteLine(output.ToString())
End Sub

' This code produces the following output:
'
' Owner=Higa, Pet=Scruffy
' Owner=Higa, Pet=Sam
' Owner=Ashkenazi, Pet=Sugar
' Owner=Price, Pet=Scratches

Kommentarer

Den här metoden implementeras med uppskjuten körning. Det omedelbara returvärdet är ett objekt som lagrar all information som krävs för att utföra åtgärden. Frågan som representeras av den här metoden körs inte förrän objektet räknas upp antingen genom att anropa metoden GetEnumerator direkt eller med hjälp av foreach i C# eller For Each i Visual Basic.

Metoden SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>) är användbar när du måste behålla elementen source i i omfånget för frågelogik som inträffar efter anropet till SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>). Se avsnittet Exempel för ett kodexempel. Om det finns en dubbelriktad relation mellan objekt av typen TSource och objekt av typen TCollection, d.v.s. om ett objekt av typen TCollection tillhandahåller en egenskap för att hämta TSource objektet som skapade det, behöver du inte den här överlagringen av SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>). I stället kan du använda SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TResult>>) och gå tillbaka till TSource objektet via objektet TCollection .

I frågeuttryckssyntaxen översätts varje from-sats (C#) eller From-sats (Visual Basic) efter att den första översätts till ett anrop av SelectMany.

Se även

• from-sats (C#-referens)
• From-sats (Visual Basic)

public:
generic <typename TSource, typename TCollection, typename TResult>
[System::Runtime::CompilerServices::Extension]
 static System::Collections::Generic::IEnumerable<TResult> ^ SelectMany(System::Collections::Generic::IEnumerable<TSource> ^ source, Func<TSource, int, System::Collections::Generic::IEnumerable<TCollection> ^> ^ collectionSelector, Func<TSource, TCollection, TResult> ^ resultSelector);

public static System.Collections.Generic.IEnumerable<TResult> SelectMany<TSource,TCollection,TResult>(this System.Collections.Generic.IEnumerable<TSource> source, Func<TSource,int,System.Collections.Generic.IEnumerable<TCollection>> collectionSelector, Func<TSource,TCollection,TResult> resultSelector);

static member SelectMany : seq<'Source> * Func<'Source, int, seq<'Collection>> * Func<'Source, 'Collection, 'Result> -> seq<'Result>

<Extension()>
Public Function SelectMany(Of TSource, TCollection, TResult) (source As IEnumerable(Of TSource), collectionSelector As Func(Of TSource, Integer, IEnumerable(Of TCollection)), resultSelector As Func(Of TSource, TCollection, TResult)) As IEnumerable(Of TResult)

Typparametrar

Parametrar

Returer

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

Undantag

Kommentarer

Den här metoden implementeras med uppskjuten körning. Det omedelbara returvärdet är ett objekt som lagrar all information som krävs för att utföra åtgärden. Frågan som representeras av den här metoden körs inte förrän objektet räknas upp antingen genom att anropa metoden GetEnumerator direkt eller med hjälp av foreach i C# eller For Each i Visual Basic.

Metoden SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>) är användbar när du måste behålla elementen source i i omfånget för frågelogik som inträffar efter anropet till SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>). Se avsnittet Exempel för ett kodexempel. Om det finns en dubbelriktad relation mellan objekt av typen TSource och objekt av typen TCollection, d.v.s. om ett objekt av typen TCollection tillhandahåller en egenskap för att hämta TSource objektet som skapade det, behöver du inte den här överlagringen av SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>). I stället kan du använda SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TResult>>) och gå tillbaka till TSource objektet via objektet TCollection .

public:
generic <typename TSource, typename TResult>
[System::Runtime::CompilerServices::Extension]
 static System::Collections::Generic::IEnumerable<TResult> ^ SelectMany(System::Collections::Generic::IEnumerable<TSource> ^ source, Func<TSource, System::Collections::Generic::IEnumerable<TResult> ^> ^ selector);

public static System.Collections.Generic.IEnumerable<TResult> SelectMany<TSource,TResult>(this System.Collections.Generic.IEnumerable<TSource> source, Func<TSource,System.Collections.Generic.IEnumerable<TResult>> selector);

static member SelectMany : seq<'Source> * Func<'Source, seq<'Result>> -> seq<'Result>

<Extension()>
Public Function SelectMany(Of TSource, TResult) (source As IEnumerable(Of TSource), selector As Func(Of TSource, IEnumerable(Of TResult))) As IEnumerable(Of TResult)

Typparametrar

Parametrar

Returer

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

Undantag

Exempel

Följande kodexempel visar hur du använder SelectMany<TSource,TResult>(IEnumerable<TSource>, 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.SelectMany(petOwner => petOwner.Pets);

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

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

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

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

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

/*
 This code produces the following output:

 Using SelectMany():
 Scruffy
 Sam
 Walker
 Sugar
 Scratches
 Diesel

 Using Select():
 Scruffy
 Sam

 Walker
 Sugar

 Scratches
 Diesel
*/

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

Sub SelectManyEx1()
    ' Create an array of PetOwner objects.
    Dim petOwners() As PetOwner =
{New PetOwner With
 {.Name = "Higa, Sidney", .Pets = New String() {"Scruffy", "Sam"}},
 New PetOwner With
 {.Name = "Ashkenazi, Ronen", .Pets = New String() {"Walker", "Sugar"}},
 New PetOwner With
 {.Name = "Price, Vernette", .Pets = New String() {"Scratches", "Diesel"}}}

    ' Call SelectMany() to gather all pets into a "flat" sequence.
    Dim query1 As IEnumerable(Of String) =
petOwners.SelectMany(Function(petOwner) petOwner.Pets)

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

    ' This code demonstrates how to use Select() instead
    ' of SelectMany() to get the same result.
    Dim query2 As IEnumerable(Of String()) =
petOwners.Select(Function(petOwner) petOwner.Pets)
    output.AppendLine(vbCrLf & "Using Select():")
    ' Notice that two foreach loops are required to iterate through
    ' the results because the query returns a collection of arrays.
    For Each petArray() As String In query2
        For Each pet As String In petArray
            output.AppendLine(pet)
        Next
    Next

    ' Display the output.
    Console.WriteLine(output.ToString())
End Sub

' This code produces the following output:
'
' Using SelectMany():
' Scruffy
' Sam
' Walker
' Sugar
' Scratches
' Diesel
'
' Using Select():
' Scruffy
' Sam
' Walker
' Sugar
' Scratches
' Diesel

Kommentarer

Den här metoden implementeras med uppskjuten körning. Det omedelbara returvärdet är ett objekt som lagrar all information som krävs för att utföra åtgärden. Frågan som representeras av den här metoden körs inte förrän objektet räknas upp antingen genom att anropa metoden GetEnumerator direkt eller med hjälp av foreach i C# eller For Each i Visual Basic.

Metoden SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TResult>>) räknar upp indatasekvensen, använder en transformeringsfunktion för att mappa varje element till ett IEnumerable<T>, och räknar sedan upp och ger elementen i varje sådant IEnumerable<T> objekt. För varje element sourceselector i anropas alltså och en sekvens med värden returneras. SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TResult>>) platta sedan ut den här tvådimensionella samlingen med samlingar till en endimensionell IEnumerable<T> och returnerar den. Om en fråga till exempel använder SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TResult>>) för att hämta beställningarna (av typen Order) för varje kund i en databas, är resultatet av typen IEnumerable<Order> i C# eller IEnumerable(Of Order) i Visual Basic. Om frågan i stället använder Select för att hämta order kombineras inte samlingen med samlingar med beställningar och resultatet är av typen IEnumerable<List<Order>> i C# eller IEnumerable(Of List(Of Order)) i Visual Basic.

I frågeuttryckssyntaxen översätts varje from-sats (C#) eller From-sats (Visual Basic) efter att den första översätts till ett anrop av SelectMany.

Se även

• from-sats (C#-referens)
• From-sats (Visual Basic)

public:
generic <typename TSource, typename TResult>
[System::Runtime::CompilerServices::Extension]
 static System::Collections::Generic::IEnumerable<TResult> ^ SelectMany(System::Collections::Generic::IEnumerable<TSource> ^ source, Func<TSource, int, System::Collections::Generic::IEnumerable<TResult> ^> ^ selector);

public static System.Collections.Generic.IEnumerable<TResult> SelectMany<TSource,TResult>(this System.Collections.Generic.IEnumerable<TSource> source, Func<TSource,int,System.Collections.Generic.IEnumerable<TResult>> selector);

static member SelectMany : seq<'Source> * Func<'Source, int, seq<'Result>> -> seq<'Result>

<Extension()>
Public Function SelectMany(Of TSource, TResult) (source As IEnumerable(Of TSource), selector As Func(Of TSource, Integer, IEnumerable(Of TResult))) As IEnumerable(Of TResult)

Typparametrar

Parametrar

Returer

En IEnumerable<T> vars element är resultatet av att anropa en-till-många-transformeringsfunktionen på varje element i en indatasekvens.

Undantag

Exempel

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

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

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

    // Project the items in the array by appending the index
    // of each PetOwner to each pet's name in that petOwner's
    // array of pets.
    IEnumerable<string> query =
        petOwners.SelectMany((petOwner, index) =>
                                 petOwner.Pets.Select(pet => index + pet));

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

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

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

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

    ' Project the items in the array by appending the index
    ' of each PetOwner to each pet's name in that petOwner's
    ' array of pets.
    Dim query As IEnumerable(Of String) =
petOwners.SelectMany(Function(petOwner, index) _
                         petOwner.Pets.Select(Function(pet) _
                                                  index.ToString() + pet))

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

    ' Display the output.
    Console.WriteLine(output.ToString())
End Sub

Kommentarer

Den här metoden implementeras med uppskjuten körning. Det omedelbara returvärdet är ett objekt som lagrar all information som krävs för att utföra åtgärden. Frågan som representeras av den här metoden körs inte förrän objektet räknas upp antingen genom att anropa metoden GetEnumerator direkt eller med hjälp av foreach i C# eller For Each i Visual Basic.

Metoden SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TResult>>) räknar upp indatasekvensen, använder en transformeringsfunktion för att mappa varje element till ett IEnumerable<T>, och räknar sedan upp och ger elementen i varje sådant IEnumerable<T> objekt. För varje element sourceselector i anropas alltså och en sekvens med värden returneras. SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TResult>>) platta sedan ut den här tvådimensionella samlingen med samlingar till en endimensionell IEnumerable<T> och returnerar den. Om en fråga till exempel använder SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TResult>>) för att hämta beställningarna (av typen Order) för varje kund i en databas, är resultatet av typen IEnumerable<Order> i C# eller IEnumerable(Of Order) i Visual Basic. Om frågan i stället använder Select för att hämta order kombineras inte samlingen med samlingar med beställningar och resultatet är av typen IEnumerable<List<Order>> i C# eller IEnumerable(Of List(Of Order)) i Visual Basic.

Det första argumentet som selector representerar elementet som ska bearbetas. Det andra argumentet som selector representerar det nollbaserade indexet för det elementet i källsekvensen. Detta kan vara användbart om elementen är i en känd ordning och du till exempel vill göra något med ett element i ett visst index. Det kan också vara användbart om du vill hämta indexet för ett eller flera element.