Enumerable.SelectMany Metodo

Riferimento

Definizione

Spazio dei nomi:: System.Linq

Assembly:: System.Linq.dll

Assembly:: System.Core.dll

Assembly:: netstandard.dll

Importante

Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.

Proietta ogni elemento di una sequenza a un oggetto IEnumerable<T> e semplifica le sequenze risultanti in un’unica sequenza.

Overload

SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>)	Proietta ogni elemento di una sequenza a un oggetto IEnumerable<T>, semplifica le sequenze risultanti in un'unica sequenza e richiama una funzione del selettore di risultato su ogni elemento al suo interno.
SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>)	Proietta ogni elemento di una sequenza a un oggetto IEnumerable<T>, semplifica le sequenze risultanti in un'unica sequenza e richiama una funzione del selettore di risultato su ogni elemento al suo interno. L'indice di ogni elemento di origine viene usato nella maschera intermedia proiettata di tale elemento.
SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TResult>>)	Proietta ogni elemento di una sequenza a un oggetto IEnumerable<T> e semplifica le sequenze risultanti in un’unica sequenza.
SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TResult>>)	Proietta ogni elemento di una sequenza a un oggetto IEnumerable<T> e semplifica le sequenze risultanti in un’unica sequenza. L'indice di ogni elemento di origine viene usato nella maschera proiettata di tale elemento.

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

Origine:: SelectMany.cs

Origine:: SelectMany.cs

Origine:: SelectMany.cs

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)

Parametri di tipo

TSource

Tipo degli elementi di source.

TCollection

Tipo degli elementi intermedi raccolti da collectionSelector.

TResult

Tipo degli elementi della sequenza risultante.

Parametri

source: IEnumerable<TSource>

Sequenza di valori da proiettare.

collectionSelector: Func<TSource,IEnumerable<TCollection>>

Funzione di trasformazione da applicare a ogni elemento della sequenza di input.

resultSelector: Func<TSource,TCollection,TResult>

Funzione di trasformazione da applicare a ogni elemento della sequenza intermedia.

Restituisce

IEnumerable<TResult>

Oggetto IEnumerable<T> i cui elementi sono il risultato ottenuto richiamando la funzione di trasformazione uno a molti collectionSelector su ogni elemento di source ed eseguire quindi il mapping di ognuno degli elementi di tale sequenza e del corrispondente elemento di origine a un elemento di risultato.

Eccezioni

ArgumentNullException

Il parametro source, il parametro collectionSelector o il parametro resultSelector è null.

Esempio

Nell'esempio di codice seguente viene illustrato come usare SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>) per eseguire una proiezione uno-a-molti su una matrice e usare una funzione selettore di risultati per mantenere ogni elemento corrispondente dalla sequenza di origine nell'ambito della chiamata finale a 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

Commenti

Questo metodo viene implementato usando l'esecuzione posticipata. Il valore restituito immediato è un oggetto che archivia tutte le informazioni necessarie per eseguire l'azione. La query rappresentata da questo metodo non viene eseguita fino a quando l'oggetto non viene enumerato chiamando direttamente il relativo GetEnumerator metodo o usando foreach in C# o For Each in Visual Basic.

Il SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>) metodo è utile quando è necessario mantenere gli elementi di nell'ambito per la logica di source query che si verifica dopo la chiamata a SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>). Per un esempio di codice, vedere la sezione relativa agli esempi. Se esiste una relazione bidirezionale tra oggetti di tipo e oggetti di tipo TSourceTCollection, ovvero se un oggetto di tipo TCollection fornisce una proprietà per recuperare l'oggetto TSource che lo ha prodotto, non è necessario questo overload di SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>). È invece possibile usare SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TResult>>) e tornare all'oggetto TSource tramite l'oggetto TCollection .

Nella sintassi delle espressioni di query, ogni from clausola (C#) o From clausola (Visual Basic) dopo quella iniziale viene convertita in una chiamata di SelectMany.

Vedi anche

Si applica a

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

Origine:: SelectMany.cs

Origine:: SelectMany.cs

Origine:: SelectMany.cs

Proietta ogni elemento di una sequenza a un oggetto IEnumerable<T>, semplifica le sequenze risultanti in un'unica sequenza e richiama una funzione del selettore di risultato su ogni elemento al suo interno. L'indice di ogni elemento di origine viene usato nella maschera intermedia proiettata di tale elemento.

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)

Parametri di tipo

TSource

Tipo degli elementi di source.

TCollection

Tipo degli elementi intermedi raccolti da collectionSelector.

TResult

Tipo degli elementi della sequenza risultante.

Parametri

source: IEnumerable<TSource>

Sequenza di valori da proiettare.

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

Funzione di trasformazione da applicare a ogni elemento di origine; il secondo parametro della funzione rappresenta l'indice dell'elemento di origine.

resultSelector: Func<TSource,TCollection,TResult>

Funzione di trasformazione da applicare a ogni elemento della sequenza intermedia.

Restituisce

IEnumerable<TResult>

Eccezioni

ArgumentNullException

Il parametro source, il parametro collectionSelector o il parametro resultSelector è null.

Commenti

Il SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>) metodo è utile quando è necessario mantenere gli elementi di nell'ambito per la logica di source query che si verifica dopo la chiamata a SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>). Per un esempio di codice, vedere la sezione relativa agli esempi. Se esiste una relazione bidirezionale tra oggetti di tipo e oggetti di tipo TSourceTCollection, ovvero se un oggetto di tipo TCollection fornisce una proprietà per recuperare l'oggetto TSource che lo ha prodotto, non è necessario questo overload di SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>). È invece possibile usare SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TResult>>) e tornare all'oggetto TSource tramite l'oggetto TCollection .

