Compartilhar via

Instruções passo a passo: escrevendo consultas em C# (LINQ)

  • Artigo

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

  1. Inicie o Visual Studio.

  2. Na barra de menu, escolha Arquivo, Novo, Projeto.

    A Caixa de diálogo Novo Projeto é exibida.

  3. InstaladoExpanda, expanda, expanda ModelosVisual C#, e então escolha Aplicativo de Console.

  4. 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.

  5. 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 Propriedades autoimplementadas (Guia de Programação em C#) e Inicializadores de objeto e coleção (Guia de Programação em 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 locais de tipo implícito (Guia de Programação em C#).)

    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

  1. 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>.

  2. 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);
}

// Output: 
// Omelchenko, Svetlana 
// Garcia, Cesar 
// Fakhouri, Fadi 
// Feng, Hanying 
// Garcia, Hugo 
// Adams, Terry 
// Zabokritski, Eugene 
// Tucker, Michael

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 Cláusula where (Referência de C#).

Modificar a consulta

Para ordenar os resultados

  1. 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

  2. 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

  3. 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

  1. 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];

  2. 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);
    }
}

// Output: 
// O 
//   Omelchenko, Svetlana 
//   O'Donnell, Claire 
// M 
//   Mortensen, Sven 
// G 
//   Garcia, Cesar 
//   Garcia, Debra 
//   Garcia, Hugo 
// F 
//   Fakhouri, Fadi 
//   Feng, Hanying 
// T 
//   Tucker, Lance 
//   Tucker, Michael 
// A 
//   Adams, Terry 
// Z 
//   Zabokritski, Eugene

  3. 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);
    }
}

// Output: 
// O 
//   Omelchenko, Svetlana 
//   O'Donnell, Claire 
// M 
//   Mortensen, Sven 
// G 
//   Garcia, Cesar 
//   Garcia, Debra 
//   Garcia, Hugo 
// F 
//   Fakhouri, Fadi 
//   Feng, Hanying 
// T 
//   Tucker, Lance 
//   Tucker, Michael 
// A 
//   Adams, Terry 
// Z 
//   Zabokritski, Eugene

    Para obter mais informações sobre var, consulte Variáveis locais de tipo implícito (Guia de Programação em C#).

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);
    }
}

// Output: 
//A 
//   Adams, Terry 
//F 
//   Fakhouri, Fadi 
//   Feng, Hanying 
//G 
//   Garcia, Cesar 
//   Garcia, Debra 
//   Garcia, Hugo 
//M 
//   Mortensen, Sven 
//O 
//   Omelchenko, Svetlana 
//   O'Donnell, Claire 
//T 
//   Tucker, Lance 
//   Tucker, Michael 
//Z 
//   Zabokritski, Eugene

    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);
}

// Output: 
// Omelchenko Svetlana 
// O'Donnell Claire 
// Mortensen Sven 
// Garcia Cesar 
// Fakhouri Fadi 
// Feng Hanying 
// Garcia Hugo 
// Adams Terry 
// Zabokritski Eugene 
// Tucker Michael

    Para obter mais informações, consulte Cláusula let (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);

// Output: 
// Class average score = 334.166666666667

Para transformar ou projeto na cláusula select

  1. É 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);
}

// Output: 
// The Garcias in the class are: 
// Cesar 
// Debra 
// Hugo

  2. 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);
}

// Output: 
// Student ID: 113, Score: 338 
// Student ID: 114, Score: 353 
// Student ID: 116, Score: 369 
// Student ID: 117, Score: 352 
// Student ID: 118, Score: 343 
// Student ID: 120, Score: 341 
// Student ID: 122, Score: 368

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:

LINQ to SQL [wd_LINQSQL]

LINQ to DataSet

LINQ to XML

Objetos LINQ to

Consulte também

Tarefas

Instruções passo a passo: escrevendo consultas em Visual Basic

Conceitos

Expressões de consulta LINQ (Guia de Programação em C#)

Recursos LINQ suplementares

Outros recursos

LINQ (Consulta Integrada à Linguagem)

Introdução a LINQ em C#