LINQ - Guia Rápido

Desenvolvedores em todo o mundo sempre encontraram problemas na consulta de dados por causa da falta de um caminho definido e precisam dominar várias tecnologias como SQL, Web Services, XQuery, etc.

Introduzido no Visual Studio 2008 e projetado por Anders Hejlsberg, LINQ (Language Integrated Query) permite escrever consultas mesmo sem o conhecimento de linguagens de consulta como SQL, XML etc. As consultas LINQ podem ser escritas para diversos tipos de dados.

Exemplo de uma consulta LINQ

C #

using System;
using System.Linq;

class Program {
   static void Main() {
   
      string[] words = {"hello", "wonderful", "LINQ", "beautiful", "world"};
		
      //Get only short words
      var shortWords = from word in words where word.Length <= 5 select word;
	    
      //Print each word out
      foreach (var word in shortWords) {
         Console.WriteLine(word);
      }	 
		
      Console.ReadLine();
   }
}

VB

Module Module1
   Sub Main()
      Dim words As String() = {"hello", "wonderful", "LINQ", "beautiful", "world"}
     
      ' Get only short words
      Dim shortWords = From word In words _ Where word.Length <= 5 _ Select word
     
      ' Print each word out.
	  
      For Each word In shortWords
         Console.WriteLine(word)
      Next
	  
      Console.ReadLine()
   End Sub
End Module

Quando o código acima de C # ou VB é compilado e executado, ele produz o seguinte resultado -

hello 
LINQ 
world

Sintaxe de LINQ

Existem duas sintaxes de LINQ. Estes são os seguintes.

Sintaxe Lamda (Método)

var longWords = words.Where( w ⇒ w.length > 10);
Dim longWords = words.Where(Function(w) w.length > 10)

Sintaxe de consulta (compreensão)

var longwords = from w in words where w.length > 10;
Dim longwords = from w in words where w.length > 10

Tipos de LINQ

Os tipos de LINQ são mencionados resumidamente a seguir.

• LINQ to Objects
• LINQ to XML (XLINQ)
• LINQ para DataSet
• LINQ to SQL (DLINQ)
• LINQ to Entities

Além do acima, há também um tipo LINQ denominado PLINQ, que é o LINQ paralelo da Microsoft.

Arquitetura LINQ em .NET

LINQ tem uma arquitetura de 3 camadas em que a camada superior consiste nas extensões de linguagem e a camada inferior consiste em fontes de dados que são normalmente objetos que implementam interfaces genéricas IEnumerable <T> ou IQueryable <T>. A arquitetura é mostrada abaixo.

Expressões de consulta

A expressão de consulta nada mais é do que uma consulta LINQ, expressa em um formato semelhante ao do SQL com operadores de consulta como Select, Where e OrderBy. As expressões de consulta geralmente começam com a palavra-chave "De".

Para acessar os operadores de consulta LINQ padrão, o namespace System.Query deve ser importado por padrão. Essas expressões são escritas em uma sintaxe de consulta declarativa que era C # 3.0.

Abaixo está um exemplo para mostrar uma operação de consulta completa que consiste na criação de fonte de dados, definição de expressão de consulta e execução de consulta.

C #

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Operators {
   class LINQQueryExpressions {
      static void Main() {
      
         // Specify the data source.
         int[] scores = new int[] { 97, 92, 81, 60 };

         // Define the query expression.
         IEnumerable<int> scoreQuery = from score in scores where score > 80 select score;

         // Execute the query.
		 
         foreach (int i in scoreQuery) {
            Console.Write(i + " ");
         }
		 
         Console.ReadLine();
      }
   }
}

Quando o código acima é compilado e executado, ele produz o seguinte resultado -

97 92 81

Métodos de Extensão

Introduzido com o .NET 3.5, os métodos de extensão são declarados em classes estáticas apenas e permitem a inclusão de métodos personalizados em objetos para realizar algumas operações de consulta precisas para estender uma classe sem ser um membro real dessa classe. Eles também podem estar sobrecarregados.

Em suma, os métodos de extensão são usados ​​para traduzir expressões de consulta em chamadas de método tradicionais (orientado a objeto).

Diferença entre LINQ e procedimento armazenado

Existe uma série de diferenças entre os procedimentos LINQ e armazenados. Essas diferenças são mencionadas a seguir.

• Os procedimentos armazenados são muito mais rápidos do que uma consulta LINQ, pois seguem um plano de execução esperado.

• É fácil evitar erros de tempo de execução durante a execução de uma consulta LINQ do que em comparação a um procedimento armazenado, já que o primeiro tem suporte a Intellisense do Visual Studio, bem como verificação de tipo completo durante o tempo de compilação.

• O LINQ permite a depuração usando o depurador .NET, o que não ocorre no caso de procedimentos armazenados.

• O LINQ oferece suporte para vários bancos de dados em contraste com procedimentos armazenados, onde é essencial reescrever o código para diversos tipos de bancos de dados.

• A implantação de uma solução baseada em LINQ é fácil e simples em comparação com a implantação de um conjunto de procedimentos armazenados.

Necessidade de LINQ

Antes do LINQ, era essencial aprender C #, SQL e várias APIs que unem os dois para formar um aplicativo completo. Desde então, essas fontes de dados e linguagens de programação enfrentam uma incompatibilidade de impedância; uma necessidade de codificação curta é sentida.

Abaixo está um exemplo de quantas técnicas diversas foram usadas pelos desenvolvedores ao consultar dados antes do advento do LINQ.

SqlConnection sqlConnection = new SqlConnection(connectString);
SqlConnection.Open();

System.Data.SqlClient.SqlCommand sqlCommand = new SqlCommand();
sqlCommand.Connection = sqlConnection;

sqlCommand.CommandText = "Select * from Customer";
return sqlCommand.ExecuteReader (CommandBehavior.CloseConnection)

Curiosamente, das linhas de código apresentadas, a consulta é definida apenas pelas duas últimas. Usando o LINQ, a mesma consulta de dados pode ser escrita em uma forma codificada por cores legível, como a seguinte, mencionada abaixo, em muito menos tempo.

Northwind db = new Northwind(@"C:\Data\Northwnd.mdf");
var query = from c in db.Customers select c;

Vantagens do LINQ

LINQ oferece uma série de vantagens e entre elas a principal é sua expressividade poderosa, que permite que os desenvolvedores se expressem declarativamente. Algumas das outras vantagens do LINQ são fornecidas abaixo.

• LINQ oferece realce de sintaxe que se mostra útil para descobrir erros durante o tempo de design.

• LINQ oferece IntelliSense, o que significa escrever consultas mais precisas facilmente.

• Escrever códigos é muito mais rápido no LINQ e, portanto, o tempo de desenvolvimento também é reduzido significativamente.

• LINQ facilita a depuração devido à sua integração na linguagem C #.

• Visualizar o relacionamento entre duas tabelas é fácil com o LINQ devido ao seu recurso hierárquico e isso permite a composição de consultas unindo várias tabelas em menos tempo.

• O LINQ permite o uso de uma única sintaxe LINQ ao consultar muitas fontes de dados diversas, principalmente por causa de sua base unitiva.

• O LINQ é extensível, o que significa que é possível usar o conhecimento do LINQ para consultar novos tipos de fonte de dados.

• O LINQ oferece a facilidade de juntar várias fontes de dados em uma única consulta, bem como dividir problemas complexos em um conjunto de consultas curtas fáceis de depurar.

• LINQ oferece fácil transformação para conversão de um tipo de dados em outro, como transformar dados SQL em dados XML.

Antes de começar com os programas LINQ, é melhor primeiro entender as nuances da configuração de um ambiente LINQ. LINQ precisa de um framework .NET, uma plataforma revolucionária para ter diversos tipos de aplicativos. Uma consulta LINQ pode ser escrita em C # ou Visual Basic convenientemente.

A Microsoft oferece ferramentas para ambas as linguagens, ou seja, C # e Visual Basic por meio do Visual Studio. Nossos exemplos são todos compilados e escritos no Visual Studio 2010. No entanto, a edição Visual Basic 2013 também está disponível para uso. É a versão mais recente e tem muitas semelhanças com o Visual Studio 2012.

Instalando o Visual Studio 2010 no Windows 7

O Visual Studio pode ser instalado a partir de uma mídia de instalação como um DVD. São necessárias credenciais de administrador para instalar o Visual Basic 2010 em seu sistema com êxito. É vital desconectar todos os dispositivos USB removíveis do sistema antes da instalação, caso contrário, a instalação pode falhar. Alguns dos requisitos de hardware essenciais para a instalação são os seguintes.

Requisitos de Hardware

• 1,6 GHz ou mais
• 1 GB de RAM
• 3 GB (espaço disponível no disco rígido)
• Unidade de disco rígido de 5400 RPM
• Placa de vídeo compatível com DirectX 9
• Unidade de DVD-ROM

Etapas de instalação

Step 1 - Primeiro, depois de inserir o DVD com o Pacote do Visual Studio 2010, clique em Install or run program from your media aparecendo em uma caixa pop-up na tela.

Step 2- Agora configurado para Visual Studio aparecerá na tela. EscolherInstall Microsoft Visual Studio 2010.

