Enumerable.SelectMany Metodo
Definizione
Proietta ogni elemento di una sequenza a un oggetto IEnumerable<T> e semplifica le sequenze risultanti in un’unica sequenza.Projects each element of a sequence to an IEnumerable<T> and flattens the resulting sequences into one sequence.
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.Projects each element of a sequence to an IEnumerable<T>, flattens the resulting sequences into one sequence, and invokes a result selector function on each element therein. |
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.Projects each element of a sequence to an IEnumerable<T>, flattens the resulting sequences into one sequence, and invokes a result selector function on each element therein. L'indice di ogni elemento di origine viene usato nella maschera intermedia proiettata di tale elemento.The index of each source element is used in the intermediate projected form of that element. |
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.Projects each element of a sequence to an IEnumerable<T> and flattens the resulting sequences into one sequence. |
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.Projects each element of a sequence to an IEnumerable<T>, and flattens the resulting sequences into one sequence. L'indice di ogni elemento di origine viene usato nella maschera proiettata di tale elemento.The index of each source element is used in the projected form of that element. |
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.Projects each element of a sequence to an IEnumerable<T>, flattens the resulting sequences into one sequence, and invokes a result selector function on each element therein.
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
.The type of the elements of source
.
- TCollection
Tipo degli elementi intermedi raccolti da collectionSelector
.The type of the intermediate elements collected by collectionSelector
.
- TResult
Tipo degli elementi della sequenza risultante.The type of the elements of the resulting sequence.
Parametri
- source
- IEnumerable<TSource>
Sequenza di valori da proiettare.A sequence of values to project.
- collectionSelector
- Func<TSource,IEnumerable<TCollection>>
Funzione di trasformazione da applicare a ogni elemento della sequenza di input.A transform function to apply to each element of the input sequence.
- resultSelector
- Func<TSource,TCollection,TResult>
Funzione di trasformazione da applicare a ogni elemento della sequenza intermedia.A transform function to apply to each element of the intermediate sequence.
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.An IEnumerable<T> whose elements are the result of invoking the one-to-many transform function collectionSelector
on each element of source
and then mapping each of those sequence elements and their corresponding source element to a result element.
Eccezioni
Il parametro source
, il parametro collectionSelector
o il parametro resultSelector
è null
.source
or collectionSelector
or resultSelector
is null
.
Esempio
Nell'esempio di codice seguente viene illustrato come utilizzare 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 utilizzare una funzione del selettore dei risultati per memorizzare ogni elemento corrispondente dalla sequenza di origine nell'ambito della chiamata finale a Select
.The following code example demonstrates how to use SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>) to perform a one-to-many projection over an array and use a result selector function to keep each corresponding element from the source sequence in scope for the final call to 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 tramite l'esecuzione posticipata.This method is implemented by using deferred execution. Il valore restituito immediato è un oggetto che archivia tutte le informazioni necessarie per eseguire l'azione.The immediate return value is an object that stores all the information that is required to perform the action. La query rappresentata da questo metodo non viene eseguita finché l'oggetto non viene enumerato chiamando il relativo GetEnumerator
metodo direttamente o utilizzando foreach
in Visual C# o For Each
in Visual Basic.The query represented by this method is not executed until the object is enumerated either by calling its GetEnumerator
method directly or by using foreach
in Visual C# or For Each
in Visual Basic.
Il SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>) metodo è utile quando è necessario contenere gli elementi di source
nell'ambito per la logica di query che si verifica dopo la chiamata a SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>) .The SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>) method is useful when you have to keep the elements of source
in scope for query logic that occurs after the call to 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.See the Example section for a code example. Se è presente una relazione bidirezionale tra oggetti di tipo TSource
e oggetti di tipo TCollection
, ovvero se un oggetto di tipo TCollection
fornisce una proprietà per recuperare l' TSource
oggetto che lo ha generato, questo overload di non è necessario SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>) .If there is a bidirectional relationship between objects of type TSource
and objects of type TCollection
, that is, if an object of type TCollection
provides a property to retrieve the TSource
object that produced it, you do not need this overload of SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>). È invece possibile utilizzare SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TResult>>) e tornare all' TSource
oggetto tramite l' TCollection
oggetto.Instead, you can use SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TResult>>) and navigate back to the TSource
object through the TCollection
object.
Nella sintassi delle espressioni di query, ogni from
clausola (Visual C#) o From
clausola (Visual Basic) dopo quella iniziale viene convertita in una chiamata di SelectMany .In query expression syntax, each from
clause (Visual C#) or From
clause (Visual Basic) after the initial one translates to an invocation of SelectMany.
Vedi anche
- Clausola from (Riferimento C#)from clause (C# Reference)
- Clausola From (Visual Basic)From Clause (Visual Basic)
Si applica a
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.Projects each element of a sequence to an IEnumerable<T>, flattens the resulting sequences into one sequence, and invokes a result selector function on each element therein. L'indice di ogni elemento di origine viene usato nella maschera intermedia proiettata di tale elemento.The index of each source element is used in the intermediate projected form of that element.
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
.The type of the elements of source
.
- TCollection
Tipo degli elementi intermedi raccolti da collectionSelector
.The type of the intermediate elements collected by collectionSelector
.
- TResult
Tipo degli elementi della sequenza risultante.The type of the elements of the resulting sequence.
Parametri
- source
- IEnumerable<TSource>
Sequenza di valori da proiettare.A sequence of values to project.
- 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.A transform function to apply to each source element; the second parameter of the function represents the index of the source element.
- resultSelector
- Func<TSource,TCollection,TResult>
Funzione di trasformazione da applicare a ogni elemento della sequenza intermedia.A transform function to apply to each element of the intermediate sequence.
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.An IEnumerable<T> whose elements are the result of invoking the one-to-many transform function collectionSelector
on each element of source
and then mapping each of those sequence elements and their corresponding source element to a result element.
Eccezioni
Il parametro source
, il parametro collectionSelector
o il parametro resultSelector
è null
.source
or collectionSelector
or resultSelector
is null
.
Commenti
Questo metodo viene implementato tramite l'esecuzione posticipata.This method is implemented by using deferred execution. Il valore restituito immediato è un oggetto che archivia tutte le informazioni necessarie per eseguire l'azione.The immediate return value is an object that stores all the information that is required to perform the action. La query rappresentata da questo metodo non viene eseguita finché l'oggetto non viene enumerato chiamando il relativo GetEnumerator
metodo direttamente o utilizzando foreach
in Visual C# o For Each
in Visual Basic.The query represented by this method is not executed until the object is enumerated either by calling its GetEnumerator
method directly or by using foreach
in Visual C# or For Each
in Visual Basic.
Il SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>) metodo è utile quando è necessario contenere gli elementi di source
nell'ambito per la logica di query che si verifica dopo la chiamata a SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>) .The SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>) method is useful when you have to keep the elements of source
in scope for query logic that occurs after the call to 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.See the Example section for a code example. Se è presente una relazione bidirezionale tra oggetti di tipo TSource
e oggetti di tipo TCollection
, ovvero se un oggetto di tipo TCollection
fornisce una proprietà per recuperare l' TSource
oggetto che lo ha generato, questo overload di non è necessario SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>) .If there is a bidirectional relationship between objects of type TSource
and objects of type TCollection
, that is, if an object of type TCollection
provides a property to retrieve the TSource
object that produced it, you do not need this overload of SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>). È invece possibile utilizzare SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TResult>>) e tornare all' TSource
oggetto tramite l' TCollection
oggetto.Instead, you can use SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TResult>>) and navigate back to the TSource
object through the TCollection
object.
Si applica a
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.Projects each element of a sequence to an IEnumerable<T> and flattens the resulting sequences into one sequence.
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
.The type of the elements of source
.
- TResult
Tipo degli elementi della sequenza restituita da selector
.The type of the elements of the sequence returned by selector
.
Parametri
- source
- IEnumerable<TSource>
Sequenza di valori da proiettare.A sequence of values to project.
- selector
- Func<TSource,IEnumerable<TResult>>
Funzione di trasformazione da applicare a ogni elemento.A transform function to apply to each element.
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.An IEnumerable<T> whose elements are the result of invoking the one-to-many transform function on each element of the input sequence.
Eccezioni
source
o selector
è null
.source
or selector
is null
.
Esempio
Nell'esempio di codice riportato di seguito viene illustrato come utilizzare SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TResult>>) per eseguire una proiezione uno-a-molti su una matrice.The following code example demonstrates how to use SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TResult>>) to perform a one-to-many projection over an array.
class PetOwner
{
public string Name { get; set; }
public List<String> Pets { get; set; }
}
public static void SelectManyEx1()
{
PetOwner[] petOwners =
{ new PetOwner { Name="Higa, Sidney",
Pets = new List<string>{ "Scruffy", "Sam" } },
new PetOwner { Name="Ashkenazi, Ronen",
Pets = new List<string>{ "Walker", "Sugar" } },
new PetOwner { Name="Price, Vernette",
Pets = new List<string>{ "Scratches", "Diesel" } } };
// Query using SelectMany().
IEnumerable<string> query1 = petOwners.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
Questo metodo viene implementato tramite l'esecuzione posticipata.This method is implemented by using deferred execution. Il valore restituito immediato è un oggetto che archivia tutte le informazioni necessarie per eseguire l'azione.The immediate return value is an object that stores all the information that is required to perform the action. La query rappresentata da questo metodo non viene eseguita finché l'oggetto non viene enumerato chiamando il relativo GetEnumerator
metodo direttamente o utilizzando foreach
in Visual C# o For Each
in Visual Basic.The query represented by this method is not executed until the object is enumerated either by calling its GetEnumerator
method directly or by using foreach
in Visual C# or For Each
in Visual Basic.
Il SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TResult>>) metodo enumera la sequenza di input, utilizza una funzione Transform per eseguire il mapping di ogni elemento a un IEnumerable<T> oggetto, quindi enumera e produce gli elementi di ogni oggetto di questo tipo IEnumerable<T> .The SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TResult>>) method enumerates the input sequence, uses a transform function to map each element to an IEnumerable<T>, and then enumerates and yields the elements of each such IEnumerable<T> object. Ovvero per ogni elemento di source
, selector
viene richiamato e viene restituita una sequenza di valori.That is, for each element of source
, selector
is invoked and a sequence of values is returned. SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TResult>>) quindi rende Flat questa raccolta bidimensionale di raccolte in un oggetto unidimensionale IEnumerable<T> e la restituisce.SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TResult>>) then flattens this two-dimensional collection of collections into a one-dimensional IEnumerable<T> and returns it. Se, ad esempio, una query utilizza SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TResult>>) per ottenere gli ordini (di tipo Order
) per ogni cliente in un database, il risultato sarà di tipo IEnumerable<Order>
in C# o IEnumerable(Of Order)
in Visual Basic.For example, if a query uses SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TResult>>) to obtain the orders (of type Order
) for each customer in a database, the result is of type IEnumerable<Order>
in C# or IEnumerable(Of Order)
in Visual Basic. Se invece la query USA Select per ottenere gli ordini, la raccolta di insiemi di ordini non viene combinata e il risultato è di tipo IEnumerable<List<Order>>
in C# o IEnumerable(Of List(Of Order))
in Visual Basic.If instead the query uses Select to obtain the orders, the collection of collections of orders is not combined and the result is of type IEnumerable<List<Order>>
in C# or IEnumerable(Of List(Of Order))
in Visual Basic.
Nella sintassi delle espressioni di query, ogni from
clausola (Visual C#) o From
clausola (Visual Basic) dopo quella iniziale viene convertita in una chiamata di SelectMany .In query expression syntax, each from
clause (Visual C#) or From
clause (Visual Basic) after the initial one translates to an invocation of SelectMany.
Vedi anche
- Clausola from (Riferimento C#)from clause (C# Reference)
- Clausola From (Visual Basic)From Clause (Visual Basic)
Si applica a
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.Projects each element of a sequence to an IEnumerable<T>, and flattens the resulting sequences into one sequence. L'indice di ogni elemento di origine viene usato nella maschera proiettata di tale elemento.The index of each source element is used in the projected form of that element.
public:
generic <typename TSource, typename TResult>
[System::Runtime::CompilerServices::Extension]
static System::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
.The type of the elements of source
.
- TResult
Tipo degli elementi della sequenza restituita da selector
.The type of the elements of the sequence returned by selector
.
Parametri
- source
- IEnumerable<TSource>
Sequenza di valori da proiettare.A sequence of values to project.
- 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.A transform function to apply to each source element; the second parameter of the function represents the index of the source element.
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.An IEnumerable<T> whose elements are the result of invoking the one-to-many transform function on each element of an input sequence.
Eccezioni
source
o selector
è null
.source
or selector
is null
.
Esempio
Nell'esempio di codice riportato di seguito viene illustrato come utilizzare SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TResult>>) per eseguire una proiezione uno-a-molti su una matrice e utilizzare l'indice di ogni elemento esterno.The following code example demonstrates how to use SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TResult>>) to perform a one-to-many projection over an array and use the index of each outer 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
Commenti
Questo metodo viene implementato tramite l'esecuzione posticipata.This method is implemented by using deferred execution. Il valore restituito immediato è un oggetto che archivia tutte le informazioni necessarie per eseguire l'azione.The immediate return value is an object that stores all the information that is required to perform the action. La query rappresentata da questo metodo non viene eseguita finché l'oggetto non viene enumerato chiamando il relativo GetEnumerator
metodo direttamente o utilizzando foreach
in Visual C# o For Each
in Visual Basic.The query represented by this method is not executed until the object is enumerated either by calling its GetEnumerator
method directly or by using foreach
in Visual C# or For Each
in Visual Basic.
Il SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TResult>>) metodo enumera la sequenza di input, utilizza una funzione Transform per eseguire il mapping di ogni elemento a un IEnumerable<T> oggetto, quindi enumera e produce gli elementi di ogni oggetto di questo tipo IEnumerable<T> .The SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TResult>>) method enumerates the input sequence, uses a transform function to map each element to an IEnumerable<T>, and then enumerates and yields the elements of each such IEnumerable<T> object. Ovvero per ogni elemento di source
, selector
viene richiamato e viene restituita una sequenza di valori.That is, for each element of source
, selector
is invoked and a sequence of values is returned. SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TResult>>) quindi rende Flat questa raccolta bidimensionale di raccolte in un oggetto unidimensionale IEnumerable<T> e la restituisce.SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TResult>>) then flattens this two-dimensional collection of collections into a one-dimensional IEnumerable<T> and returns it. Se, ad esempio, una query utilizza 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 sarà di tipo IEnumerable<Order>
in C# o IEnumerable(Of Order)
in Visual Basic.For example, if a query uses SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TResult>>) to obtain the orders (of type Order
) for each customer in a database, the result is of type IEnumerable<Order>
in C# or IEnumerable(Of Order)
in Visual Basic. Se invece la query USA Select per ottenere gli ordini, la raccolta di insiemi di ordini non viene combinata e il risultato è di tipo IEnumerable<List<Order>>
in C# o IEnumerable(Of List(Of Order))
in Visual Basic.If instead the query uses Select to obtain the orders, the collection of collections of orders is not combined and the result is of type IEnumerable<List<Order>>
in C# or IEnumerable(Of List(Of Order))
in Visual Basic.
Il primo argomento per selector
rappresenta l'elemento da elaborare.The first argument to selector
represents the element to process. Il secondo argomento di selector
rappresenta l'indice in base zero dell'elemento nella sequenza di origine.The second argument to selector
represents the zero-based index of that element in the source sequence. Questo può essere utile se gli elementi sono in un ordine noto e si desidera eseguire un'operazione con un elemento in un determinato indice, ad esempio.This can be useful if the elements are in a known order and you want to do something with an element at a particular index, for example. Può inoltre essere utile se si desidera recuperare l'indice di uno o più elementi.It can also be useful if you want to retrieve the index of one or more elements.