Operações de projeção

Projeção refere-se a operação de transformação de um objeto em um novo formulário, geralmente consiste somente as propriedades que serão usadas posteriormente. Usando a projeção, você pode construir um novo tipo, é criado a partir de cada objeto. Pode-se uma propriedade de projeto e executar uma função matemática nele. Você também pode projetar o objeto original sem alterá-lo.

Os métodos de operador de consulta padrão que realizam a projeção estão listados na seção a seguir.

Métodos

Nome do método	Descrição	C# Expressão de consulta sintaxe	Visual BasicSintaxe de expressão de consulta	Mais informações
Select	Valores de projetos baseiam-se uma função de transformação.	select	Select	Enumerable.Select Queryable.Select
SelectMany	Seqüências de projetos de valores que sejam baseiam em uma função de transformação e nivela-o em uma seqüência.	Usar várias from cláusulas	Usar várias From cláusulas	Enumerable.SelectMany Queryable.SelectMany

Exemplos de sintaxe de expressão de consulta

Select

O exemplo a seguir usa a select cláusula C# ou Select cláusula Visual Basic ao projeto a primeira letra de cada seqüência de caracteres em uma lista de seqüências de caracteres.

        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

O exemplo a seguir usa vários from as cláusulas em C# ou From as cláusulas em Visual Basic ao projeto de cada palavra de cada seqüência de caracteres em uma lista de seqüências de caracteres.

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

Selecione versus SelectMany

O trabalho dos dois Select() e SelectMany() é produzir um valor de resultado (ou valores) de valores de origem. **Select()**produz um valor de resultado para cada valor de origem. Portanto, o resultado geral é uma coleção que tem o mesmo número de elementos, como a coleção de origem. Em contraste, SelectMany() produz um único resultado geral que contém o sub-collections concatenados de cada valor de origem. A função de transformação é passada como um argumento para SelectMany() deve retornar uma seqüência enumerável de valores para cada valor de origem. Essas seqüências de enumerable depois são concatenadas por SelectMany() para criar uma seqüência de grandes.

As duas ilustrações a seguir mostram a diferença conceitual entre as ações desses dois métodos. Em cada caso, suponha que a função de seletor (transformação) seleciona a matriz de flores de cada valor de origem.

Esta ilustração apresenta como Select() retorna uma coleção que tem o mesmo número de elementos como a coleção de origem.

Esta ilustração apresenta como SelectMany() concatena a seqüência de intermediária dos arrays em um valor do resultado final, que contém a cada valor de cada array intermediário.

Exemplo de código

O exemplo a seguir compara o comportamento de Select() e SelectMany(). O código cria um Buquê de"" de flores, tirando os dois primeiros itens de cada lista de nomes de flor na coleção de origem. Neste exemplo, o "valor único" que a função de transformação Select<TSource, TResult>(IEnumerable<TSource>, Func<TSource, TResult>) usa o próprio é uma coleção de valores. Isso requer que o extra foreach (For Each na Visual Basic) o loop para enumerar cada seqüência de caracteres em cada 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
    */

}

Consulte também

Tarefas

Como: Combinar Dados com LINQ usando Joins Visual Basic)

Como: Preencher as coleções de objetos de várias fontes (LINQ)

Como: retornar um resultado da consulta LINQ como um tipo específico (Visual Basic)

Como: Dividir um arquivo em vários arquivos usando grupos (LINQ)

Referência

Selecione a cláusula (referência de TRANSLATION FROM VPE FOR CSHARP)

Cláusula Select (Visual Basic)

System.Linq

Conceitos

Visão geral operadores de consulta padrão