Operace projekce

Projekce odkazuje na operaci transformace objektu do nového formuláře, který často obsahuje pouze ty vlastnosti, které budou následně použity.Projekce pomocí můžete vytvořit nový typ, který je součástí každého objektu.Můžete vlastnost projektu a provádět matematické funkce.Microsoft Office project původní objekt bez provedení změn.

V následující části jsou uvedeny metody standardního dotazu operátor, provádějící projekce.

Metody

Název metody	Description	Syntaxi výrazu dotazu C#	Visual BasicSyntaxe dotazu výraz	Další informace
Vybrat	Hodnoty projekty, které jsou založeny na funkci transformace.	select	Select	Enumerable.Select``2 Queryable.Select``2
Označit více	Projekty číselné řady hodnot, které jsou založeny na funkci transformace a pak je sloučí do jedné řady.	Použití více from klauzule	Použití více From klauzule	Enumerable.SelectMany``2 Queryable.SelectMany``2

Příklady syntaxe výraz dotazu

Vybrat

V následujícím příkladu select klauzule v jazyce C# nebo Select klauzule v Visual Basic na první písmeno z každý řetězec v seznamu řetězců projektu.

Dim words = New List(Of String) From {"an", "apple", "a", "day"}

        Dim query = From word In words 
                    Select word.Substring(0, 1)

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

        ' Display the output.
        MsgBox(sb.ToString())

        ' This code produces the following output: 

        ' a 
        ' a 
        ' a 
        ' d

            List<string> words = new List<string>() { "an", "apple", "a", "day" };

            var query = from word in words
                        select word.Substring(0, 1);

            foreach (string s in query)
                Console.WriteLine(s);

            /* This code produces the following output:

                a
                a
                a
                d
            */

Označit více

Následující příklad používá více from doložek v C# nebo From doložek v Visual Basic na každé slovo z každý řetězec v seznamu řetězců projektu.

Dim phrases = New List(Of String) From {"an apple a day", "the quick brown fox"}

        Dim query = From phrase In phrases 
                    From word In phrase.Split(" "c) 
                    Select word

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

        ' Display the output.
        MsgBox(sb.ToString())

        ' This code produces the following output: 

        ' an 
        ' apple 
        ' a 
        ' day 
        ' the 
        ' quick 
        ' brown 
        ' fox

            List<string> phrases = new List<string>() { "an apple a day", "the quick brown fox" };

            var query = from phrase in phrases
                        from word in phrase.Split(' ')
                        select word;

            foreach (string s in query)
                Console.WriteLine(s);

            /* This code produces the following output:

                an
                apple
                a
                day
                the
                quick
                brown
                fox
            */

Vyberte versus SelectMany

Práce obou Select() a SelectMany() , je výsledná hodnota (nebo hodnoty) z hodnoty zdroje.**Select()**vytváří jeden výsledek hodnotu pro každý zdroj hodnotu.Celkový výsledek je proto kolekce, která má stejný počet prvků jako zdrojové kolekce.Na rozdíl od SelectMany() vytváří jeden celkový výsledek obsahuje spojených sub-collections od hodnoty každého zdroje.Funkce transformace, který je předán jako argument SelectMany() musí vrátit agregující číselné řady hodnot pro každou zdrojovou hodnotu.Tyto sekvence agregující pak ve spojení SelectMany() k vytvoření jedné velké sekvence.

Následující dva obrázky ukazují koncepční rozdíl mezi akce těchto dvou metod.V každém případě předpokládá, že funkce modulu selector (transformace) vybere z každé zdrojové hodnoty pole květiny.

Tento obrázek znázorňuje způsob Select() Vrátí kolekci, která má stejný počet prvků jako zdrojové kolekce.

Tento obrázek znázorňuje způsob SelectMany() spojuje zprostředkující posloupnost polí do jednoho konečný výsledek hodnotu, která obsahuje jednotlivé hodnoty z každé dílčí pole.

Příklad kódu

Následující příklad porovnává chování Select() a SelectMany().Přičemž první dvě položky z každého seznamu názvů květina ve zdrojové kolekci vytvoří kód "bouquet" květiny.V tomto příkladu "jedna hodnota" která transformační funkce Select``2(IEnumerableUMP, FuncUMP, UMP) používá samotný je kolekce hodnot.To vyžaduje extra foreach (For Each v Visual Basic) smyčka pro výčet každý řetězec v každé sub-sequence.

