LINQ
Language Integrated Query (LINQ) é um conjunto de extensões à plataforma .Net que facilita a manipulação de conjuntos de objectos, permitindo também manipular os conjuntos com uma sintaxe muito semelhante à utilizada no SQL.
exemplo 1:
String[] ss = new String[] {"20", "100", "313", "2222", "111"};
IEnumerable<int> numbers = ss
.Where(x => x.Contains("1"))
.Select(x => Int32.Parse(x));
exemplo 2:
String[] ss = new String[] {"20", "100", "313", "2222", "111" };
IEnumerable<int> numbers =
from s in ss
where s.Contains("1")
select Int32.Parse(s);
O exemplo 1 mostra como utilizar LINQ para obter todas as Strings presentes no array ss que contenham o carácter ‘1’ e como as transformar em inteiros. Neste exemplo a variável numbers irá conter os inteiros 100, 313 e 111. O exemplo 2 demonstra como obter o mesmo resultado que o exemplo 1 mas utilizando a sintaxe de query do LINQ.
Algumas das principais características da Framework .Net que possibilitam a existência do LINQ são:
- Extension methods
- Object and Collection Initializers
- Type Inference (var)
- Anonymous Types
- Lambda Methods
- Keyword yield
Extension methods
Um extension method (ou método de extensão) é um método estático que pode ser chamado como se fosse um método de instância de uma outra classe. Basicamente os extension methods foram criados para possibilitar adicionar métodos de instância a classes às quais não se tem acesso ao seu código fonte e não é possível derivar delas.
exemplo 3:
public static class ExtencoesString {
public static String Prefixar(this string s, string prefixo) {
return prefixo + s;
}
}
No exemplo 3 é criado o extension method Prefixar que irá estender a classe String, ou seja passa a ser possível chamar o método Prefixar sobre instâncias de String. O primeiro parâmetro de um extension method contém a palavra-chave this, indicando assim a classe que está a ser estendida (neste caso a classe String). Esse parâmetro representa a instância da classe sobre a qual o método foi chamado. Os extension methods têm de ser estáticos e só podem ser definidos em classes estáticas. O extension method Prefixar limita-se a prefixar à String sobre o qual é chamado (parâmetro s) com a String passada no parâmetro prefixo.
exemplo 4:
String t = "tarde";
System.Console.WriteLine(t.Prefixar("Boa "));
O exemplo 4 demonstra a utilização do extension method Prefixar. O exemplo escreve na consola o texto “Boa tarde”.
Os extension methods não passam de um facilitismo sintáctico do compilador. Quando o código for compilado as chamadas aos extension methods serão transformadas nas chamadas aos respectivos métodos estáticos. Devido a este comportamento, é também possível declarar extension methods sobre interfaces.
Grande parte dos métodos do LINQ são extension methods que estendem a interface IEnumerable.
Object and Collection Initializers
Object initializer é uma sintaxe que permite afectar campos e propriedades publicas de objectos a quando a sua construção. A ideia da sintaxe de object initializer é a de chamar o construtor do objecto e afectar as propriedades desse objecto na mesma expressão.
exemplo 5:
public class Ponto {
public int X { get; set;}
public int Y { get; set;}
}
Ponto ponto = new Ponto();
ponto.X = 5;
ponto.Y = 10;
exemplo 6:
Ponto ponto = new Ponto { X = 5, Y = 10};
O exemplo 5 mostra a criação de uma instância da classe Ponto, e a afectação das suas duas propriedades. Nesse exemplo para criar a instância e afectar as suas propriedades foram necessárias 3 instruções. A sintaxe de object initializer, demonstrada no exemplo 6, permite que a chamada ao construtor e a afectação das propriedades da instância sejam feitas na mesma expressão. O código do exemplo 6 obtêm o mesmo resultado que o do exemplo 5.
Collection initializer trás a ideia do object initializer para as Collections. Basicamente permite criar Collections e inserir objectos nas Collections numa só expressão (algo semelhante à sintaxe de criação e inicialização de arrays).
exemplo 7:
int[] n = new int[] {1,2,3,4,5};
List strings = new List {"a", "b", "c", "d"};
O exemplo 7 demonstra o uso da sintaxe de collection initializer (bem como a sintaxe de inicialização de arrays).
Os object e collection initializers trazem alguma simplificação na sintaxe de declaração de lambda methods, o que por sua vez simplifica a sintaxe das operações LINQ onde sejam utilizados lambda methods.
Type Inference (var)
O type inference permite criar variáveis sem declarar o seu tipo.
exemplo 8:
var x = new float[2];
//x = "dois"; // erro de compilação
O exemplo 8 demonstra o uso de type inference. É criada uma variável x sem indicar qual o seu tipo. Para tal coloca-se a palavra-chave var no lugar onde normalmente se colocaria o nome do tipo da variável. Quando o código é compilado, o compilador infere o tipo da variável através do valor com que a variável é afectada, no caso deste exemplo a variável x é do tipo array de float porque é afectada por um array de float.
È de notar que type inference não torna o tipo da variável dinâmico. O compilador obriga a que na declaração de uma variável que utilize a palavra-chave var, essa variável seja afectada. È essa afectação que o compilador utiliza para inferir o tipo da variável. Ao tentar-se afectar a variável com uma expressão que devolve uma instância de um tipo não compatível com o tipo devolvido na primeira afectação da variável, será gerado um erro de compilação. Por exemplo se o comentário da segunda linha do exemplo 8 for retirado, o código passa a gerar um erro de compilação. Isto porque o tipo inferido da variável x é array de float e está-se a tentar afectar a variável com uma String.
Esta sintaxe é utilizada normalmente com o uso de tipos anónimos, pois não se sabe o nome do tipo e por isso é necessário utilizar type inference para criar variáveis desse tipo.
Anonymous Types
Anonymous types permite a criação de tipos anónimos.
exemplo 9:
var morada = new {
Morada = "Av Liberdade",
Localidade = "Lisboa",
CodigoPostal = 1234,
Pais = "Portugal"
};
O exemplo 9 demonstra a criação de um tipo anónimo que representa uma morada. Como não se sabe o nome do tipo, é necessário utilizar type inference para declarar uma variável desse tipo. Um anonymous type não é um tipo dinâmico. Por cada anonymous type com propriedades com nomes e tipos diferentes, o compilador cria um tipo com as propriedades especificadas e com um nome gerado automaticamente.
exemplo 10:
public class Produto {
public String Nome { get; set; }
public int Categoria { get; set; }
public String Referencia { get; set; }
public float Preco { get; set; }
}
Produto[] produtos = new Produto[] {
new Produto() { Nome = "Produto 1", Categoria = 12, Referencia="A3W", Preco = 10 },
new Produto() { Nome = "Produto 2", Categoria = 23, Referencia="E$R", Preco = 20 },
};
var infoNomePreco = produtos.Select(x => new { Nome = x.Nome, Preco = x.Preco });
Os anonymous types são muito utilizados em LINQ, especialmente nos métodos Select onde se quer apenas obter alguns campos de uma estrutura de dados. Invés de estar a criar outra estrutura de dados, que apenas contém esses campos e que apenas será utilizada naquela situação, devolve-se um anonymous type com os campos pretendidos. O exemplo 10 demonstra esse comportamento. Existe um conjunto de Produtos mas apenas se quer saber o nome e preço desses produtos, para isso utiliza-se o método Select para transformar as instâncias de Produtos em instâncias de um tipo anonimo que apenas contém informação sobre o nome e preço dos produtos.
Lambda Methods
Lambda methods é uma sintaxe simplificada para declarar métodos anónimos. Esta sintaxe é muito semelhante à sintaxe lambda utilizada nas linguagens de programação funcional.
exemplo 11:
Func<int, bool> metodo1 = x => x == 0;
Func<int, int, int> metodo2 = (x, y) => x + y;
O exemplo 11 demonstra a declaração de dois métodos anónimos usando a sintaxe Lambda. A sintaxe Lambda está dividida em 2 partes:
(nome das variáveis) => expressão que o método devolve
Como se pode constatar, não se indica o tipo das variáveis, apenas o seu nome. O tipo das variáveis é inferido pelo tipo de delegate ao qual o Lambda method é afectado. O metodo1, do exemplo 11, como é afectado a um delegate que recebe um inteiro e devolve um booleano a variável x tem de ser do tipo inteiro e expressão de retorno do tipo booleano. O metodo1 indica se o parâmetro x é igual a zero.
O metodo2 recebe dois inteiros como parâmetros (x e y) e devolve um inteiro (que será soma dos seus parâmetros).
Caso o Lambda method só tenha um parâmetro, este não necessita de estar dentro de parênteses. Caso o número de parâmetros seja superior a 1, os parâmetros precisam de estar dentro de parênteses.
Em LINQ os Lambda methods são muito utilizados para declarar os delegates que os vários métodos do LINQ utilizam, isto porque os Lambda methods tornam a sintaxe de declaração de métodos anónimos muito mais simples.
Keyword yield
A palavra-chave yield é utilizada para facilitar a construção de iteradores.
exemplo 12:
public static IEnumerable Letras() {
yield return "a";
yield return "b";
yield return "c";
yield return "d";
for (int i = 1; i < 3; i++) {
yield return i.ToString();
}
yield break;
}
String[] letras = Letras().ToArray();
O método Letras do exemplo 12 devolve um conjunto de Strings, mais especificamente uma enumeração de Strings, na qual as Strings são acedidas atraves de um iterador. O método Letras faz uso da palavra-chave yield para construir a enumeração de Strings.
A palavra-chave yield indica ao compilador que aquele método é um bloco de iteração. O compilador gera um iterador que implemente o comportamento especificado pelo bloco de iteração. A instrução yield return indica um dos valores da enumeração, ou seja o resultado de uma iteração pela enumeração. A instrução yield break indica que o iterador chegou ao fim da enumeração, ou seja, que não existem mais elementos na enumeração.
Os valores da enumeração mantêm a ordem pela qual as instruções yield são executadas, isto é, como a instrução yield return "a"; é executada antes da yield return "b"; isto significa que elemento “a” aparecerá primeiro que o elemento “b” na enumeração devolvida pelo método Letras. No exemplo a variável letras irá conter os seguintes valores: a, b, c, d, 1 e 2.
A palavra-chave yield é utilizada por grande parte dos extension method do LINQ, pois facilita a implementação de iteradores. O exemplo 13 demonstra a implementação do método MyWhere que implementa o mesmo comportamento que o método Where do LINQ.
exemplo 13:
public static class Extensoes {
public static IEnumerable<T> MyWhere<T>(this IEnumerable<T> conjunto, Func<T, bool> predicado) {
foreach (T item in conjunto) {
if(predicado.Invoke(item)) {
yield return item;
}
}
yield break;
}
}
int[] s = new [] { 1, 24, 13, 38, 9, 3 };
int[] numerosImpares = s.MyWhere(x => (x % 2) != 0).ToArray();
A variável numerosImpares irá conter o seguinte conjunto de números: 1,13, 9 e 3.