Step 3- Assim que você clicar, o processo será iniciado e uma janela de configuração aparecerá em sua tela. Após a conclusão do carregamento dos componentes de instalação, o que levará algum tempo, clique emNext botão para ir para a próxima etapa.

Step 4 - Esta é a última etapa da instalação e uma página inicial aparecerá na qual simplesmente escolha "Li e aceito os termos da licença" e clique em Next botão.

Step 5- Agora selecione os recursos a serem instalados na página de opções que aparece na tela. Você pode escolherFull ou Customopção. Se você tiver menos espaço em disco do que o necessário mostrado nos requisitos de espaço em disco, vá para Personalizado.

Step 6- Quando você escolhe a opção Personalizado, a seguinte janela aparecerá. Selecione os recursos que deseja instalar e clique emUpdate ou então vá para a etapa 7. No entanto, é recomendável não ir com a opção personalizada, pois no futuro você pode precisar dos recursos que optou por não ter.

Step 7- Em breve uma janela pop-up será exibida e a instalação será iniciada, o que pode demorar um pouco. Lembre-se de que isso é para instalar todos os componentes.

Step 8- Finalmente, você poderá ver uma mensagem em uma janela informando que a instalação foi concluída com sucesso. CliqueFinish.

Escrevendo um programa C # usando LINQ no Visual Studio 2010

• Inicie a edição Visual Studio 2010 Ultimate e escolha Arquivo seguido de Novo projeto no menu.

• Uma nova caixa de diálogo do projeto aparecerá na tela.

• Agora escolha Visual C # como uma categoria em modelos instalados e em seguida escolha o modelo de aplicativo de console conforme mostrado na figura abaixo.

• Dê um nome ao seu projeto na caixa de nome inferior e pressione OK.

• O novo projeto aparecerá no Gerenciador de Soluções no lado direito de uma nova caixa de diálogo na tela.

• Agora escolha Program.cs no Solution Explorer e você pode visualizar o código na janela do editor que começa com 'using System'.

• Aqui você pode começar a codificar seu seguinte programa C #.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
			
namespace HelloWorld {
   class Program {
      static void Main(string[] args) {
      
         Console.WriteLine("Hello World")
         Console.ReadKey();
      } 		
   }
}

• Pressione a tecla F5 e execute seu projeto. É altamente recomendável salvar o projeto escolhendoFile → Save All antes de executar o projeto.

Escrevendo um programa VB usando LINQ no Visual Studio 2010

• Inicie a edição Visual Studio 2010 Ultimate e escolha Arquivo seguido de Novo projeto no menu.

• Uma nova caixa de diálogo do projeto aparecerá na tela.

• Agora escolha Visual Basic como uma categoria em modelos instalados e, em seguida, escolha o modelo de aplicativo de console.

• Dê um nome ao seu projeto na caixa de nome inferior e pressione OK.

• Você verá uma tela com Module1.vb. Comece a escrever seu código VB aqui usando LINQ.

Module Module1

   Sub Main()
      Console.WriteLine("Hello World")
      Console.ReadLine()
   End Sub
   
End Module

• Pressione a tecla F5 e execute seu projeto. É altamente recomendável salvar o projeto escolhendoFile → Save All antes de executar o projeto.

Quando o código de C # ou VB acima é cimpilado e executado, ele produz o seguinte resultado -

Hello World

Um conjunto de métodos de extensão formando um padrão de consulta é conhecido como Operadores de Consulta Padrão LINQ. Como blocos de construção de expressões de consulta LINQ, esses operadores oferecem uma variedade de recursos de consulta, como filtragem, classificação, projeção, agregação, etc.

Os operadores de consulta padrão do LINQ podem ser categorizados nos seguintes com base em sua funcionalidade.

• Operadores de filtragem
• Operadores de adesão
• Operações de Projeção
• Operadores de classificação
• Operadores de agrupamento
• Conversions
• Concatenation
• Aggregation
• Operações Quantificadoras
• Operações de Partição
• Operações de Geração
• Operações de conjunto
• Equality
• Operadores de elemento

Operadores de filtragem

A filtragem é uma operação para restringir o conjunto de resultados de forma que ele tenha apenas elementos selecionados que satisfaçam uma condição específica.

Mostrar exemplos

Operador	Descrição	Sintaxe de expressão de consulta C #	Sintaxe de expressão de consulta VB
Onde	Filtrar valores com base em uma função de predicado	Onde	Onde
OfType	Filtre os valores com base em sua capacidade de ser como um tipo especificado	Não aplicável	Não aplicável

Operadores de adesão

A união refere-se a uma operação na qual as fontes de dados com relacionamentos difíceis de acompanhar entre si de forma direta são direcionadas.

Mostrar exemplos

Operador	Descrição	Sintaxe de expressão de consulta C #	Sintaxe de expressão de consulta VB
Junte-se	O operador junta duas sequências com base em chaves correspondentes	entrar ... em ... em ... é igual a ...	De x In…, y In… Onde xa = ya
GroupJoin	Junte duas sequências e agrupe os elementos correspondentes	entrar ... em ... em ... é igual a ... em ...	Participar do grupo… Em… Em…

Operações de Projeção

Projeção é uma operação na qual um objeto é transformado em uma forma totalmente nova, com apenas propriedades específicas.

Mostrar exemplos

Operador	Descrição	Sintaxe de expressão de consulta C #	Sintaxe de expressão de consulta VB
Selecione	O operador projeta valores com base em uma função de transformação	selecionar	Selecione
SelectMany	O operador projeta as sequências de valores que são baseadas em uma função de transformação, bem como os achata em uma única sequência	Use várias cláusulas from	Use várias cláusulas From

Operadores de classificação

Uma operação de classificação permite ordenar os elementos de uma sequência com base em um ou mais atributos.

Mostrar exemplos

Operador	Descrição	Sintaxe de expressão de consulta C #	Sintaxe de expressão de consulta VB
Ordenar por	O operador classifica os valores em ordem crescente	ordenar por	Ordenar por
OrderByDescending	O operador classifica os valores em ordem decrescente	ordem por ... decrescente	Ordem por ... Decrescente
ThenBy	Executa uma classificação secundária em ordem crescente	ordenar por …, …	Ordenar por …, …
ThenByDescending	Executa uma classificação secundária em ordem decrescente	ordem por ..., ... decrescente	Ordem por ..., ... decrescente
Reverter	Executa uma reversão da ordem dos elementos em uma coleção	Não aplicável	Não aplicável

Operadores de agrupamento

Os operadores colocam dados em alguns grupos com base em um atributo compartilhado comum.

Mostrar exemplos

Operador	Descrição	Sintaxe de expressão de consulta C #	Sintaxe de expressão de consulta VB
GroupBy	Organize uma sequência de itens em grupos e retorne-os como uma coleção IEnumerable do tipo IGrouping <chave, elemento>	grupo ... por -ou- grupo ... por ... em ...	Grupo ... Por ... Em ...
Procurar	Execute uma operação de agrupamento em que uma sequência de pares de chaves é retornada	Não aplicável	Não aplicável

Conversões

Os operadores alteram o tipo de objetos de entrada e são usados ​​em uma ampla variedade de aplicativos.

Mostrar exemplos

Operador	Descrição	Sintaxe de expressão de consulta C #	Sintaxe de expressão de consulta VB
AsEnumerable	Retorna a entrada digitada como IEnumerable <T>	Não aplicável	Não aplicável
AsQueryable	Um IEnumerable (genérico) é convertido em um IQueryable (genérico)	Não aplicável	Não aplicável
Fundida	Executa a conversão de elementos de uma coleção para um tipo especificado	Use uma variável de intervalo digitada explicitamente. Ex: da string str em palavras	De ... como ...
OfType	Filtra os valores com base em seus, dependendo de sua capacidade de ser convertido para um tipo específico	Não aplicável	Não aplicável
ToArray	Força a execução da consulta e faz a conversão de uma coleção em uma matriz	Não aplicável	Não aplicável
ToDictionary	Com base em uma função de seletor de chave, defina elementos em um Dictionary <TKey, TValue> e força a execução de uma consulta LINQ	Não aplicável	Não aplicável
Listar	Força a execução de uma consulta convertendo uma coleção em uma Lista <T>	Não aplicável	Não aplicável
Procurar	Força a execução de uma consulta e coloca elementos em um Lookup <TKey, TElement> com base em uma função de seletor de chave	Não aplicável	Não aplicável

Concatenação

Executa a concatenação de duas sequências e é bastante semelhante ao operador União em termos de operação, exceto pelo fato de que isso não remove duplicatas.

Mostrar exemplos

Operador	Descrição	Sintaxe de expressão de consulta C #	Sintaxe de expressão de consulta VB
Concat	Duas sequências são concatenadas para a formação de uma única sequência.	Não aplicável	Não aplicável

Agregação

Executa qualquer tipo de agregação desejada e permite a criação de agregações personalizadas no LINQ.

Mostrar exemplos