Class Bouquet
    Public Flowers As List(Of String)
End Class 

Sub SelectVsSelectMany()
    Dim bouquets = New List(Of Bouquet) From { 
        New Bouquet With {.Flowers = New List(Of String)(New String() {"sunflower", "daisy", "daffodil", "larkspur"})}, 
        New Bouquet With {.Flowers = New List(Of String)(New String() {"tulip", "rose", "orchid"})}, 
        New Bouquet With {.Flowers = New List(Of String)(New String() {"gladiolis", "lily", "snapdragon", "aster", "protea"})}, 
        New Bouquet With {.Flowers = New List(Of String)(New String() {"larkspur", "lilac", "iris", "dahlia"})}}

    Dim output As New System.Text.StringBuilder

    ' Select() 
    Dim query1 = bouquets.Select(Function(b) b.Flowers)

    output.AppendLine("Using Select():")
    For Each flowerList In query1
        For Each str As String In flowerList
            output.AppendLine(str)
        Next 
    Next 

    ' SelectMany() 
    Dim query2 = bouquets.SelectMany(Function(b) b.Flowers)

    output.AppendLine(vbCrLf & "Using SelectMany():")
    For Each str As String In query2
        output.AppendLine(str)
    Next 

    ' Display the output
    MsgBox(output.ToString())

    ' This code produces the following output: 
    ' 
    ' Using Select(): 
    ' sunflower 
    ' daisy 
    ' daffodil 
    ' larkspur 
    ' tulip 
    ' rose 
    ' orchid 
    ' gladiolis 
    ' lily 
    ' snapdragon 
    ' aster 
    ' protea 
    ' larkspur 
    ' lilac 
    ' iris 
    ' dahlia 

    ' Using SelectMany() 
    ' sunflower 
    ' daisy 
    ' daffodil 
    ' larkspur 
    ' tulip 
    ' rose 
    ' orchid 
    ' gladiolis 
    ' lily 
    ' snapdragon 
    ' aster 
    ' protea 
    ' larkspur 
    ' lilac 
    ' iris 
    ' dahlia 

End Sub

class Bouquet
{
    public List<string> Flowers { get; set; }
}

static void SelectVsSelectMany()
{
    List<Bouquet> bouquets = new List<Bouquet>() {
        new Bouquet { Flowers = new List<string> { "sunflower", "daisy", "daffodil", "larkspur" }},
        new Bouquet{ Flowers = new List<string> { "tulip", "rose", "orchid" }},
        new Bouquet{ Flowers = new List<string> { "gladiolis", "lily", "snapdragon", "aster", "protea" }},
        new Bouquet{ Flowers = new List<string> { "larkspur", "lilac", "iris", "dahlia" }}
    };

    // *********** Select ***********            
    IEnumerable<List<string>> query1 = bouquets.Select(bq => bq.Flowers);

    // ********* SelectMany *********
    IEnumerable<string> query2 = bouquets.SelectMany(bq => bq.Flowers);

    Console.WriteLine("Results by using Select():");
    // Note the extra foreach loop here. 
    foreach (IEnumerable<String> collection in query1)
        foreach (string item in collection)
            Console.WriteLine(item);

    Console.WriteLine("\nResults by using SelectMany():");
    foreach (string item in query2)
        Console.WriteLine(item);

    /* This code produces the following output:

       Results by using Select():
        sunflower
        daisy
        daffodil
        larkspur
        tulip
        rose
        orchid
        gladiolis
        lily
        snapdragon
        aster
        protea
        larkspur
        lilac
        iris
        dahlia

       Results by using SelectMany():
        sunflower
        daisy
        daffodil
        larkspur
        tulip
        rose
        orchid
        gladiolis
        lily
        snapdragon
        aster
        protea
        larkspur
        lilac
        iris
        dahlia
    */

}

Viz také

Úkoly

Postupy: Kombinace dat s LINQ pomocí spojení (Visual Basic)

Postupy: Vyplňování kolekcí objektů z více zdrojů (LINQ)

Postupy: Vrácení výsledku dotazu LINQ jako specifického typu (Visual Basic)

Postupy: Rozdělení souboru na více souborů pomocí skupin (LINQ)

Referenční dokumentace

select – klauzule (Referenční dokumentace jazyka C#)

Select – klauzule (Visual Basic)

System.Linq

Koncepty

Přehled standardních operátorů dotazu