Si applica a

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

Origine:: SelectMany.cs

Origine:: SelectMany.cs

Origine:: SelectMany.cs

Proietta ogni elemento di una sequenza a un oggetto IEnumerable<T> e semplifica le sequenze risultanti in un’unica sequenza.

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)

Parametri di tipo

TSource

Tipo degli elementi di source.

TResult

Tipo degli elementi della sequenza restituita da selector.

Parametri

source: IEnumerable<TSource>

Sequenza di valori da proiettare.

selector: Func<TSource,IEnumerable<TResult>>

Funzione di trasformazione da applicare a ogni elemento.

Restituisce

IEnumerable<TResult>

Oggetto IEnumerable<T> i cui elementi sono il risultato ottenuto richiamando la funzione di trasformazione uno a molti su ogni elemento della sequenza di input.

Eccezioni

ArgumentNullException

source o selector è null.

Esempio

Nell'esempio di codice seguente viene illustrato come usare SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TResult>>) per eseguire una proiezione uno-a-molti su una matrice.

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

Commenti

Il SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TResult>>) metodo enumera la sequenza di input, usa una funzione di trasformazione per eseguire il mapping di ogni elemento a un oggetto IEnumerable<T>e quindi enumera e restituisce gli elementi di ogni oggetto.IEnumerable<T> Vale a dire, per ogni elemento di source, selector viene richiamato e viene restituita una sequenza di valori. SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TResult>>) appiattisce quindi questa raccolta bidimensionale di raccolte in un oggetto unidimensionale IEnumerable<T> e la restituisce. Ad esempio, se una query usa SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TResult>>) per ottenere gli ordini (di tipo Order) per ogni cliente in un database, il risultato è di tipo IEnumerable<Order> in C# o IEnumerable(Of Order) in Visual Basic. Se invece la query usa Select per ottenere gli ordini, la raccolta di raccolte di ordini non viene combinata e il risultato è di tipo IEnumerable<List<Order>> in C# o IEnumerable(Of List(Of Order)) in Visual Basic.

Nella sintassi delle espressioni di query, ogni from clausola (C#) o From clausola (Visual Basic) dopo quella iniziale viene convertita in una chiamata di SelectMany.

Vedi anche

Si applica a

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

Origine:: SelectMany.cs

Origine:: SelectMany.cs

Origine:: SelectMany.cs

Proietta ogni elemento di una sequenza a un oggetto IEnumerable<T> e semplifica le sequenze risultanti in un’unica sequenza. L'indice di ogni elemento di origine viene usato nella maschera proiettata di tale elemento.

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)

Parametri di tipo

TSource

Tipo degli elementi di source.

TResult

Tipo degli elementi della sequenza restituita da selector.

Parametri

source: IEnumerable<TSource>

Sequenza di valori da proiettare.

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

Funzione di trasformazione da applicare a ogni elemento di origine; il secondo parametro della funzione rappresenta l'indice dell'elemento di origine.

Restituisce

IEnumerable<TResult>

Oggetto IEnumerable<T> i cui elementi sono il risultato ottenuto richiamando la funzione di trasformazione uno a molti su ogni elemento di una sequenza di input.

Eccezioni

ArgumentNullException

source o selector è null.

Esempio

Nell'esempio di codice seguente viene illustrato come usare SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TResult>>) per eseguire una proiezione uno-a-molti su una matrice e usare l'indice di ogni elemento esterno.

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

Commenti

Il SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TResult>>) metodo enumera la sequenza di input, usa una funzione di trasformazione per eseguire il mapping di ogni elemento a un oggetto IEnumerable<T>e quindi enumera e restituisce gli elementi di ogni oggetto.IEnumerable<T> Vale a dire, per ogni elemento di source, selector viene richiamato e viene restituita una sequenza di valori. SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TResult>>) appiattisce quindi questa raccolta bidimensionale di raccolte in un oggetto unidimensionale IEnumerable<T> e la restituisce. Ad esempio, se una query usa SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TResult>>) per ottenere gli ordini (di tipo Order) per ogni cliente in un database, il risultato è di tipo IEnumerable<Order> in C# o IEnumerable(Of Order) in Visual Basic. Se invece la query usa Select per ottenere gli ordini, la raccolta di raccolte di ordini non viene combinata e il risultato è di tipo IEnumerable<List<Order>> in C# o IEnumerable(Of List(Of Order)) in Visual Basic.

Primo argomento da selector rappresentare l'elemento da elaborare. Secondo argomento da selector rappresentare l'indice in base zero di tale elemento nella sequenza di origine. Ciò può essere utile se gli elementi sono in un ordine noto e si vuole eseguire un'operazione con un elemento in corrispondenza di un indice specifico, ad esempio. Può essere utile anche se si desidera recuperare l'indice di uno o più elementi.

Si applica a

Enumerable.SelectMany Metodo

Definizione

Overload

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

Parametri di tipo

Parametri

Restituisce

Eccezioni

Esempio

Commenti

Vedi anche

Si applica a

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

Parametri di tipo

Parametri

Restituisce

Eccezioni

Commenti

Si applica a

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

Parametri di tipo

Parametri

Restituisce

Eccezioni

Esempio

Commenti

Vedi anche

Si applica a

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

Parametri di tipo

Parametri

Restituisce

Eccezioni

Esempio

Commenti

Si applica a

Commenti e suggerimenti

Risorse aggiuntive