Operador	Descrição	Sintaxe de expressão de consulta C #	Sintaxe de expressão de consulta VB
Agregar	Opera nos valores de uma coleção para realizar uma operação de agregação personalizada	Não aplicável	Não aplicável
Média	O valor médio de uma coleção de valores é calculado	Não aplicável	Agregar… em… na média ()
Contagem	Conta os elementos que satisfazem uma função de predicado na coleção	Não aplicável	Agregar… em… na contagem ()
LonCount	Conta os elementos que satisfazem uma função de predicado em uma coleção enorme	Não aplicável	Agregar… Em… Em LongCount ()
Max	Descubra o valor máximo em uma coleção	Não aplicável	Agregar… em… no máximo ()
Min	Descubra o valor mínimo existente em uma coleção	Não aplicável	Agregar… em… em min ()
Soma	Descubra a soma dos valores em uma coleção	Não aplicável	Agregar… em… na soma ()

Operações Quantificadoras

Esses operadores retornam um valor booleano, ou seja, True ou False quando alguns ou todos os elementos de uma sequência satisfazem uma condição específica.

Mostrar exemplos

Operador	Descrição	Sintaxe de expressão de consulta C #	Sintaxe de expressão de consulta VB
Todos	Retorna um valor 'True' se todos os elementos de uma sequência satisfizerem uma condição de predicado	Não aplicável	Agregar ... em ... em todos (...)
Qualquer	Determina, pesquisando uma sequência, se algum elemento da mesma satisfaz uma condição especificada	Não aplicável	Agregar… em… em qualquer ()
Contém	Retorna um valor 'Verdadeiro' se achar que um elemento específico está lá em uma sequência se a sequência não contiver esse elemento específico, o valor 'falso' é retornado	Não aplicável	Não aplicável

Operadores de partição

Divida uma sequência de entrada em duas seções separadas sem reorganizar os elementos da sequência e depois retornar um deles.

Mostrar exemplos

Operador	Descrição	Sintaxe de expressão de consulta C #	Sintaxe de expressão de consulta VB
Pular	Pula um determinado número de elementos em uma sequência e retorna os restantes	Não aplicável	Pular
SkipWhile	Igual ao de Skip, com a única exceção de que o número de elementos a serem ignorados é especificado por uma condição booleana	Não aplicável	Pular enquanto
Levar	Pegue um determinado número de elementos de uma sequência e pule os restantes	Não aplicável	Levar
TakeWhile	Igual a Take, exceto pelo fato de que o número de elementos a serem tomados são especificados por uma condição booleana	Não aplicável	Demorar um pouco

Operações de Geração

Uma nova sequência de valores é criada por operadores geracionais.

Mostrar exemplos

Operador	Descrição	Sintaxe de expressão de consulta C #	Sintaxe de expressão de consulta VB
DefaultIfEmpty	Quando aplicado a uma sequência vazia, gera um elemento padrão dentro de uma sequência	Não aplicável	Não aplicável
Vazio	Retorna uma sequência vazia de valores e é o operador geracional mais simples	Não aplicável	Não aplicável
Alcance	Gera uma coleção com uma sequência de inteiros ou números	Não aplicável	Não aplicável
Repetir	Gera uma sequência contendo valores repetidos de um comprimento específico	Não aplicável	Não aplicável

Operações de conjunto

Existem quatro operadores para as operações definidas, cada um produzindo um resultado com base em critérios diferentes.

Mostrar exemplos

Operador	Descrição	Sintaxe de expressão de consulta C #	Sintaxe de expressão de consulta VB
Distinto	Resulta em uma lista de valores únicos de uma coleção, filtrando dados duplicados, se houver	Não aplicável	Distinto
Exceto	Compara os valores de duas coleções e retorna aqueles de uma coleção que não estão na outra coleção	Não aplicável	Não aplicável
Cruzar	Retorna o conjunto de valores encontrados como idênticos em duas coleções separadas	Não aplicável	Não aplicável
União	Combina o conteúdo de duas coleções diferentes em uma única lista que também sem qualquer conteúdo duplicado	Não aplicável	Não aplicável

Igualdade

Compara duas sentenças (enumeráveis) e determina se são uma correspondência exata ou não.

Mostrar exemplos

Operador	Descrição	Sintaxe de expressão de consulta C #	Sintaxe de expressão de consulta VB
SequenceEqual	Resulta um valor booleano se duas sequências forem idênticas uma à outra	Não aplicável	Não aplicável

Operadores de elemento

Exceto o DefaultIfEmpty, todos os outros oito operadores de elemento de consulta padrão retornam um único elemento de uma coleção.

Mostrar exemplos

Operador	Descrição	Sintaxe de expressão de consulta C #	Sintaxe de expressão de consulta VB
ElementAt	Retorna um elemento presente em um índice específico em uma coleção	Não aplicável	Não aplicável
ElementAtOrDefault	O mesmo que ElementAt, exceto pelo fato de que também retorna um valor padrão no caso de o índice específico estar fora do intervalo	Não aplicável	Não aplicável
Primeiro	Recupera o primeiro elemento de uma coleção ou o primeiro elemento que satisfaz uma condição específica	Não aplicável	Não aplicável
FirstOrDefault	O mesmo que Primeiro, exceto pelo fato de que também retorna um valor padrão caso não haja existência de tais elementos	Não aplicável	Não aplicável
Último	Recupera o último elemento presente em uma coleção ou o último elemento que satisfaça uma condição específica	Não aplicável	Não aplicável
LastOrDefault	O mesmo que o último, exceto pelo fato de que também retorna um valor padrão no caso de não haver qualquer um desses elementos	Não aplicável	Não aplicável
solteiro	Retorna o elemento solitário de uma coleção ou o elemento solitário que satisfaz uma determinada condição	Não aplicável	Não aplicável
SingleOrDefault	O mesmo que Único, exceto que também retorna um valor padrão se não houver nenhum elemento solitário	Não aplicável	Não aplicável
DefaultIfEmpty	Retorna um valor padrão se a coleção ou lista estiver vazia ou nula	Não aplicável	Não aplicável

LINQ to SQL oferece uma infraestrutura (tempo de execução) para o gerenciamento de dados relacionais como objetos. É um componente da versão 3.5 do .NET Framework e habilmente faz a tradução de consultas integradas à linguagem do modelo de objeto em SQL. Essas consultas são então enviadas ao banco de dados para fins de execução. Depois de obter os resultados do banco de dados, o LINQ to SQL os converte novamente em objetos.

Introdução do LINQ To SQL

Para a maioria dos desenvolvedores ASP.NET, LINQ to SQL (também conhecido como DLINQ) é uma parte eletrizante da Consulta Integrada de Linguagem, pois permite consultar dados no banco de dados do servidor SQL usando expressões LINQ usuais. Ele também permite atualizar, excluir e inserir dados, mas a única desvantagem de que sofre é sua limitação ao banco de dados do servidor SQL. No entanto, existem muitos benefícios do LINQ to SQL sobre o ADO.NET, como complexidade reduzida, poucas linhas de codificação e muito mais.

Abaixo está um diagrama que mostra a arquitetura de execução do LINQ to SQL.

Como usar o LINQ to SQL?

Step 1- Faça uma nova “Conexão de Dados” com o servidor de banco de dados. Ver o & arrar; Server Explorer & arrar; Conexões de dados & arrar; Adicionar conexão

Step 2 - Adicionar arquivo de classe LINQ To SQL

Step 3 - Selecione tabelas do banco de dados e arraste e solte no novo arquivo de classe LINQ to SQL.

Step 4 - Adicionadas tabelas ao arquivo de classe.

Consultando com LINQ to SQL

As regras para executar uma consulta com LINQ to SQL são semelhantes às de uma consulta LINQ padrão, ou seja, a consulta é executada de forma adiada ou imediata. Existem vários componentes que desempenham um papel na execução de uma consulta com LINQ to SQL e estes são os seguintes.

• LINQ to SQL API - solicita a execução da consulta em nome de um aplicativo e a envia ao LINQ to SQL Provider.

• LINQ to SQL Provider - converte a consulta em Transact SQL (T-SQL) e envia a nova consulta ao provedor ADO para execução.

• ADO Provider - Após a execução da consulta, envie os resultados na forma de um DataReader para o provedor LINQ to SQL que, por sua vez, os converte em uma forma de objeto de usuário.

Deve-se observar que antes de executar uma consulta LINQ to SQL, é vital conectar-se à fonte de dados por meio da classe DataContext.

Inserir, atualizar e excluir usando LINQ To SQL

Adicionar OU Inserir

C#

using System;
using System.Linq;

namespace LINQtoSQL {
   class LinqToSQLCRUD {
      static void Main(string[] args) {
      
         string connectString = System.Configuration.ConfigurationManager.ConnectionStrings["LinqToSQLDBConnectionString"].ToString();

         LinqToSQLDataContext db = new LinqToSQLDataContext(connectString);           

         //Create new Employee
		 
         Employee newEmployee = new Employee();
         newEmployee.Name = "Michael";
         newEmployee.Email = "[email protected]";
         newEmployee.ContactNo = "343434343";
         newEmployee.DepartmentId = 3;
         newEmployee.Address = "Michael - USA";

         //Add new Employee to database
         db.Employees.InsertOnSubmit(newEmployee);

         //Save changes to Database.
         db.SubmitChanges();

         //Get new Inserted Employee            
         Employee insertedEmployee = db.Employees.FirstOrDefault(e ⇒e.Name.Equals("Michael"));

         Console.WriteLine("Employee Id = {0} , Name = {1}, Email = {2}, ContactNo = {3}, Address = {4}",
                          insertedEmployee.EmployeeId, insertedEmployee.Name, insertedEmployee.Email, 
                          insertedEmployee.ContactNo, insertedEmployee.Address);

         Console.WriteLine("\nPress any key to continue.");
         Console.ReadKey();
      }
   }
}

