Operacje rzutowania

Rzut odnosi się do funkcjonowania przekształcania obiektu nowy formularz, który często składa się tylko z tych właściwości, które będą następnie używane.Za pomocą projekcji, można utworzyć nowy typ, który jest zbudowany z każdego obiektu.Można właściwości projektu i wykonywać w niej funkcji matematycznych.Oryginalny obiekt można także projektu, nie zmieniając go.

Metody operator standardowej kwerendy wykonujące rzut są wymienione w poniższej sekcji.

Metody

Nazwa metody	Opis	Kwerendy języka C# składni wyrażenia	Visual BasicSkładni wyrażenia kwerendy	Więcej informacji
Wybierz	Wartości projektów, które są oparte na funkcji transformacji.	select	Select	Enumerable.Select``2 Queryable.Select``2
SelectMany	Projekty sekwencji wartości, które są oparte na funkcji transformacji i następnie spłaszcza je w jednej sekwencji.	Użyj wielu from klauzul	Użyj wielu From klauzul	Enumerable.SelectMany``2 Queryable.SelectMany``2

Przykłady składni wyrażenia kwerendy

Wybierz

W poniższym przykładzie użyto select klauzuli w C# lub Select w klauzuli Visual Basic do projektu pierwszej litery z każdy ciąg listy ciągów.

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
            */

SelectMany

W poniższym przykładzie użyto wielu from klauzul w C# lub From klauzul w Visual Basic do projektu każdego wyrazu z każdy ciąg listy ciągów.

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
            */

Wybierz kontra SelectMany

Prace w obu Select() i SelectMany() jest do produkcji, wartość wyniku (lub wartości) od wartości źródłowych.**Select()**tworzy jedną wartość wyniku dla każdego źródła wartości.Ogólny wynik jest zatem kolekcji, która ma tę samą liczbę elementów w kolekcji źródłowej.Z drugiej strony SelectMany() tworzy pojedynczy wynik ogólny, zawierający sub-collections uzyskiwanej z każdego źródła wartości.Funkcję transform, która jest przekazywana jako argument do SelectMany() musi zwracać agregującym sekwencja wartości dla każdej wartości źródła.Następnie sklejeniu te sekwencje agreguje ustalony przez SelectMany() do utworzenia jednej dużej sekwencji.

Poniższe dwa rysunki przedstawiają koncepcyjne różnica między akcje te dwie metody.W każdym przypadku założono, że funkcja selektor (transformacji) zaznacza tablicę kwiatów od wartości każdego źródła.

Na ilustracji przedstawiono sposób Select() zwraca kolekcję, który ma tę samą liczbę elementów w kolekcji źródłowej.

Na ilustracji przedstawiono sposób SelectMany() łączy sekwencji pośrednich tablic w jedną wartość wyniku końcowego, zawierający każdej wartości z każdego pośredniego tablicy.

Przykładowy kod

Poniższy przykład porównuje zachowanie Select() i SelectMany().Kod tworzy "bouquet" kwiaty, przyjmując dwa pierwsze elementy z każdej listy nazw kwiat w kolekcji źródłowej.W tym przykładzie "pojedyncza wartość", funkcja transform Select``2(IEnumerableUMP, FuncUMP, UMP) zastosowań jest to zbiór wartości.Wymaga to dodatkowych foreach (For Each w Visual Basic) pętli w celu wyliczenia każdy ciąg w każdym 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
    */

}

Zobacz też

Zadania

Porady: łączenie danych w LINQ za pomocą sprzężeń (Visual Basic)

Porady: wypełnianie kolekcji Object z wielu źródeł (LINQ)

Porady: zwracanie wyniku zapytania LINQ jako określonego typu (Visual Basic)

Porady: dzielenie pliku na kilka plików za pomocą grup (LINQ)

Informacje

select — Klauzula (odwołanie w C#)

Select — Klauzula (Visual Basic)

System.Linq

Koncepcje

Standardowe operatory zapytań — Omówienie