Resumen De Sentencia LinQ

Leguaje de Consulta Integrado (Language Integrated Query, LINQ).

LINQ es el primer intento de Microsoft para integrar consultas en el lenguaje. LINQ ofrece una manera fácil de escribir consultas que se pueden ejecutar como la de los objetos en memoria.

Tipos de LINQ.

Linq Viene con 3 tipos básicos:

1. LINQ (LINQ to Objects)

2. DLINQ (LINQ to SQL)

3. XLinq (LINQ to XML)

Expresiones Lambda.

LINQ siempre se asocia con las expresiones lambda. En. NET 2.0 tenemos el concepto de métodos Annonymous que le permite escribir en una línea la función del cuerpo sin necesidad de escribir una función de delegado. La expresión Lambda de .NET Framework 3.5 conserva el concepto de escritura de la función Annonymous. Vamos a echar un vistazo de cómo escribir métodos Annonymous en C # 2.0.

int i = this.compute(10);

private int compute(int value)

{

return (value + 2);

}

Podemos reemplazar el código anterior con la función annonymous de una línea de esta manera:

//C#

delegate int TipoEli(int i);

TipoEli dd = delegate(int value) { return (value + 2); };

int i = dd(10,5);

Podemos tomar el uso de operador => que se introduce en. NET 3.5. Da forma más flexible y más fácil de escribir la expresión.

delegate int DelType(int i);

DelType d = value => value + 2;

int i = d(10);

Del mismo modo, si queremos podemos poner tantos argumentos como queramos.

// Method with 2 arguments

delegate int DelType(int i, int j);

DelType d = (value1,value2) => value1 + value2;

int i = d(10, 20); // Returns 30

Expresión lambda cuando el cuerpo de la función tiene más de una expresión.

// Cuerpo de la function multilinea.

delegate int DelType(int i, int j);

DelType d = (value1, value2) => {

value1 = value1 + 2;

value2 = value2 + 2;

return value1 + value2;

};

También podemos crear nosotros mismos tipos de expresión dinámicas, si nos gusta usar la clase System.Linq.Expressions.

Expression<Func<int, int>> exprTree = num => num * 5;

// Descomposicion de la expresion en Arbol.

ParameterExpression param = (ParameterExpression)exprTree.Parameters[0];

BinaryExpression operation = (BinaryExpression)exprTree.Body;

ParameterExpression left = (ParameterExpression)operation.Left;

ConstantExpression right = (ConstantExpression)operation.Right;

NOTA: VB.NET no es compatible con los métodos Annonymous y expresiones lambda con declaración en el cuerpo.

Tipo Annonymous

Los tipos Annonymous introducidos con .NET pueden crear un objeto sin ni siquiera declarar las clases. Los miembros de los tipos Annonymous implícitamente se define durante la compilación

var x = new {Nombre = "AA", Edad = 30, dob = DateTime.Now};

Esto crearía un nuevo objeto de tipo annonymous.

Significado de var.

Var es una nueva palabra clave en el añadida .NET 3.5. Esto se conoce como variable de tipo implícito.

var x = 10; // implica que la variable es de tipo entero

var x =new List<Employee>(); // Significa que x tiene una lista de los empleados

La unica restricción es que no podemos definir miembros de tipo var.

Ejemplos de LINQ.

Vamos ahora a demostrar LINQ con un ejemplo sencillo

C#

List<Employee> employees = new List<Employee>();

List<Employee> employee1 = new List<Employee>();

List<Order> orders = new List<Order>();

//Cuando empleado y Orden son Clases.

public class Employee

{

public string name;

public int age;

public override string ToString()

{

return this.name;

}

}

public class Order

{

public string itemName;

public string empName;

public override string ToString()

{

return this.itemName;

}

Operadores

Operadores más generales:

1. Operadores de proyección (Select)

2. Operadores de restricción (Where )

3. Operadores de particiones (Take / Skip, TakeWhile / SkipWhile)

4. Operadores de Únion (Join)

5. Operadores de concatenacion (Concat)

6. Operadores de Orden (Order by)

7. Operadores de agrupación (Group By Into)

Operadores de proyección (Select)

var iNames = from i in employees

select i.name;

//Using Lambda Expression

var iNames = employees.Select<Employee, string>(r => r.name);

Operadores de restricción (Where )

var filterEnumerable = from emp in employees

where emp.age > 50

select emp;

Operadores de particiones (Take / Skip, TakeWhile / SkipWhile)

Tome se puede utilizar cuando se toman los primeros N elementos de una lista, se llevará a saltar los elementos después de la N.

C #

var filterEnumerable = (from emp in employees

select emp).Take<Employee>(2);

//Using Lambda Expression

var filterEnumerable = employees.Select<Employee, string>(r => r.name);

Operador TakeWhile y SkipWhile:

Este operador se seleccionará de una lista sobre la base de un delegado pasado

C #

var filterEnumerable = (from emp in employees

select emp).SkipWhile<Employee>(

r => r.name.Length > 4);

//Using Lambda Expression

var filterEnumerable = employees.Select<Employee, Employee>(

r => {

return r;

}).SkipWhile<Employee>(r => r.name.Length > 4);

Operadores de Union:

Úne a los operadores que

...