VB

Module Module1

   Sub Main()
   
      Dim connectString As String = System.Configuration.ConfigurationManager.ConnectionStrings("LinqToSQLDBConnectionString").ToString()

      Dim db As New LinqToSQLDataContext(connectString)

      Dim newEmployee As New Employee()
	  
      newEmployee.Name = "Michael"
      newEmployee.Email = "[email protected]"
      newEmployee.ContactNo = "343434343"
      newEmployee.DepartmentId = 3
      newEmployee.Address = "Michael - USA"
     
      db.Employees.InsertOnSubmit(newEmployee)
     
      db.SubmitChanges()
     
      Dim insertedEmployee As Employee = db.Employees.FirstOrDefault(Function(e) e.Name.Equals("Michael"))

      Console.WriteLine("Employee Id = {0} , Name = {1}, Email = {2}, ContactNo = {3}, 
         Address = {4}", insertedEmployee.EmployeeId, insertedEmployee.Name,
         insertedEmployee.Email, insertedEmployee.ContactNo, insertedEmployee.Address)

      Console.WriteLine(vbLf & "Press any key to continue.")
      Console.ReadKey()
	 
   End Sub
  
End Module

Quando o código acima de C # ou VB é compilado e executado, ele produz o seguinte resultado -

Emplyee ID = 4, Name = Michael, Email = [email protected], ContactNo = 
343434343, Address = Michael - USA

Press any key to continue.

Atualizar

C#

using System;
using System.Linq;

namespace LINQtoSQL {
   class LinqToSQLCRUD {
      static void Main(string[] args) {
      
         string connectString = System.Configuration.ConfigurationManager.ConnectionStrings["LinqToSQLDBConnectionString"].ToString();

         LinqToSQLDataContext db = new LinqToSQLDataContext(connectString);

         //Get Employee for update
         Employee employee = db.Employees.FirstOrDefault(e =>e.Name.Equals("Michael"));

         employee.Name = "George Michael";
         employee.Email = "[email protected]";
         employee.ContactNo = "99999999";
         employee.DepartmentId = 2;
         employee.Address = "Michael George - UK";

         //Save changes to Database.
         db.SubmitChanges();

         //Get Updated Employee            
         Employee updatedEmployee = db.Employees.FirstOrDefault(e ⇒e.Name.Equals("George Michael"));

         Console.WriteLine("Employee Id = {0} , Name = {1}, Email = {2}, ContactNo = {3}, Address = {4}",
                          updatedEmployee.EmployeeId, updatedEmployee.Name, updatedEmployee.Email, 
                          updatedEmployee.ContactNo, updatedEmployee.Address);

         Console.WriteLine("\nPress any key to continue.");
         Console.ReadKey();
      }
   }
}

VB

Module Module1

   Sub Main()
  
      Dim connectString As String = System.Configuration.ConfigurationManager.ConnectionStrings("LinqToSQLDBConnectionString").ToString()

      Dim db As New LinqToSQLDataContext(connectString)

      Dim employee As Employee = db.Employees.FirstOrDefault(Function(e) e.Name.Equals("Michael"))

      employee.Name = "George Michael"
      employee.Email = "[email protected]"
      employee.ContactNo = "99999999"
      employee.DepartmentId = 2
      employee.Address = "Michael George - UK"

      db.SubmitChanges()
          
      Dim updatedEmployee As Employee = db.Employees.FirstOrDefault(Function(e) e.Name.Equals("George Michael"))

      Console.WriteLine("Employee Id = {0} , Name = {1}, Email = {2}, ContactNo = {3},
         Address = {4}", updatedEmployee.EmployeeId, updatedEmployee.Name, 
         updatedEmployee.Email, updatedEmployee.ContactNo, updatedEmployee.Address)

      Console.WriteLine(vbLf & "Press any key to continue.")
      Console.ReadKey()
	  
   End Sub
   
End Module

Quando o código acima de C # ou Vb é compilado e executado, ele produz o seguinte resultado -

Emplyee ID = 4, Name = George Michael, Email = [email protected], ContactNo = 
999999999, Address = Michael George - UK

Press any key to continue.

Excluir

C#

using System;
using System.Linq;

namespace LINQtoSQL {
   class LinqToSQLCRUD {
      static void Main(string[] args) {
      
         string connectString = System.Configuration.ConfigurationManager.ConnectionStrings["LinqToSQLDBConnectionString"].ToString();

         LinqToSQLDataContext db = newLinqToSQLDataContext(connectString);

         //Get Employee to Delete
         Employee deleteEmployee = db.Employees.FirstOrDefault(e ⇒e.Name.Equals("George Michael"));

         //Delete Employee
         db.Employees.DeleteOnSubmit(deleteEmployee);

         //Save changes to Database.
         db.SubmitChanges();

         //Get All Employee from Database
         var employeeList = db.Employees;
         foreach (Employee employee in employeeList) {
            Console.WriteLine("Employee Id = {0} , Name = {1}, Email = {2}, ContactNo = {3}",
               employee.EmployeeId, employee.Name, employee.Email, employee.ContactNo);
         }            

         Console.WriteLine("\nPress any key to continue.");
         Console.ReadKey();
      }
   }
}

VB

Module Module1

   Sub Main()
   
      Dim connectString As String = System.Configuration.ConfigurationManager.ConnectionStrings("LinqToSQLDBConnectionString").ToString()

      Dim db As New LinqToSQLDataContext(connectString)

      Dim deleteEmployee As Employee = db.Employees.FirstOrDefault(Function(e) e.Name.Equals("George Michael"))

      db.Employees.DeleteOnSubmit(deleteEmployee)

      db.SubmitChanges()

      Dim employeeList = db.Employees
	  
      For Each employee As Employee In employeeList
         Console.WriteLine("Employee Id = {0} , Name = {1}, Email = {2}, ContactNo = {3}",
            employee.EmployeeId, employee.Name, employee.Email, employee.ContactNo)
      Next 

      Console.WriteLine(vbLf & "Press any key to continue.")
      Console.ReadKey()
   End Sub
   
End Module

Quando o código acima de C # ou VB é compilado e executado, ele produz o seguinte resultado -

Emplyee ID = 1, Name = William, Email = [email protected], ContactNo = 999999999
Emplyee ID = 2, Name = Miley, Email = [email protected], ContactNo = 999999999
Emplyee ID = 3, Name = Benjamin, Email = [email protected], ContactNo = 

Press any key to continue.

LINQ to Objects oferece o uso de qualquer consulta LINQ com suporte a IEnumerable <T> para acessar coleções de dados na memória sem a necessidade de provedor LINQ (API) como no caso de LINQ to SQL ou LINQ to XML.

Introdução do LINQ para objetos

As consultas em LINQ to Objects retornam variáveis ​​do tipo geralmente apenas IEnumerable <T>. Em suma, LINQ to Objects oferece uma nova abordagem para coleções, pois era vital escrever uma codificação longa (loops foreach de muita complexidade) para recuperação de dados de uma coleção que agora é substituída pela escrita de código declarativo que descreve claramente os dados desejados que é necessário para recuperar.

Existem também muitas vantagens do LINQ to Objects sobre os loops foreach tradicionais, como mais legibilidade, filtragem poderosa, capacidade de agrupamento, ordenação aprimorada com codificação de aplicativo mínima. Essas consultas LINQ também são mais compactas por natureza e são portáteis para qualquer outra fonte de dados sem qualquer modificação ou com apenas uma pequena modificação.

Abaixo está um exemplo simples de LINQ to Objects -

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace LINQtoObjects {
   class Program {
      static void Main(string[] args) {
      
         string[] tools = { "Tablesaw", "Bandsaw", "Planer", "Jointer", "Drill", "Sander" };
         var list = from t in tools select t;

         StringBuilder sb = new StringBuilder();

         foreach (string s in list) {
            sb.Append(s + Environment.NewLine);
         }
		 
         Console.WriteLine(sb.ToString(), "Tools");
         Console.ReadLine();
      }
   }
}

No exemplo, uma matriz de strings (ferramentas) é usada como a coleção de objetos a serem consultados usando LINQ to Objects.

Objects query is:
var list = from t in tools select t;

Quando o código acima é compilado e executado, ele produz o seguinte resultado -

Tablesaw
Bandsaw
Planer
Jointer
Drill
Sander

Consultando coleções de memória usando LINQ to Objects

C #

using System;
using System.Collections.Generic;
using System.Linq;

namespace LINQtoObjects {
   class Department {
      public int DepartmentId { get; set; }
      public string Name { get; set; }
   }

