Share
Como desarrolladores de software, dedicamos mucho tiempo a extraer y mostrar datos de diferentes fuentes de datos. Ya sea un servicio web XML de algún tipo o una base de datos relacional con todas las funciones, nos hemos visto obligados a aprender diferentes métodos de acceso a datos. ¿No sería fantástico si el método de acceso fuera el mismo para todas las fuentes de datos? Bueno, estamos de suerte porque, a partir del lanzamiento de C # 3.0 y .NET 3.5 Framework, LINQ ha venido a cambiar el juego para siempre..
En la plataforma .NET hemos estado y todavía estamos utilizando ADO.NET
Para acceder a diferentes fuentes de datos. La comunidad de código abierto también ha proporcionado
Los desarrolladores con una serie de alternativas..
Language Integrated Query es la nueva adición a .NET
familia y como su nombre indica es el tipo de acceso a datos de estilo de consulta que
es totalmente compatible con el idioma para unificar de manera efectiva la forma en que accedemos a los datos
Y para hacer nuestras vidas más fáciles. LINQ puede apuntar a una serie de fuentes diferentes, a saber, Oracle,
MSSQL, XML y algunos otros, pero por ahora nos centraremos en lo más básico de
todos, LINQ to Objects.
Normalmente, para procesar y refinar los datos dentro de nuestras listas
y varias otras estructuras de datos, hemos utilizado el bucle 'foreach' u otro
tipo de método de bucle para iterar a través de los objetos y procesarlos uno por
Uno de acuerdo a alguna condición. Esto está bien, pero, francamente, requiere una gran cantidad de
Codificación básica que todos deseamos no tener que escribir. Esencialmente hemos tenido que decirle al
compilar cada detalle del proceso para manipular los datos.
Aquí es exactamente donde LINQ brilla mejor. Lo que LINQ nos permite
Lo que hay que hacer es simplemente decirle al compilador lo que nos gustaría realizar y dejar que el compilador funcione
La mejor manera de lograrlo. Si ha usado la sintaxis SQL anteriormente, las semejanzas masivas
Entre LINQ y cualquier dialecto de SQL será lo primero que notará..
Al igual que SQL, LINQ también soporta "seleccionar", "desde", "donde", "unirse", "agrupar por"
y "ordenar por" palabras clave. Aquí hay un ejemplo simple de consultar una lista de objetos:
Inicialización de la lista:
ListaListOfCars = nueva lista () new Car name = "Toyota", owner = "Alex", model = 1992, new Car name = "Mitsubishi", owner = "Jeff", model = 2005, new Car name = "Land Rover ", owner =" Danny ", model = 2001, New Car name =" BMW ", owner =" Danny ", model = 2006, new Car name =" Subaru ", owner =" Smith ", model = 2003;
La consulta:
EnumerableQueryResult = from car en ListOfCars select car;
La primera parte del código anterior simplemente rellena una lista
Con cuatro instancias de la clase 'Car'. La siguiente parte del código, sin embargo, utiliza la
"from" y "select" keywords para seleccionar un grupo de objetos. La principal diferencia
entre SQL y LINQ es que la palabra clave "de" aparece antes de "seleccionar"
palabra clave porque primero debemos definir el objeto que queremos operar. Finalmente
La cláusula "seleccionar" le dice al compilador lo que deseamos extraer en esta consulta. Lo anterior
el código simplemente extrae todo lo que está en la lista y lo asigna al "QueryResult"
variable.
Cuando consultamos cosas desde objetos (LINQ to Objects), nuestra
Las consultas siempre devuelven un "IEnumrable
El tipo "IEnumerable" es el tipo de lista que expone el enumerador, que
admite una iteración simple sobre una colección no genérica, y
es el tipo de cada entrada en la lista.
No se preocupe si no está familiarizado con los "enumeradores" y los "genéricos". Sólo
recuerde que el resultado de las consultas LINQ es siempre una colección como datos
estructura que permite iterar a través de ella utilizando un bucle como se muestra
bramido:
foreach (Car car in QueryResult) Console.WriteLine (car.name);
Aprendimos que LINQ siempre devuelve una estructura de colección similar.
a cualquier otra lista. Sin embargo, la consulta LINQ no se ejecuta hasta que su resultado es
accedido por alguna otra pieza de código, como el bucle "foreach" arriba. Esto es para
Permítanos definir continuamente la consulta sin la sobrecarga reevaluando
cada nuevo paso en la consulta.
Hasta ahora tan bueno; Pero la mayoría de las veces, nuestras consultas necesitarán.
ser más complejo; Así que vamos a tratar de proyectar datos. En SQL, Proyección significa seleccionar
el nombre de la (s) columna (s) de la (s) tabla (s) que uno desea ver aparecer en el resultado
de la consulta. En el caso de LINQ to Objects, se realizará una Proyección.
en un tipo de resultado de consulta diferente al tipo de objeto que realizamos
consulta en.
Hay dos tipos de proyecciones que podemos hacer. Podemos
realice una proyección basada en un tipo de objeto existente o vaya por completo
la otra forma mediante el uso de tipos anónimos. El siguiente ejemplo es de los primeros.
tipo:
EnumerableQueryResult = from car en ListOfCars selecciona nuevo CarOwner owner_name = car.owner;
En el código anterior, el tipo de resultado de la consulta se declara como
También usé la palabra clave "nueva" y he hecho algunas tareas dentro de la curva
soportes. En el código anterior, el uso de "seleccionar" con la palabra clave "nuevo" le indica a
compilador para crear una instancia de un nuevo objeto 'CarOwner' para cada entrada en el resultado de la consulta.
También asignando valores al nuevo tipo hemos inicializado cada instancia
de la clase 'CarOwner'.
No obstante, si aún no tiene un tipo definido para
utilizar, todavía puede realizar proyecciones utilizando tipos anónimos.
Sería una gran molestia si, para cada Proyección, fueras
Obligado a crear un nuevo tipo. Por eso, a partir de C # 3.0, soporte para Anonymous
Los tipos fueron agregados al lenguaje. Un tipo anónimo se declara usando la "var"
palabra clave. Le dice al compilador que el tipo de la variable es desconocido hasta que
es asignado por primera vez.
var QueryResult = from car en ListOfCars selecciona new car_name = car.name, owner_name = car.owner; foreach (var entry en QueryResult) Console.WriteLine (entry.car_name);
Lo anterior es un ejemplo de realizar una consulta con Anonymous.
tipos El único problema a tener en cuenta es que el compilador no
Permite devolver tipos anónimos de métodos..
Acceder a las propiedades de un tipo anónimo es fácil. En Visual Studio 2008, el Código
Completion / Intellisense también enumera las propiedades expuestas por el tipo Anónimo.
Por lo general, como parte de la consulta LINQ, también necesitamos refinar el
consultar el resultado especificando una condición. Al igual que SQL, LINQ también usa el "dónde"
Cláusula para decirle al compilador qué condiciones son aceptables..
EnumerableQueryResult = from car en ListOfCars donde car.name == "Subaru" selecciona car;
El código anterior demuestra el uso de la cláusula "where" y
La condición a seguir. Para seguir definiendo múltiples condiciones, LINQ soporta
las construcciones 'and' (&& amp) y 'or' (||). La parte "donde" de la consulta debe ser siempre una
Expresión booleana, de lo contrario el compilador se quejará..
Al consultar objetos, es posible confiar en la consulta.
El objetivo ya está ordenado. Si ese no es el caso, LINQ puede hacerse cargo de eso
mediante el uso de la cláusula "ordenar por" que asegurará que el resultado de su consulta sea
debidamente ordenado.
EnumerableQueryResult = from car en ListOfCars orderby car.model select car;
Si ejecuta el código anterior, verá que el resultado de la
La consulta está ordenada en orden ascendente. Puede alterar el orden usando "ascendente" y "descendente"
palabras clave, y además cambie el orden especificando más de un campo para ordenar
por. El siguiente código muestra cómo:
EnumerableQueryResult = from car in ListOfCars orderby car.model descendente selecciona car;
LINQ también permite agrupar el resultado de la consulta por el valor de un
propiedad específica como se muestra en este ejemplo:
var QueryResult = from car en ListOfCars group car por car.owner en carOwnersGroup select carOwnersGroup.Key;
Como puede ver, LINQ admite la cláusula "agrupar por" para
Especifique qué objeto y por qué propiedad agrupar por. La palabra clave "en" será
luego nos permite proyectar sobre un resultado de agrupación al que se puede acceder mediante la "Clave"
propiedad.
LINQ admite la unión de datos de diferentes colecciones en una sola.
resultado de la consulta. Puede hacer esto usando la palabra clave "join" para especificar qué objetos
para unirse y usar la palabra clave "on" para especificar la relación coincidente entre
los dos objetos.
Inicializando lista relacionada:
ListaListOfCars = nueva lista () new Car name = "Mitsubishi", owner = "Jeff", model = 2005, new Car name = "Land Rover", owner = "Danny", model = 2001, new Car name = " Subaru ", owner =" Smith ", model = 2003, Carro nuevo name =" Toyota ", owner =" Alex ", model = 1992, Carro nuevo name =" BMW ", owner =" Danny ", model = 2006,; Lista ListOfCarOwners = new List () nuevo CarOwner owner_name = "Danny", age = 22, nuevo CarOwner owner_name = "Jeff", age = 35, nuevo CarOwner owner_name = "Smith", age = 19, nuevo CarOwner owner_name = "Alex", edad = 40;
Consulta:
var QueryResult = from car en ListOfCars unir a carowner en ListOfCarOwners en car.owner es igual a carowner.owner_name seleccionar nuevo name = car.name, owner = car.owner, owner_age = carowner.age;
En el código anterior, utilizando un tipo anónimo, nos hemos unido
los dos objetos en un solo resultado de consulta.
Hasta ahora, hemos aprendido cómo podemos usar LINQ para construir un plano
lista de resultados de la consulta. Con LINQ, también es posible lograr una consulta jerárquica
resultado utilizando "GroupJoin". En palabras simples, podríamos asignar objetos a
Propiedades de cada entrada con consulta LINQ..
ListaListOfCars = nueva lista () new Car name = "Mitsubishi", owner = "Jeff", model = 2005, new Car name = "Land Rover", owner = "Danny", model = 2001, new Car name = " Subaru ", owner =" Smith ", model = 2003, Carro nuevo name =" Toyota ", owner =" Alex ", model = 1992, Carro nuevo name =" BMW ", owner =" Danny ", model = 2006,; Lista ListOfCarOwners = new List () nuevo CarOwner owner_name = "Danny", age = 22, nuevo CarOwner owner_name = "Jeff", age = 35, nuevo CarOwner owner_name = "Smith", age = 19, nuevo CarOwner owner_name = "Alex", edad = 40; var QueryResult = del propietario de carros en ListOfCarOwners se une a car en ListOfCars en carowner.owner_name es igual a car.owner en carsGroup selecciona new name = carowner.owner_name, cars = carsGroup; foreach (var carOwner en QueryResult) foreach (var car en carOwner.cars) Console.WriteLine ("Nombre del propietario: 0, nombre del auto: 1, modelo del auto: 2", carOwner.name, car.name , Modelo de auto);
En el ejemplo anterior, la cláusula "Unirse" va seguida de "into"
parte. Esto difiere de la operación de unión anterior que vimos. Aquí, el "en"
La cláusula se utiliza para agrupar los automóviles por el propietario (en carsGroup) y asignar la agrupación a la
"coches" propiedad del tipo anónimo.
Hasta ahora, todo lo que hemos visto ha sido respaldado por el C # 3.0
sintaxis. Sin embargo, todavía hay una gran cantidad de operaciones que C # 3.0 no realiza
apoyo. Los operadores de consulta estándar proporcionan capacidades de consulta que incluyen
Filtrado, proyección, agregación, clasificación y más. Por lo tanto, estas operaciones son compatibles
como métodos de la biblioteca LINQ y se pueden ejecutar en el resultado de una consulta como se muestra en la
siguiente captura de pantalla:
Estos operadores se enumeran a continuación para su referencia.
LINQ ha demostrado ser muy útil para consultar objetos, y la sintaxis similar a SQL hace que sea fácil
aprender y usar. Además, la gran cantidad de operadores estándar permite encadenar a varios operadores
Para realizar consultas complejas. En un seguimiento de este tutorial, revisaremos cómo se puede usar LINQ para
Consulta bases de datos y contenido XML ...
Accentsconagua