Passo a passo: Escrever consultas em C# (LINQ)

Artigo
02/25/2013

Essa explicação passo a passo demonstra os recursos de linguagem C# que são usados para gravar expressões de consulta de LINQ .Após concluir essa explicação passo a passo você estará pronto para mover sobre os exemplos e a documentação para o provedor específico de LINQ que você está interessado em, como LINQ to SQL, LINQ ao datasets, ou LINQ to XML.

Pré-requisitos

Essa explicação passo a passo requer os recursos que são apresentados no Visual Studio 2008.

link para vídeo Para uma versão de vídeo deste tópico, consulte Como: exibição Escrevendo consultas em C# (LINQ).

Crie um Pack C#

Para criar um projeto

Inicie o Visual Studio.
Na barra de menu, escolha Arquivo, Novo, Projeto.

A Caixa de diálogo Novo Projeto é exibida.
InstaladoExpanda, expanda, expanda ModelosVisual C#, e então escolha Aplicativo de Console.
Na caixa de texto de Nome , digite um nome diferente ou aceite o nome padrão, e então escolha o botão de OK .

O novo projeto aparece no Gerenciador de Soluções.
Observe que seu projeto possui uma referência a System.Core.dll e uma política de using para o namespace de System.Linq .

Crie uma fonte de dados em memória

A fonte de dados para consultas é uma lista simples de objetos de Student .Cada registro de Student tem um nome, o sobrenome, e uma matriz de inteiros que representa as pontuações na classe.Copiar esse código em seu projeto.Observe as seguintes características:

A classe de Student consiste de propriedades autoimplementadas.
Cada aluno na lista é inicializado com um inicializador de objeto.
A própria lista é inicializada com um inicializador de coleção.