   class LinqToObjects {
      static void Main(string[] args) {
      
         List<Department> departments = new List<Department>();
			
         departments.Add(new Department { DepartmentId = 1, Name = "Account" });
         departments.Add(new Department { DepartmentId = 2, Name = "Sales" });
         departments.Add(new Department { DepartmentId = 3, Name = "Marketing" });

         var departmentList = from d in departments
                              select d;

         foreach (var dept in departmentList) {
            Console.WriteLine("Department Id = {0} , Department Name = {1}",
               dept.DepartmentId, dept.Name);
         }
		 
         Console.WriteLine("\nPress any key to continue.");
         Console.ReadKey();
      }
   }
}

VB

Imports System.Collections.Generic
Imports System.Linq

Module Module1

   Sub Main(ByVal args As String())

      Dim account As New Department With {.Name = "Account", .DepartmentId = 1}
      Dim sales As New Department With {.Name = "Sales", .DepartmentId = 2}
      Dim marketing As New Department With {.Name = "Marketing", .DepartmentId = 3}

      Dim departments As New System.Collections.Generic.List(Of Department)(New Department() {account, sales, marketing})

      Dim departmentList = From d In departments

      For Each dept In departmentList
         Console.WriteLine("Department Id = {0} , Department Name = {1}", dept.DepartmentId, dept.Name)
      Next

      Console.WriteLine(vbLf & "Press any key to continue.")
      Console.ReadKey()
   End Sub

   Class Department
      Public Property Name As String
      Public Property DepartmentId As Integer
   End Class
   
End Module

Quando o código acima de C # ou VB é compilado e executado, ele produz o seguinte resultado -

Department Id = 1, Department Name = Account
Department Id = 2, Department Name = Sales
Department Id = 3, Department Name = Marketing

Press any key to continue.

Um Dataset oferece uma representação de dados extremamente útil na memória e é usado para uma ampla gama de aplicativos baseados em dados. LINQ to Dataset como uma das tecnologias do LINQ to ADO.NET facilita a realização de consultas nos dados de um Dataset de forma descomplicada e aumenta a produtividade.

Introdução do LINQ To Dataset

O LINQ to Dataset tornou a tarefa de consulta simples para os desenvolvedores. Eles não precisam escrever consultas em uma linguagem de consulta específica, em vez disso, o mesmo pode ser escrito em linguagem de programação. LINQ to Dataset também pode ser usado para consultar onde os dados são consolidados de várias fontes de dados. Isso também não precisa de nenhum provedor LINQ, como LINQ to SQL e LINQ to XML, para acessar dados de coleções de memória.

Abaixo está um exemplo simples de uma consulta LINQ to Dataset em que uma fonte de dados é obtida primeiro e, em seguida, o conjunto de dados é preenchido com duas tabelas de dados. Um relacionamento é estabelecido entre as tabelas e uma consulta LINQ é criada em ambas as tabelas por meio da cláusula de junção. Finalmente, o loop foreach é usado para exibir os resultados desejados.

C #

using System;
using System.Collections.Generic;
using System.Data;
using System.Data.SqlClient;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace LINQtoDataset {
   class Program {
      static void Main(string[] args) {
      
         string connectString = System.Configuration.ConfigurationManager.ConnectionStrings["LinqToSQLDBConnectionString"].ToString();

         string sqlSelect = "SELECT * FROM Department;" + "SELECT * FROM Employee;";

         // Create the data adapter to retrieve data from the database
         SqlDataAdapter da = new SqlDataAdapter(sqlSelect, connectString);
        
         // Create table mappings
         da.TableMappings.Add("Table", "Department");
         da.TableMappings.Add("Table1", "Employee");

         // Create and fill the DataSet
         DataSet ds = new DataSet();
         da.Fill(ds);

         DataRelation dr = ds.Relations.Add("FK_Employee_Department",
                           ds.Tables["Department"].Columns["DepartmentId"],
                           ds.Tables["Employee"].Columns["DepartmentId"]);

         DataTable department = ds.Tables["Department"];
         DataTable employee = ds.Tables["Employee"];

         var query = from d in department.AsEnumerable()
                     join e in employee.AsEnumerable()
                     on d.Field<int>("DepartmentId") equals
                     e.Field<int>("DepartmentId")                        
                     select new {
                        EmployeeId = e.Field<int>("EmployeeId"),
                        Name = e.Field<string>("Name"),                            
                        DepartmentId = d.Field<int>("DepartmentId"),                            
                        DepartmentName = d.Field<string>("Name")
                     };

         foreach (var q in query) {
            Console.WriteLine("Employee Id = {0} , Name = {1} , Department Name = {2}",
               q.EmployeeId, q.Name, q.DepartmentName);
         }

         Console.WriteLine("\nPress any key to continue.");
         Console.ReadKey();
      }
   }
}

VB

Imports System.Data.SqlClient
Imports System.Linq

Module LinqToDataSet

   Sub Main()
   
      Dim connectString As String = System.Configuration.ConfigurationManager.ConnectionStrings("LinqToSQLDBConnectionString").ToString()

      Dim sqlSelect As String = "SELECT * FROM Department;" + "SELECT * FROM Employee;"
      Dim sqlCnn As SqlConnection = New SqlConnection(connectString)
      sqlCnn.Open()

      Dim da As New SqlDataAdapter
      da.SelectCommand = New SqlCommand(sqlSelect, sqlCnn)

      da.TableMappings.Add("Table", "Department")
      da.TableMappings.Add("Table1", "Employee")

      Dim ds As New DataSet()
      da.Fill(ds)

      Dim dr As DataRelation = ds.Relations.Add("FK_Employee_Department", ds.Tables("Department").Columns("DepartmentId"), ds.Tables("Employee").Columns("DepartmentId"))

      Dim department As DataTable = ds.Tables("Department")
      Dim employee As DataTable = ds.Tables("Employee")

      Dim query = From d In department.AsEnumerable()
                  Join e In employee.AsEnumerable() On d.Field(Of Integer)("DepartmentId") Equals
                  e.Field(Of Integer)("DepartmentId")
                  Select New Person With { _
                        .EmployeeId = e.Field(Of Integer)("EmployeeId"),
                        .EmployeeName = e.Field(Of String)("Name"),
                        .DepartmentId = d.Field(Of Integer)("DepartmentId"),
                        .DepartmentName = d.Field(Of String)("Name")
                  }

      For Each e In query
         Console.WriteLine("Employee Id = {0} , Name = {1} , Department Name = {2}", e.EmployeeId, e.EmployeeName, e.DepartmentName)
      Next

      Console.WriteLine(vbLf & "Press any key to continue.")
      Console.ReadKey()
	  
   End Sub
  
   Class Person
      Public Property EmployeeId As Integer
      Public Property EmployeeName As String
      Public Property DepartmentId As Integer
      Public Property DepartmentName As String
   End Class
   
End Module

Quando o código acima de C # ou VB é compilado e executado, ele produz o seguinte resultado -

Employee Id = 1, Name = William, Department Name = Account
Employee Id = 2, Name = Benjamin, Department Name = Account
Employee Id = 3, Name = Miley, Department Name = Sales

Press any key to continue.

Consultando conjunto de dados usando LinQ para conjunto de dados

Antes de começar a consultar um Dataset usando LINQ to Dataset, é vital carregar dados em um Dataset e isso é feito usando a classe DataAdapter ou LINQ to SQL. A formulação de consultas usando LINQ to Dataset é bastante semelhante à formulação de consultas usando LINQ junto com outras fontes de dados habilitadas para LINQ.

Consulta de Tabela Única

Na seguinte consulta de tabela única, todos os pedidos online são coletados de SalesOrderHeaderTtable e, em seguida, o ID do pedido, a data do pedido e o número do pedido são exibidos como saída.

C#

using System;
using System.Collections.Generic;
using System.Data;
using System.Data.SqlClient;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace LinqToDataset {
   class SingleTable {
      static void Main(string[] args) {
      
         string connectString = System.Configuration.ConfigurationManager.ConnectionStrings["LinqToSQLDBConnectionString"].ToString();

         string sqlSelect = "SELECT * FROM Department;";

         // Create the data adapter to retrieve data from the database
         SqlDataAdapter da = new SqlDataAdapter(sqlSelect, connectString);

         // Create table mappings
         da.TableMappings.Add("Table", "Department");           

         // Create and fill the DataSet
         DataSet ds = new DataSet();
         da.Fill(ds);

         DataTable department = ds.Tables["Department"];            

         var query = from d in department.AsEnumerable()                        
         select new {
            DepartmentId = d.Field<int>("DepartmentId"),
            DepartmentName = d.Field<string>("Name")
         };

         foreach (var q in query) {
            Console.WriteLine("Department Id = {0} , Name = {1}",
               q.DepartmentId, q.DepartmentName);
         }

         Console.WriteLine("\nPress any key to continue.");
         Console.ReadKey();
      }
   }
}

VB

Imports System.Data.SqlClient
Imports System.Linq

