Operações de projeção

Projeção refere-se a operação de transformar um objeto em um novo formulário que geralmente consiste somente as propriedades que serão usadas posteriormente.Usando a projeção, você pode construir um novo tipo é construído a partir de cada objeto.Pode ser 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ões de consulta	Mais informações
Select	Valores de projetos que sejam baseiam em uma função de transformação.	select	Select	Enumerable.Select Queryable.Select
SelectMany	Sequências de projetos de valores que sejam baseiam em uma função de transformação e, em seguida, nivela-los 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ões de consulta

Select

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

        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 para cada palavra de cada seqüência de caracteres em uma lista de seqüências de caracteres do projeto.

        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) dos valores de origem.**Select()**produz um valor de resultado para cada valor de origem.Portanto, o resultado geral é um conjunto que possui o mesmo número de elementos, como a coleção de origem.Em contraste, SelectMany() produz um único resultado geral que contém sub-collections concatenados de cada valor de origem.A função de transformação que é 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 grande.

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 de 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 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 é uma coleção de valores em si.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 associações (Visual Basic)

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

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

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

Referência

(referência de C#) da cláusula Select

Selecione a cláusula (Visual Basic)

System.Linq

Conceitos

Visão geral operadores de consulta padrão