Essa estrutura de dados inteira será inicializada e instanciada sem explícitos chamadas para o construtor explícito ou acesso de membro.Para obter mais informações sobre esses novos recursos, consulte Auto-implementado propriedades (guia de programação do C#) e Objeto e coleção inicializadores (guia de programação do C#).

Para criar a fonte de dados

Adicione a classe de Student e a lista de alunos inicializada para a classe de Program em seu projeto.

public class Student
{
    public string First { get; set; }
    public string Last { get; set; }
    public int ID { get; set; }
    public List<int> Scores;
}

// Create a data source by using a collection initializer.
static List<Student> students = new List<Student>
{
   new Student {First="Svetlana", Last="Omelchenko", ID=111, Scores= new List<int> {97, 92, 81, 60}},
   new Student {First="Claire", Last="O’Donnell", ID=112, Scores= new List<int> {75, 84, 91, 39}},
   new Student {First="Sven", Last="Mortensen", ID=113, Scores= new List<int> {88, 94, 65, 91}},
   new Student {First="Cesar", Last="Garcia", ID=114, Scores= new List<int> {97, 89, 85, 82}},
   new Student {First="Debra", Last="Garcia", ID=115, Scores= new List<int> {35, 72, 91, 70}},
   new Student {First="Fadi", Last="Fakhouri", ID=116, Scores= new List<int> {99, 86, 90, 94}},
   new Student {First="Hanying", Last="Feng", ID=117, Scores= new List<int> {93, 92, 80, 87}},
   new Student {First="Hugo", Last="Garcia", ID=118, Scores= new List<int> {92, 90, 83, 78}},
   new Student {First="Lance", Last="Tucker", ID=119, Scores= new List<int> {68, 79, 88, 92}},
   new Student {First="Terry", Last="Adams", ID=120, Scores= new List<int> {99, 82, 81, 79}},
   new Student {First="Eugene", Last="Zabokritski", ID=121, Scores= new List<int> {96, 85, 91, 60}},
   new Student {First="Michael", Last="Tucker", ID=122, Scores= new List<int> {94, 92, 91, 91} }
};

Para adicionar um novo aluno para listar alunos

Adicionar novo Student à lista de Students e use um nome e pontuações de sua escolha.Tente digitar qualquer novo informações de aluno melhor para aprender a sintaxe para o inicializador de objeto.

Crie a consulta

Para criar uma simples consulta

No método de Main do aplicativo, crie uma simples consulta que, quando é executada, gerar uma lista de todos os alunos cuja contagem no primeiro teste fosse maior que 90.Observe que porque o objeto de Student inteiro é selecionado, o tipo de consulta é IEnumerable<Student>.Embora o código também pode usar tipagem implícita usando a palavra-chave de var , digite explícito é usado para ilustrar claramente resultados.(Para obter mais informações sobre var, consulte Variáveis de locais digitadas implicitamente (C# Guia de programação).)

Observe também que o intervalo variável de consulta, student, serve como uma referência a cada Student na fonte, fornecendo acesso de membro para cada objeto.


// Create the query.
// The first line could also be written as "var studentQuery ="
IEnumerable<Student> studentQuery =
    from student in students
    where student.Scores[0] > 90
    select student;

Executar a consulta

Para executar a consulta

Escreva agora o loop de foreach que fará com que a consulta seja executado.Observe o seguinte no código:
- Cada elemento na sequência retornado é acessado através da variável de iteração do loop de foreach .
- O tipo dessa variável é Student, e o tipo da variável de consulta é compatível, IEnumerable<Student>.
Depois de adicionar este código, compilação e executar o aplicativo pressionando CTRL + F5 para ver os resultados na janela de Console .

// Execute the query.
// var could be used here also.
foreach (Student student in studentQuery)
{
    Console.WriteLine("{0}, {1}", student.Last, student.First);
}

Para adicionar outra condição de filtro

Você pode combinar várias condições booleanas na cláusula de where para refinar mais uma consulta.O código a seguir adiciona uma condição de modo que a consulta retorna os alunos cujos primeira a contagem estava sobre 90 e cuja contagem a última foi menor que 80.A cláusula de where deve se parecer com o seguinte código.
```
where student.Scores[0] > 90 && student.Scores[3] < 80
```
Para obter mais informações, consulte onde a cláusula (referência de C#).

Modificar a consulta

Para ordenar os resultados

Será mais fácil verificação os resultados estão em algum tipo de ordem.Você pode classificar a sequência retornado por qualquer campo acessível em elementos de origem.Por exemplo, a seguinte cláusula de orderby ordenar os resultados em ordem alfabética A Z de acordo com o sobrenome de cada aluno.Adicione a seguinte orderby cláusula da sua consulta, mesmo após a instrução de where e antes da instrução de select :
```
orderby student.Last ascending
```
Agora alterar a cláusula de orderby de modo que regra os resultados em ordem inversa de acordo com a contagem no primeiro teste, da contagem mais alta para a menor número.
```
orderby student.Scores[0] descending
```
Altere a cadeia de caracteres de formato de WriteLine para que você possa ver os resultados:
```
Console.WriteLine("{0}, {1} {2}", student.Last, student.First, student.Scores[0]);
```
Para obter mais informações, consulte cláusula OrderBy (referência de C#).

Para agrupar os resultados

O agrupamento é um recurso avançado em expressões de consulta.Uma consulta com uma cláusula do grupo gera uma sequência de grupos, e cada grupo próprio contém Key e uma sequência que consiste em todos os membros do grupo.A seguinte nova consulta agrupa os alunos usando a primeira letra de seu último sobrenome como a chave.
```
// studentQuery2 is an IEnumerable<IGrouping<char, Student>>
var studentQuery2 =
    from student in students
    group student by student.Last[0];
```

Observe que o tipo de consulta se tiver alterado o momento.Agora gera uma sequência dos grupos que tem um tipo de char como chave, e uma sequência de Student objetos.Porque o tipo de consulta foi alterado, o código a seguir altera o loop de execução de foreach também:

// studentGroup is a IGrouping<char, Student>
foreach (var studentGroup in studentQuery2)
{
    Console.WriteLine(studentGroup.Key);
    foreach (Student student in studentGroup)
    {
        Console.WriteLine("   {0}, {1}",
                  student.Last, student.First);
    }
}

Pressione CTRL + F5 para executar o aplicativo e exibir os resultados na janela de Console .

Para obter mais informações, consulte cláusula Group (referência de C#).

Para fazer as variáveis de tipo implícito

Explicitamente codificar IEnumerables de IGroupings rapidamente pode se tornar tedioso para.Você pode escrever a mesma consulta e loop de foreach muito mais conveniente usando var.A palavra-chave de var não altera os tipos de seus objetos; instrui apenas para o compilador inferir os tipos.Altere o tipo de studentQuery e a iteração groupa variável var e executar novamente a consulta.Observe que no loop mais interno de foreach , a variável de iteração é digitado ainda como Student, e a consulta funciona exatamente como antes.Modificar a variável de iteração de s a var e executar a consulta novamente.Você verá que você obtém exatamente os mesmos resultados.
```
var studentQuery3 =
    from student in students
    group student by student.Last[0];

foreach (var groupOfStudents in studentQuery3)
{
    Console.WriteLine(groupOfStudents.Key);
    foreach (var student in groupOfStudents)
    {
         Console.WriteLine("   {0}, {1}",
             student.Last, student.First);
    }
}
```
Para obter mais informações sobre var, consulte Variáveis de locais digitadas implicitamente (C# Guia de programação).

Para ordenar os grupos pelo valor da chave

Quando você executa a consulta anterior, você observa que os grupos são não em ordem alfabética.Para alterar isso, você deve fornecer uma cláusula de orderby após a cláusula de group .Mas para usar uma cláusula de orderby , você precisa primeiro um identificador que serve como uma referência aos grupos criados pela cláusula de group .Você fornece o identificador de into usando a palavra-chave, como segue:

            var studentQuery4 =
                from student in students
                group student by student.Last[0] into studentGroup
                orderby studentGroup.Key
                select studentGroup;

            foreach (var groupOfStudents in studentQuery4)
            {
                Console.WriteLine(groupOfStudents.Key);
                foreach (var student in groupOfStudents)
                {
                    Console.WriteLine("   {0}, {1}",
                        student.Last, student.First);
                }
            }

Quando você executa essa consulta, você verá os grupos está classificada agora em ordem alfabética.

Para criar um identificador usando deixe

Você pode usar a palavra-chave de let para introduzir um identificador para todo o resultado da expressão na expressão de consulta.Este identificador pode ser uma conveniência, como no exemplo a seguir, ou pode melhorar o desempenho armazenando os resultados de uma expressão para que ele não tenha que se calcular várias vezes.

// studentQuery5 is an IEnumerable<string>
// This query returns those students whose
// first test score was higher than their
// average score.
var studentQuery5 =
    from student in students
    let totalScore = student.Scores[0] + student.Scores[1] +
        student.Scores[2] + student.Scores[3]
    where totalScore / 4 < student.Scores[0]
    select student.Last + " " + student.First;

foreach (string s in studentQuery5)
{
    Console.WriteLine(s);
}

Para obter mais informações, consulte permitir que a cláusula (referência de C#).

Para usar a sintaxe método em uma expressão de consulta

Como descrito em Sintaxe de consulta e sintaxe de método em LINQ (C#), algumas operações consulta só podem ser expressas usando a sintaxe método.O código a seguir calcula a contagem total para cada Student em sequência de origem em seguida, chame o método de Average() nos resultados da consulta para calcular a contagem meio da classe.Observe o posicionamento dos parênteses ao redor da expressão de consulta.
```
    var studentQuery6 = 
        from student in students
        let totalScore = student.Scores[0] + student.Scores[1] +
            student.Scores[2] + student.Scores[3]
        select totalScore;

    double averageScore = studentQuery6.Average();
Console.WriteLine("Class average score = {0}", averageScore);
```

Para transformar ou projeto na cláusula select

É muito comum uma consulta gerar uma sequência cujos elementos para diferir de elementos em sequências de origem.Excluir ou comente para fora seu loop de consulta anterior e de execução, e substitui-lo com o código a seguir.Observe que a consulta retorna uma sequência de cadeias de caracteres (não Students), e esse fato é refletido no loop de foreach .

            IEnumerable<string> studentQuery7 =
                from student in students
                where student.Last == "Garcia"
                select student.First;

            Console.WriteLine("The Garcias in the class are:");
            foreach (string s in studentQuery7)
            {
                Console.WriteLine(s);
            }

O código anteriormente neste passo-a-passo indicou que a contagem meio da classe é aproximadamente 334.Para gerar uma sequência de Students cuja contagem total é maior do que a média da classe, junto com seu Student ID, você pode usar um anônimo na declaração de select :

            var studentQuery8 =
                from student in students
                let x = student.Scores[0] + student.Scores[1] +
                    student.Scores[2] + student.Scores[3]
                where x > averageScore
                select new { id = student.ID, score = x };

            foreach (var item in studentQuery8)
            {
                Console.WriteLine("Student ID: {0}, Score: {1}", item.id, item.score);
            }

Próximas etapas

Depois que você é familiarizado com os aspectos básicos de trabalhar com consultas em C#, você está pronto para ler a documentação e exemplos para o tipo específico de provedor de LINQ que você está interessado em:

Consulte também

Partilhar via