Module LinqToDataSet

   Sub Main()
   
      Dim connectString As String = System.Configuration.ConfigurationManager.ConnectionStrings("LinqToSQLDBConnectionString").ToString()

      Dim sqlSelect As String = "SELECT * FROM Department;"
      Dim sqlCnn As SqlConnection = New SqlConnection(connectString)
      sqlCnn.Open()

      Dim da As New SqlDataAdapter
      da.SelectCommand = New SqlCommand(sqlSelect, sqlCnn)

      da.TableMappings.Add("Table", "Department")
      Dim ds As New DataSet()
      da.Fill(ds)

      Dim department As DataTable = ds.Tables("Department")

      Dim query = From d In department.AsEnumerable()
      Select New DepartmentDetail With {
         .DepartmentId = d.Field(Of Integer)("DepartmentId"),
            .DepartmentName = d.Field(Of String)("Name")
      }

      For Each e In query
         Console.WriteLine("Department Id = {0} , Name = {1}", e.DepartmentId, e.DepartmentName)
      Next

      Console.WriteLine(vbLf & "Press any key to continue.")
      Console.ReadKey()
   End Sub

   Public Class DepartmentDetail
      Public Property DepartmentId As Integer
      Public Property DepartmentName As String
   End Class
   
End Module

Quando o código acima de C # ou VB é compilado e executado, ele produz o seguinte resultado -

Department Id = 1, Name = Account
Department Id = 2, Name = Sales
Department Id = 3, Name = Pre-Sales
Department Id = 4, Name = Marketing

Press any key to continue.

LINQ to XML oferece fácil acessibilidade a todas as funcionalidades do LINQ, como operadores de consulta padrão, interface de programação, etc. Integrado na estrutura .NET, LINQ to XML também faz o melhor uso das funcionalidades da estrutura .NET, como depuração, verificação em tempo de compilação, tipagem forte e muito mais a dizer.

Introdução do LINQ to XML

Ao usar o LINQ to XML, carregar documentos XML na memória é fácil e mais fácil é consultar e modificar o documento. Também é possível salvar em disco documentos XML existentes na memória e serializá-los. Ele elimina a necessidade de um desenvolvedor aprender a linguagem de consulta XML, que é um tanto complexa.

LINQ to XML tem seu poder no namespace System.Xml.Linq. Isso tem todas as 19 classes necessárias para trabalhar com XML. Essas classes são as seguintes.

• XAttribute
• XCData
• XComment
• XContainer
• XDeclaration
• XDocument
• XDocumentType
• XElement
• XName
• XNamespace
• XNode
• XNodeDocumentOrderComparer
• XNodeEqualityComparer
• XObject
• XObjectChange
• XObjectChangeEventArgs
• XObjectEventHandler
• XProcessingInstruction
• XText

Leia um arquivo XML usando LINQ

C #

using System;
using System.Collections.Generic;
using System.Linq;
using System.Xml.Linq;

namespace LINQtoXML {
   class ExampleOfXML {
      static void Main(string[] args) {
      
         string myXML = @"<Departments>
                       <Department>Account</Department>
                       <Department>Sales</Department>
                       <Department>Pre-Sales</Department>
                       <Department>Marketing</Department>
                       </Departments>";

         XDocument xdoc = new XDocument();
         xdoc = XDocument.Parse(myXML);

         var result = xdoc.Element("Departments").Descendants();

         foreach (XElement item in result) {
            Console.WriteLine("Department Name - " + item.Value);
         }

         Console.WriteLine("\nPress any key to continue.");
         Console.ReadKey();
      }
   }
}

VB

Imports System.Collections.Generic
Imports System.Linq
Imports System.Xml.Linq

Module Module1

   Sub Main(ByVal args As String())
   
      Dim myXML As String = "<Departments>" & vbCr & vbLf & 
                           "<Department>Account</Department>" & vbCr & vbLf & 
                           "<Department>Sales</Department>" & vbCr & vbLf & 
                           "<Department>Pre-Sales</Department>" & vbCr & vbLf & 
                           "<Department>Marketing</Department>" & vbCr & vbLf & 
                           "</Departments>"

      Dim xdoc As New XDocument()
      xdoc = XDocument.Parse(myXML)

      Dim result = xdoc.Element("Departments").Descendants()

      For Each item As XElement In result
         Console.WriteLine("Department Name - " + item.Value)
      Next

      Console.WriteLine(vbLf & "Press any key to continue.")
      Console.ReadKey()
	  
   End Sub
   
End Module

Quando o código acima de C # ou VB é compilado e executado, ele produz o seguinte resultado -

Department Name - Account
Department Name - Sales
Department Name - Pre-Sales
Department Name - Marketing

Press any key to continue.

Adicionar Novo Nó

C #

using System;
using System.Collections.Generic;
using System.Linq;
using System.Xml.Linq;

namespace LINQtoXML {
   class ExampleOfXML {
      static void Main(string[] args) {
      
         string myXML = @"<Departments>
                       <Department>Account</Department>
                       <Department>Sales</Department>
                       <Department>Pre-Sales</Department>
                       <Department>Marketing</Department>
                       </Departments>";

         XDocument xdoc = new XDocument();
         xdoc = XDocument.Parse(myXML);

         //Add new Element
         xdoc.Element("Departments").Add(new XElement("Department", "Finance"));

         //Add new Element at First
         xdoc.Element("Departments").AddFirst(new XElement("Department", "Support"));

         var result = xdoc.Element("Departments").Descendants();

         foreach (XElement item in result) {
            Console.WriteLine("Department Name - " + item.Value);
         }

         Console.WriteLine("\nPress any key to continue.");
         Console.ReadKey();
      }
   }
}

VB

Imports System.Collections.Generic
Imports System.Linq
Imports System.Xml.Linq

Module Module1

   Sub Main(ByVal args As String())
   
      Dim myXML As String = "<Departments>" & vbCr & vbLf & 
     	                   "<Department>Account</Department>" & vbCr & vbLf & 
     	                   "<Department>Sales</Department>" & vbCr & vbLf & 
     	                   "<Department>Pre-Sales</Department>" & vbCr & vbLf & 
     	                   "<Department>Marketing</Department>" & vbCr & vbLf & 
     	                   "</Departments>"

      Dim xdoc As New XDocument()
      xdoc = XDocument.Parse(myXML)

      xdoc.Element("Departments").Add(New XElement("Department", "Finance"))
     
      xdoc.Element("Departments").AddFirst(New XElement("Department", "Support"))

      Dim result = xdoc.Element("Departments").Descendants()

      For Each item As XElement In result
         Console.WriteLine("Department Name - " + item.Value)
      Next

      Console.WriteLine(vbLf & "Press any key to continue.")
      Console.ReadKey()
	  
   End Sub
   
End Module

Quando o código acima de C # ou VB é compilado e executado, ele produz o seguinte resultado -

Department Name - Support
Department Name - Account
Department Name - Sales
Department Name - Pre-Sales
Department Name - Marketing
Department Name - Finance

Press any key to continue.

Excluindo Nó Particular

C #

using System;
using System.Collections.Generic;
using System.Linq;
using System.Xml.Linq;

namespace LINQtoXML {
   class ExampleOfXML {
      static void Main(string[] args) {
      
         string myXML = @"<Departments>
                       <Department>Support</Department>
                       <Department>Account</Department>
                       <Department>Sales</Department>
                       <Department>Pre-Sales</Department>
                       <Department>Marketing</Department>
                       <Department>Finance</Department>
                       </Departments>";

         XDocument xdoc = new XDocument();
         xdoc = XDocument.Parse(myXML);

         //Remove Sales Department
         xdoc.Descendants().Where(s =>s.Value == "Sales").Remove(); 

         var result = xdoc.Element("Departments").Descendants();

         foreach (XElement item in result) {
            Console.WriteLine("Department Name - " + item.Value);
         }

         Console.WriteLine("\nPress any key to continue.");
         Console.ReadKey();
      }
   }
}

VB

Imports System.Collections.Generic
Imports System.Linq
Imports System.Xml.Linq

Module Module1

   Sub Main(args As String())
   
      Dim myXML As String = "<Departments>" & vbCr & vbLf & 
     	                   "<Department>Support</Department>" & vbCr & vbLf & 
     	                   "<Department>Account</Department>" & vbCr & vbLf & 
     	                   "<Department>Sales</Department>" & vbCr & vbLf & 
     	                   "<Department>Pre-Sales</Department>" & vbCr & vbLf & 
     	                   "<Department>Marketing</Department>" & vbCr & vbLf & 
     	                   "<Department>Finance</Department>" & vbCr & vbLf & 
                           "</Departments>"

      Dim xdoc As New XDocument()
      xdoc = XDocument.Parse(myXML)
     
      xdoc.Descendants().Where(Function(s) s.Value = "Sales").Remove()

      Dim result = xdoc.Element("Departments").Descendants()

      For Each item As XElement In result
         Console.WriteLine("Department Name - " + item.Value)
      Next

      Console.WriteLine(vbLf & "Press any key to continue.")
      Console.ReadKey()
	  
   End Sub
   
End Module

Quando o código acima de C # ou VB é compilado e executado, ele produz o seguinte resultado -

Department Name - Support
Department Name - Account
Department Name - Pre-Sales
Department Name - Marketing
Department Name - Finance

Press any key to continue.

Como parte do ADO.NET Entity Framework, o LINQ to Entities é mais flexível do que o LINQ to SQL, mas não é muito popular devido à sua complexidade e falta de recursos principais. No entanto, ele não tem as limitações do LINQ to SQL que permite a consulta de dados apenas no banco de dados do servidor SQL, pois o LINQ to Entities facilita a consulta de dados em um grande número de provedores de dados como Oracle, MySQL, etc.

Além disso, conta com um grande suporte do ASP.Net no sentido de que os usuários podem utilizar um controle de fonte de dados para executar uma consulta via LINQ to Entities e facilita a vinculação dos resultados sem a necessidade de codificação extra.

O LINQ to Entities, por essas vantagens, tornou-se o mecanismo padrão para o uso do LINQ em bancos de dados hoje em dia. Também é possível com o LINQ to Entities alterar os detalhes dos dados consultados e fazer uma atualização em lote facilmente. O que é o fato mais intrigante sobre LINQ to Entities é que ele tem a mesma sintaxe do SQL e ainda tem o mesmo grupo de operadores de consulta padrão como Join, Select, OrderBy, etc.

LINQ to Entities Query Creation and Execution Process

• Construção de um ObjectQuery instância fora de um ObjectContext (Conexão de Entidade)

• Compondo uma consulta em C # ou Visual Basic (VB) usando a instância recém-construída

• Conversão de operadores de consulta padrão de LINQ, bem como expressões LINQ em árvores de comando

• Executar a consulta passando quaisquer exceções encontradas para o cliente diretamente

• Devolver ao cliente todos os resultados da consulta

ObjectContext é aqui a classe principal que permite a interação com Entity Data Modelou em outras palavras, atua como uma ponte que conecta o LINQ ao banco de dados. Árvores de comando são aqui representação de consulta com compatibilidade com a estrutura Entity.

A Entity Framework, por outro lado, é realmente Object Relational Mapperabreviado geralmente como ORM pelos desenvolvedores que faz a geração de objetos de negócios, bem como entidades de acordo com as tabelas do banco de dados e facilita várias operações básicas como criar, atualizar, excluir e ler. A ilustração a seguir mostra a estrutura da entidade e seus componentes.

Exemplo de ADD, UPDATE e DELETE usando LINQ com modelo de entidade

Primeiro adicione o modelo de entidade seguindo as etapas abaixo.

Step 1- Clique com o botão direito no projeto e clique em adicionar novo item para abrir a janela conforme abaixo. Selecione ADO.NET Entity Data Model, especifique o nome e clique em Add.

Step 2 - Selecione Generate from database.

Step 3 - Escolha Conexão de banco de dados no menu suspenso.

Step 4 - Selecione todas as tabelas.

Agora escreva o seguinte código.

using DataAccess;
using System;
using System.Linq;

namespace LINQTOSQLConsoleApp {
   public class LinqToEntityModel {
      static void Main(string[] args) {

         using (LinqToSQLDBEntities context = new LinqToSQLDBEntities()) {
            //Get the List of Departments from Database
            var departmentList = from d in context.Departments
            select d;

            foreach (var dept in departmentList) {
               Console.WriteLine("Department Id = {0} , Department Name = {1}",
                  dept.DepartmentId, dept.Name);
            }

            //Add new Department
            DataAccess.Department department = new DataAccess.Department();
            department.Name = "Support";

            context.Departments.Add(department);
            context.SaveChanges();

            Console.WriteLine("Department Name = Support is inserted in Database");

            //Update existing Department
            DataAccess.Department updateDepartment = context.Departments.FirstOrDefault(d ⇒d.DepartmentId == 1);
            updateDepartment.Name = "Account updated";
            context.SaveChanges();

            Console.WriteLine("Department Name = Account is updated in Database");

            //Delete existing Department
            DataAccess.Department deleteDepartment = context.Departments.FirstOrDefault(d ⇒d.DepartmentId == 3);
            context.Departments.Remove(deleteDepartment);
            context.SaveChanges();

            Console.WriteLine("Department Name = Pre-Sales is deleted in Database");

            //Get the Updated List of Departments from Database
            departmentList = from d in context.Departments
            select d;

            foreach (var dept in departmentList) {
               Console.WriteLine("Department Id = {0} , Department Name = {1}",
                  dept.DepartmentId, dept.Name);
            }
         }

         Console.WriteLine("\nPress any key to continue.");
         Console.ReadKey();
      }
   }
}

Quando o código acima é compilado e executado, ele produz o seguinte resultado -

O termo 'expressão lambda' deriva seu nome de cálculo 'lambda' que, por sua vez, é uma notação matemática aplicada para definir funções. Expressões lambda como a parte executável de uma equação LINQ traduzem a lógica de uma maneira em tempo de execução para que ela possa passar para a fonte de dados convenientemente. No entanto, as expressões lambda não se limitam apenas a localizar aplicativos no LINQ apenas.

Essas expressões são expressas pela seguinte sintaxe -

(Input parameters) ⇒ Expression or statement block

Aqui está um exemplo de uma expressão lambda -

y ⇒ y * y

A expressão acima especifica um parâmetro denominado y e o valor de y é elevado ao quadrado. No entanto, não é possível executar uma expressão lambda neste formato. Exemplo de uma expressão lambda em C # é mostrado abaixo.

C #

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace lambdaexample {
   class Program {

      delegate int del(int i);
      static void Main(string[] args) {

         del myDelegate = y ⇒ y * y;
         int j = myDelegate(5);
         Console.WriteLine(j);
         Console.ReadLine();
      }
   }
}

VB

Module Module1
   Private Delegate Function del(ByVal i As Integer) As Integer
   
   Sub Main(ByVal args As String())
   
      Dim myDelegate As del = Function(y) y * y
      Dim j As Integer = myDelegate(5)
      Console.WriteLine(j)
      Console.ReadLine()
	  
   End Sub
   
End Module

Quando o código acima de C # ou VB é compilado e executado, ele produz o seguinte resultado -

25

Expression Lambda

Como a expressão na sintaxe da expressão lambda mostrada acima está do lado direito, também são conhecidas como expressão lambda.

Lambdas assíncronos

A expressão lambda criada pela incorporação do processamento assíncrono pelo uso da palavra-chave async é conhecida como lambdas assíncronas. Abaixo está um exemplo de lambda assíncrono.

Func<Task<string>> getWordAsync = async()⇒ “hello”;

Lambda em operadores de consulta padrão

Uma expressão lambda dentro de um operador de consulta é avaliada pelo mesmo sob demanda e trabalha continuamente em cada um dos elementos na seqüência de entrada e não em toda a seqüência. Os desenvolvedores têm permissão para a expressão Lambda alimentar sua própria lógica nos operadores de consulta padrão. No exemplo a seguir, o desenvolvedor usou o operador 'Where' para recuperar os valores ímpares de uma determinada lista, usando uma expressão lambda.

C #

//Get the average of the odd Fibonacci numbers in the series... 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace lambdaexample {
   class Program {     
      static void Main(string[] args) {
      
         int[] fibNum = { 1, 1, 2, 3, 5, 8, 13, 21, 34 };
         double averageValue = fibNum.Where(num ⇒ num % 2 == 1).Average();
         Console.WriteLine(averageValue);
         Console.ReadLine();
      }
   }
}

VB

Module Module1

   Sub Main()
   
      Dim fibNum As Integer() = {1, 1, 2, 3, 5, 8, 13, 21, 34}
      Dim averageValue As Double = fibNum.Where(Function(num) num Mod 2 = 1).Average()
	  
      Console.WriteLine(averageValue)
      Console.ReadLine()
	  
   End Sub
   
End Module

Quando o código acima é compilado e executado, ele produz o seguinte resultado -

7.33333333333333

Digite Inferência em Lambda

Em C #, a inferência de tipo é usada convenientemente em uma variedade de situações e também sem especificar os tipos explicitamente. No entanto, no caso de uma expressão lambda, a inferência de tipo funcionará apenas quando cada tipo tiver sido especificado, pois o compilador deve ser satisfeito. Vamos considerar o seguinte exemplo.

delegate int Transformer (int i);

Aqui, o compilador emprega a inferência de tipo para se basear no fato de que x é um inteiro e isso é feito examinando o tipo de parâmetro do Transformer.

Escopo Variável na Expressão Lambda

Existem algumas regras ao usar o escopo de variável em uma expressão lambda, como variáveis ​​iniciadas em uma expressão lambda que não devem ser visíveis em um método externo. Também há uma regra de que uma variável capturada não deve ser coletada como lixo, a menos que o delegado que faz referência à mesma se torne elegível para o ato de coleta de lixo. Além disso, existe uma regra que proíbe uma instrução de retorno dentro de uma expressão lambda para causar o retorno de um método envolvente.

Aqui está um exemplo para demonstrar o escopo da variável na expressão lambda.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace lambdaexample {
   class Program {
      delegate bool D();
      delegate bool D2(int i);

      class Test {
         D del;
         D2 del2;
			
         public void TestMethod(int input) {
            int j = 0;
            // Initialize the delegates with lambda expressions.
            // Note access to 2 outer variables.
            // del will be invoked within this method.
            del = () ⇒ { j = 10; return j > input; };

            // del2 will be invoked after TestMethod goes out of scope.
            del2 = (x) ⇒ { return x == j; };

            // Demonstrate value of j:            
            // The delegate has not been invoked yet.
            Console.WriteLine("j = {0}", j);        // Invoke the delegate.
            bool boolResult = del();
           
            Console.WriteLine("j = {0}. b = {1}", j, boolResult);
         }

         static void Main() {
            Test test = new Test();
            test.TestMethod(5);

            // Prove that del2 still has a copy of
            // local variable j from TestMethod.
            bool result = test.del2(10);
           
            Console.WriteLine(result);

            Console.ReadKey();
         }
      }
   }
}

Quando o código acima é compilado e executado, ele produz o seguinte resultado -

j = 0
j = 10. b = True
True

Árvore de Expressão

Expressões lambda são usadas em Expression Treeconstrução extensivamente. Uma árvore de expressão fornece código em uma estrutura de dados semelhante a uma árvore na qual cada nó é uma expressão como uma chamada de método ou pode ser uma operação binária como x <y. Abaixo está um exemplo de uso da expressão lambda para construir uma árvore de expressão.

Declaração Lambda

Também há statement lambdasconsistindo em duas ou três declarações, mas não são usadas na construção de árvores de expressão. Uma instrução de retorno deve ser escrita em uma instrução lambda.

Sintaxe da declaração lambda

(params)⇒ {statements}

Exemplo de uma declaração lambda

using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Linq.Expressions;

namespace lambdaexample {
   class Program {
      static void Main(string[] args) {
         int[] source = new[] { 3, 8, 4, 6, 1, 7, 9, 2, 4, 8 };

         foreach (int i in source.Where(x ⇒ 
            {
               if (x <= 3)
                  return true;
               else if (x >= 7)
                  return true;
               return false;
            }
         ))
        Console.WriteLine(i);
        Console.ReadLine();
      }
   }
}

Quando o código acima é compilado e executado, ele produz o seguinte resultado -

3
8
1
7
9
2
8

Lambdas são empregados como argumentos em consultas LINQ com base em métodos e nunca podem ter um lugar no lado esquerdo de operadores como is ou asapenas como métodos anônimos. Embora as expressões Lambda sejam muito semelhantes aos métodos anônimos, eles não são restritos ao uso apenas como delegados.

Pontos a serem lembrados ao usar expressões lambda

• Uma expressão lambda pode retornar um valor e pode ter parâmetros.

• Os parâmetros podem ser definidos de várias maneiras com uma expressão lambda.

• Se houver uma única instrução em uma expressão lambda, não há necessidade de chaves, ao passo que, se houver várias instruções, as chaves, bem como o valor de retorno, são essenciais para escrever.

• Com expressões lambda, é possível acessar variáveis ​​presentes fora do bloco de expressão lambda por um recurso conhecido como encerramento. O uso de fechamento deve ser feito com cautela para evitar qualquer problema.

• É impossível executar qualquer código não seguro dentro de qualquer expressão lambda.

• As expressões lambda não devem ser usadas no lado esquerdo do operador.

Como um conjunto de extensões do .NET framework, LINQ é o mecanismo preferido para acesso a dados por desenvolvedores ASP.NET. O ASP.NET 3.5 tem uma ferramenta interna de controle LINQDataSource que permite o uso de LINQ facilmente no ASP.NET. ASP.NET usa o controle mencionado acima como uma fonte de dados. Projetos da vida real geralmente englobam sites ou aplicativos do Windows e, portanto, para entender melhor o conceito de LINQ com ASP.NET, vamos começar criando um site ASP.NET que faz uso dos recursos do LINQ.

Para isso, é imprescindível ter instalado o Visual Studio e o .NET Framework em seu sistema. Depois de abrir o Visual Studio, vá para Arquivo → Novo → Site. Uma janela pop-up será aberta conforme mostrado na figura abaixo.

Agora, sob os modelos do lado esquerdo, haverá duas opções de idioma para criar o site. EscolherVisual C# e selecione ASP.NET Empty Web Site.

Selecione a pasta onde deseja salvar o novo site em seu sistema. Então aperteOK e assim por diante Solution Exploreraparece na tela contendo todos os arquivos da web. Clique com o botão direito do mouse em Default.aspx no Solution Explorer e escolha View in Browser para visualizar o site ASP.NET padrão no navegador. Em breve, seu novo site ASP.NET será aberto no navegador da web, conforme mostrado na captura de tela a seguir.

.aspx é de fato a principal extensão de arquivo usada em sites ASP.NET. O Visual Studio por padrão cria todas as páginas necessárias para um site básico comoHome page e About Uspágina onde você pode colocar seu conteúdo convenientemente. O código do site é gerado automaticamente aqui e também pode ser visualizado.

LINQDataSource Control

É possível UPDATE, INSERT e DELETEdados nas páginas do site ASP.NET com a ajuda do controle LINQDataSource. Não há absolutamente nenhuma necessidade de especificação de comandos SQL, pois o controle LINQDataSource emprega comandos criados dinamicamente para tais operações.

O controle permite que um usuário faça uso do LINQ em uma página da Web ASP.NET convenientemente pela configuração da propriedade no texto de marcação. LINQDataSource é muito semelhante ao de controles comoSqlDataSource assim como ObjectDataSourcepois pode ser usado para vincular outros controles ASP.NET presentes em uma página a uma fonte de dados. Então, devemos ter umdatabase para explicar as várias funções invocadas pelo controle LINQDataSource.

Antes de iniciar a explicação do uso do controle no formulário de página da web ASP.NET, é essencial abrir a caixa de ferramentas do Microsoft Visual Studio e arrastar e soltar o controle LINQDataSource na página .aspx do site ASP.NET como a figura abaixo.

A próxima etapa é configurar LINQDataSource selecionando todas as colunas para o registro do funcionário.

Agora adicione um controle GridView à página .aspx e configure-o como mostrado na figura abaixo. O controle GridView é poderoso e oferece flexibilidade para trabalhar com os dados. Logo após configurar o controle, ele aparecerá no navegador.

A codificação que pode ser visualizada agora em sua tela para a página .aspx será -

<!DOCTYPE html>

<html>
   <head runat = "server">
      <title></title>
   </head>

   <body>
      <form id = "form1" runat = "server">
         <div>
            <asp:GridView ID = "GridView1" runat = "server" AutoGenerateColumns = "False"
			
               DataKeyNames = "ContactID" DataSourceID = "LINQDataSource1">
               <Columns>
			   
                  <asp:BoundField DataField = "ContactID" HeaderText = "ContactID"
                     InsertVisible = "False" ReadOnly="True" SortExpression = "ContactID" />
                  <asp:CheckBoxField DataField = "NameStyle" HeaderText = "NameStyle"
                     SortExpression = "NameStyle" />
                  <asp:BoundField DataField = "Title" HeaderText = "Title" SortExpression = "Title" />
                  <asp:BoundField DataField = "FirstName" HeaderText = "FirstName"
                     SortExpression="FirstName" />
                  <asp:BoundField DataField = "MiddleName" HeaderText = "MiddleName"
                     SortExpression = "MiddleName" />
                  <asp:BoundField DataField = "LastName" HeaderText = "LastName"
                     SortExpression = "LastName" />
                  <asp:BoundField DataField = "Suffix" HeaderText = "Suffix"
                     SortExpression = "Suffix" />
                  <asp:BoundField DataField = "EmailAddress" HeaderText = "EmailAddress"
                     SortExpression = "EmailAddress" />
               </Columns>

            </asp:GridView>

            <br />

         </div>

         <asp:LINQDataSource ID = "LINQDataSource1" runat = "server"

            ContextTypeName = "LINQWebApp1.AdventureWorksDataContext" EntityTypeName = ""
               TableName = "Contacts">

         </asp:LINQDataSource>
      </form>
   </body>
</html>

Aqui, deve-se observar que é vital definir a propriedade ContextTypeName para aquela da classe que representa o banco de dados. Por exemplo, aqui é fornecido como LINQWebApp1.AdventureWorksDataContext, pois essa ação fará a conexão necessária entre LINQDataSource e o banco de dados.

INSERT, UPDATE e DELETE dados na página ASP.NET usando LINQ

Depois de concluir todas as etapas acima com rigor, escolha o LINQDataSource Tasks de LINQDataSource Control e escolha todas as três caixas para habilitar a inserção, habilitar a atualização e habilitar a exclusão das mesmas, conforme mostrado na imagem a seguir.

Em breve, a marcação declarativa será exibida em sua tela como a seguinte.

<asp:LINQDataSource 
   ContextTypeName = "LINQWebApp1.AdventureWorksDataContext" 
   TableName = "Contacts" 
   EnableUpdate = "true" 
   EnableInsert = "true" 
   EnableDelete = "true" 
   ID = "LINQDataSource1" 
   runat = "server">
</asp:LINQDataSource>

Agora, como existem várias linhas e colunas, é melhor adicionar outro controle em seu formulário .aspx denominado como Visualização de detalhes ou controle Mestre abaixo do controle Visualização de grade para exibir apenas os detalhes de uma linha selecionada da grade. Escolha as Tarefas de Visualização de Detalhes no controle de Visualização de Detalhes e marque as caixas de seleção conforme mostrado abaixo.

Agora, basta salvar as alterações e pressionar Ctrl + F5 para visualizar a página em seu navegador onde agora é possível excluir, atualizar, inserir qualquer registro no controle de visualização de detalhes.