Métodos de extensión de las consultas (segunda parte)
Distinct: Elimina los valores duplicados en el origen.
--------------------------------------VB------------------------------------------
Dim scores = New Integer() {88, 23, 99, 65, 23, 99, 90}
For Each score In scores.Distinct()
txtLog.WriteLine(score)
Next
--------------------------------------CS------------------------------------------
int[] scores = { 88, 23, 99, 65, 23, 99, 90 };
foreach (var score in scores.Distinct())
{
txtLog.WriteLine(score);
}
El resultado seria:
88
23
99
65
90
ElementAt: Se utiliza cuando se sabe el orden del elemento n en el origen. Si hay un elemento válido en ese lugar (basado en 0), se devuelve sino se lanza una excepción ArgumentOutOfRangeException.
--------------------------------------VB------------------------------------------
Dim scores = New Integer() {88, 56, 23, 99, 65, 93, 78, 23, 99, 90}
txtLog.WriteLine(scores.ElementAt(4))
--------------------------------------CS------------------------------------------
int[] scores = { 88, 56, 23, 99, 65, 93, 78, 23, 99, 90 };
txtLog.WriteLine(scores.ElementAt(4));
ElementAtOrDefault: Es el mismo que el método de extensión ElementAt salvo que no se produce una excepción si el elemento no existe. En cambio, se devuelve el valor por defecto para el tipo de la colección.
Except: Cuando se tiene una secuencia de elementos y desea saber qué elementos no existen en una segunda secuencia.
--------------------------------------VB------------------------------------------
Dim lastYearScores As Integer() = New Integer() {88, 56, 23, 99, 65}
Dim thisYearScores As Integer() = New Integer() {93, 78, 23, 99, 90}
Dim item As Integer
For Each item In lastYearScores.Except(thisYearScores)
txtLog.WriteLine(item)
Next
--------------------------------------CS------------------------------------------
int[] lastYearScores = { 88, 56, 23, 99, 65 };
int[] thisYearScores = { 93, 78, 23, 99, 90 };
foreach (var item in lastYearScores.Except(thisYearScores))
{
txtLog.WriteLine(item);
}
First: Cuando se tiene una secuencia de elementos y sólo quiere el primer elemento. Si no existen elementos, se lanza una InvalidOperationException.
--------------------------------------VB------------------------------------------
Dim scores = New Integer() {88, 56, 23, 99, 65, 93, 78, 23, 99, 90}
txtLog.WriteLine(scores.First())
--------------------------------------CS------------------------------------------
int[] scores = { 88, 56, 23, 99, 65, 93, 78, 23, 99, 90 };
txtLog.WriteLine(scores.First());
Resultado: 88
FirstOrDefault: Es lo mismo que el método First, salvo que si no existen elementos en la secuencia de origen, se devuelve el valor predeterminado del tipo de secuencia.
GroupBy: devuelve una secuencia de objetos IGrouping <TKey,TElement>. Implementa IEnumerable <TElement> y expone una propiedad de clave única que representa el valor de la clave para la agrupación.
--------------------------------------VB------------------------------------------
Dim cars = GetCars()
Dim query = cars.GroupBy(Function(c) c.Make)
For Each group As IGrouping(Of String, Car) In query
txtLog.WriteLine("Key:{0}", group.Key)
For Each c In group
txtLog.WriteLine("Car VIN:{0} Make:{1}", c.VIN, c.Make)
Next
Next
--------------------------------------CS------------------------------------------
var cars = GetCars();
var query = cars.GroupBy(c => c.Make);
foreach (IGrouping<string,Car> group in query)
{
txtLog.WriteLine("Key:{0}", group.Key);
foreach (Car c in group)
{
txtLog.WriteLine("Car VIN:{0} Make:{1}", c.VIN, c.Make);
}
}
El resultado quedaría:
Key:Ford
Car VIN:ABC123 Make:Ford
Car VIN:DEF456 Make:Ford
Key:BMW
Car VIN:DEF123 Make:BMW
Key:Audi
Car VIN:ABC456 Make:Audi
Key:VW
Car VIN:HIJ123 Make:VW
Intersect: Se utiliza cuando se tiene una secuencia de elementos en el que desea saber que existen en una segunda secuencia.
--------------------------------------VB------------------------------------------
Dim lastYearScores As Integer() = New Integer() {88, 56, 23, 99, 65}
Dim thisYearScores As Integer() = New Integer() {93, 78, 23, 99, 90}
Dim item As Integer
For Each item In lastYearScores.Intersect(thisYearScores)
Me.txtLog.WriteLine(item)
Next
--------------------------------------CS------------------------------------------
int[] lastYearScores = { 88, 56, 23, 99, 65 };
int[] thisYearScores = { 93, 78, 23, 99, 90 };
foreach (var item in lastYearScores.Intersect(thisYearScores))
{
txtLog.WriteLine(item);
}
resultado 23 , 99
Join: similar al inner join del SQL, produce un resultado único para cada entrada de la secuencia de exterior cuando hay una coincidencia con la secuencia de interior. Para cada elemento coincidente en la secuencia de interior, un elemento resultante se crea.
--------------------------------------VB------------------------------------------
Dim makes = New String() {"Audi", "BMW", "Ford", "Mazda", "VW"}
Dim cars = GetCars()
Dim query = makes.Join(cars, _
Function(make) make, _
Function(car) car.Make, _
Function(make, innerCar) New With {.Make = make, .Car = innerCar})
For Each item In query
txtLog.WriteLine("Make: {0}, Car:{1} {2} {3}",
item.Make, item.Car.VIN, item.Car.Make, item.Car.Model)
Next
--------------------------------------CS------------------------------------------
var makes = new string[] { "Audi", "BMW", "Ford", "Mazda", "VW" };
var cars = GetCars();
var query = makes.Join(cars,
make => make, car => car.Make,
(make, innerCar) => new { Make = make, Car = innerCar });
foreach (var item in query)
{
txtLog.WriteLine("Make: {0}, Car:{1} {2} {3}",
item.Make, item.Car.VIN, item.Car.Make, item.Car.Model);
}
Para entender un poco mas, el resultado quedaria:
Make: Audi, Car:ABC456 Audi TT
Make: BMW, Car:DEF123 BMW Z-3
Make: Ford, Car:ABC123 Ford F-250
Make: Ford, Car:DEF456 Ford F-150
Make: VW, Car:HIJ123 VW Bug
Last: Cuando se desea recuperar el último elemento de una secuencia. Este método produce una InvalidOperationException si no hay elementos en la secuencia.
--------------------------------------VB------------------------------------------
Dim scores = New Integer() {88, 56, 23, 99, 65, 93, 78, 23, 99, 90}
txtLog.WriteLine(scores.Last())
--------------------------------------CS------------------------------------------
int[] scores = { 88, 56, 23, 99, 65, 93, 78, 23, 99, 90 };
txtLog.WriteLine(scores.Last());
LastOrDefault: es el mismo que el método Last, pero si no existen elementos en la secuencia de origen, el valor predeterminado del tipo de secuencia se devuelve.
LongCount: es el mismo que el método Count, excepto que el conde devuelve un entero de 32 bits, yLongCount devuelve un entero de 64 bits.
Max: se utiliza cuando se tiene una secuencia de valores y desea determinar qué elemento es más grande.
--------------------------------------VB------------------------------------------
Dim scores = New Integer() {88, 56, 23, 99, 65, 93, 78, 23, 99, 90}
txtLog.WriteLine(scores.Max())
--------------------------------------CS------------------------------------------
int[] scores = { 88, 56, 23, 99, 65, 93, 78, 23, 99, 90 };
txtLog.WriteLine(scores.Max());
Resultado: 99
Min: Cuando estás trabajando con una secuencia no vacía de valores y desea determinar
qué elemento es el más pequeño.
OfType: es un método de filtrado que sólo devuelve objetos que se pueden convertir a un tipo específico.
--------------------------------------VB------------------------------------------
Dim items = New Object() {55, "Hello", 22, "Goodbye"}
For Each intItem In items.OfType(Of Integer)()
txtLog.WriteLine(intItem)
Next
--------------------------------------CS------------------------------------------
object[] items = new object[] { 55, "Hello", 22, "Goodbye" };
foreach (var intItem in items.OfType<int>())
{
txtLog.WriteLine(intItem);
}
El resultado seria :
55
22
OrderBy, OrderByDescending, ThenBy y ThenByDescending: Cuando se desea ordenar los elementos en una secuencia. Estos métodos de extensiónson nonstreaming, lo que significa que todos los elementos de la secuencia deben ser evaluados antes de cualquier salida se puede producir.
Todos estos métodos de extensión devuelven un objeto IOrderedEnumerable <T>, que hereda de IEnumerable <T> y permite a los operadores ThenBy y ThenByDescending.
--------------------------------------VB------------------------------------------
Dim cars = GetCars().OrderBy(Function(c) c.Make) _
.ThenByDescending(Function(c) c.Model) _
.ThenBy(Function(c) c.Year)
For Each item In cars
txtLog.WriteLine("Car VIN:{0} Make:{1} Model:{2} Year:{3}", _
item.VIN, item.Make, item.Model, item.Year)
Next
--------------------------------------CS------------------------------------------
var cars = GetCars().OrderBy(c=>c.Make)
.ThenByDescending(c=>c.Model)
.ThenBy(c=>c.Year);
foreach (var item in cars)
{
txtLog.WriteLine("Car VIN:{0} Make:{1} Model:{2} Year:{3}",
item.VIN, item.Make, item.Model, item.Year);
}
El resultado:
Car VIN:ABC456 Make:Audi Model:TT Year:2008
Car VIN:DEF123 Make:BMW Model:Z-3 Year:2005
Car VIN:ABC123 Make:Ford Model:F-250 Year:2000
Car VIN:DEF456 Make:Ford Model:F-150 Year:1998
Car VIN:HIJ123 Make:VW Model:Bug Year:1956
Reverse: es un mecanismo de ordenación que se invierte el orden de los elementos de la secuencia.
--------------------------------------CS------------------------------------------
Dim scores = {88, 56, 23, 99, 65, 93, 78, 23, 99, 90}
For Each item In scores.Reverse()
txtLog.WriteLine(item)
Next
--------------------------------------CS------------------------------------------
int[] scores = { 88, 56, 23, 99, 65, 93, 78, 23, 99, 90 };
foreach (var item in scores.Reverse())
{
txtLog.WriteLine(item);
}
}
Select: devuelve un elemento de salida para cada elemento de entrada. El operador de selección también le permite realizar una proyección de un nuevo tipo de elemento. Este mecanismo de conversión o la cartografía juega un papel importante en la mayoría de las consultas LINQ.
--------------------------------------VB------------------------------------------
Dim vehicles As New List(Of Tuple(Of String, String, Integer)) From { _
Tuple.Create(Of String, String, Integer)("123", "VW", 1999), _
Tuple.Create(Of String, String, Integer)("234", "Ford", 2009), _
Tuple.Create(Of String, String, Integer)("567", "Audi", 2005), _
Tuple.Create(Of String, String, Integer)("678", "Ford", 2003), _
Tuple.Create(Of String, String, Integer)("789", "Mazda", 2003), _
Tuple.Create(Of String, String, Integer)("999", "Ford", 1965) _
}
Dim fordCars = vehicles.Where(Function(v) v.Item2 = "Ford") _
.Select(Function(v) New Car With { _
.VIN = v.Item1, _
.Make = v.Item2, _
.Year = v.Item3 _
})
For Each item In fordCars
txtLog.WriteLine("Car VIN:{0} Make:{1} Year:{2}", _
item.VIN, item.Make, item.Year)
Next
--------------------------------------CS------------------------------------------
var vehicles = new List<Tuple<string,string,int>>
{
Tuple.Create("123", "VW", 1999),
Tuple.Create("234","Ford",2009),
Tuple.Create("567","Audi", 2005),
Tuple.Create("678","Ford", 2003),
Tuple.Create("789","Mazda", 2003),
Tuple.Create("999","Ford",1965)
};
var fordCars = vehicles
.Where(v=>v.Item2=="Ford")
.Select(v=>new Car
{
VIN=v.Item1,
Make=v.Item2,
Year=v.Item3
});
foreach (var item in fordCars )
{
txtLog.WriteLine("Car VIN:{0} Make:{1} Year:{2}",
item.VIN, item.Make, item.Year);
}
resultado:
Car VIN:234 Make:Ford Year:2009
Car VIN:678 Make:Ford Year:2003
Car VIN:999 Make:Ford Year:1965
SelectMany: proyecta un único elemento de salida en varios elementos de salida, se puede utilizar para realizar una combinación interna de SQL (inner join), también se puede utilizar cuando se trabaja con una colección de colecciones, y que está consultando la colección de exterior, pero necesitan para producir un elemento de salida para cada elemento de la colección interna. Ej:
--------------------------------------VB------------------------------------------
Dim repairs = New List(Of Tuple(Of String, List(Of String))) From
{
Tuple.Create("ABC123",
New List(Of String) From {"Rotate Tires", "Change oil"}),
Tuple.Create("DEF123",
New List(Of String) From {"Fix Flat", "Wash Vehicle"}),
Tuple.Create("ABC456",
New List(Of String) From {"Alignment", "Vacuum", "Wax"}),
Tuple.Create("HIJ123",
New List(Of String) From {"Spark plugs", "Air filter"}),
Tuple.Create("DEF456",
New List(Of String) From {"Wiper blades", "PVC valve"})
}
Dim query = repairs.SelectMany(Function(t) _
t.Item2.Select(Function(r) New With {.VIN = t.Item1, .Repair = r}))
For Each item In query
txtLog.WriteLine("VIN:{0} Repair:{1}", item.VIN, item.Repair)
Next
--------------------------------------CS------------------------------------------
var repairs = new List<Tuple<string, List<string>>>
{
Tuple.Create("ABC123",new List<string>{"Rotate Tires","Change oil"}),
Tuple.Create("DEF123",new List<string>{"Fix Flat","Wash Vehicle"}),
Tuple.Create("ABC456",new List<string>{"Alignment","Vacuum", "Wax"}),
Tuple.Create("HIJ123",new List<string>{"Spark plugs","Air filter"}),
Tuple.Create("DEF456",new List<string>{"Wiper blades","PVC valve"}),
};
var query = repairs.SelectMany(t =>
t.Item2.Select(r => new { VIN = t.Item1, Repair = r }));
foreach (var item in query)
{
txtLog.WriteLine("VIN:{0} Repair:{1}", item.VIN, item.Repair);
}
SequenceEqual: cuando se tienen dos secuencias y queremos ver si contienen los mismos elementos en el mismo orden.
--------------------------------------VB------------------------------------------
Dim lastYearScores = New List(Of Integer) From {93, 78, 23, 99, 91}
Dim thisYearScores = New List(Of Integer) From {93, 78, 23, 99, 90}
txtLog.WriteLine(lastYearScores.SequenceEqual(thisYearScores))
--------------------------------------CS------------------------------------------
var lastYearScores = new List<int>{ 93, 78, 23, 99, 91 };
var thisYearScores = new List<int>{ 93, 78, 23, 99, 90 };
txtLog.WriteLine(lastYearScores.SequenceEqual(thisYearScores));
Single: cuando se tiene una colección de un elemento y se lo desea convertir a un elemento generico de la interfaz IEnumerable. Si la secuencia contiene más de un elemento o elementos que no, se producirá una excepción.
--------------------------------------VB------------------------------------------
Dim cars = GetCars()
Dim myCar As Car = cars.Where(Function(c) c.VIN = "HIJ123").Single()
--------------------------------------CS------------------------------------------
var cars = GetCars();
Car myCar = cars.Where(c => c.VIN == "HIJ123").Single();
SingleOrDefault: funciona como el método Single, salvo que no se producirá una excepción sino hay elementos en la secuencia. Todavía produce una excepción InvalidOperationException si hay más de un elemento.
Skip: ignora los elementos de la secuencia de origen.
--------------------------------------VB------------------------------------------
Dim scores = {88, 56, 23, 99, 65, 93, 78, 23, 99, 90} For Each score In scores.OrderBy(Function(i) i).Skip(1) txtLog.WriteLine(score) Next
--------------------------------------CS------------------------------------------
int[] scores = { 88, 56, 23, 99, 65, 93, 78, 23, 99, 90 };
foreach (var score in scores.OrderBy(i=>i).Skip(1))
{
txtLog.WriteLine(score);
}
resultado:
56
65
78
88
90
93
99
SkipWhile : es similar al método Skip a excepción SkipWhile acepta un predicado que toma un elemento de la colección y devuelve un valor booleano para determinar cuándo debe omitir.
--------------------------------------VB------------------------------------------
Dim scores = {88, 56, 23, 99, 65, 93, 78, 23, 99, 90}
For Each score In scores.OrderBy(Function(i) i).SkipWhile(Function(s) s < 80)
txtLog.WriteLine(score)
--------------------------------------CS------------------------------------------
int[] scores = { 88, 56, 23, 99, 65, 93, 78, 23, 99, 90 };
foreach (var score in scores.OrderBy(i => i).SkipWhile(s => s < 80))
{
txtLog.WriteLine(score);
}
el resultado seria:
88
90
93
99
99
SUM :El método de extensión Sum es una función de agregado que puede iterar sobre la secuencia de origen y calcular una suma total basado en la expresión lambda pasado a este método para seleccionar la propiedad que se suman. Si la secuencia es IEnumerable de un tipo numérico, la suma puede ser ejecutado sin una expresión lambda. El código de ejemplo siguiente muestra la suma de todas las puntuaciones.
--------------------------------------VB------------------------------------------
Dim scores = {88, 56, 23, 99, 65, 93, 78, 23, 99, 90}
txtLog.WriteLine(scores.Sum())
--------------------------------------CS------------------------------------------
int[] scores = { 88, 56, 23, 99, 65, 93, 78, 23, 99, 90 };
txtLog.WriteLine(scores.Sum());
el resultado es: 714
Take: recupera una parte de la secuencia. Se puede especificar el número de elementos que se desea con este método.
--------------------------------------VB------------------------------------------
Dim scores = {88, 56, 23, 99, 65, 93, 78, 23, 99, 90}
For Each item In scores.OrderBy(Function(i) i).Skip(3).Take(2)
txtLog.WriteLine(item)
Next
--------------------------------------CS------------------------------------------
int[] scores = { 88, 56, 23, 99, 65, 93, 78, 23, 99, 90 };
foreach (var item in scores.OrderBy(i => i).Skip(3).Take(2))
{
txtLog.WriteLine(item);
}
El ejemplo anterior, saltea los primeros 3 elementos y tomas los siguientes 2. El resultado es:
99
65
TakeWhile: similar a skipwile, solo que este recupera los elementos de la secuencia, siempre y cuando el predicado devuelva true.
ToArray: el método de extensión ToArray ejecuta la consulta diferida y transforma estos datos en una matriz del tipo de elemento de la secuencia original.
--------------------------------------VB------------------------------------------
Dim scores = {88, 56, 23, 99, 65, 93, 78, 23, 99, 90}
Dim evenScores = scores.Where(Function(s) s Mod 2 = 0).ToArray()
scores(2) = 2
For Each item In evenScores
txtLog.WriteLine(item)
Next
--------------------------------------CS------------------------------------------
int[] scores = { 88, 56, 23, 99, 65, 93, 78, 23, 99, 90 };
var evenScores = scores.Where(s => s % 2 == 0).ToArray();
scores[2] = 2;
foreach (var item in evenScores)
{
txtLog.WriteLine(item);
}
el resultado seria:
88
56
78
90
ToDictionary: ejecuta una consulta diferida y convierte el resultado a un diccionario con un tipo de clave deduce del tipo de salida que devuelve la consulta lambda que se pasa como parámetro.
--------------------------------------VB------------------------------------------
Dim cars = GetCars()
Dim carsByVin = cars.ToDictionary(Function(c) c.VIN)
Dim myCar = carsByVin("HIJ123")
txtLog.WriteLine("Car VIN:{0}, Make:{1}, Model:{2} Year:{3}", _
myCar.VIN, myCar.Make, myCar.Model, myCar.Year)
--------------------------------------CS------------------------------------------
var cars = GetCars();
var carsByVin = cars.ToDictionary(c=>c.VIN);
Car myCar = carsByVin["HIJ123"];
txtLog.WriteLine("Car VIN:{0}, Make:{1}, Model:{2} Year:{3}",
myCar.VIN, myCar.Make, myCar.Model, myCar.Year);
Resultado:
Car VIN:HIJ123, Make:VW, Model:Bug Year:1956
ToList: ejecuta la consulta diferida y almacena cada elemento en una lista <T> donde T es del mismo tipo que la secuencia original.
ToLookup: ILookup vuelve <TKey, TElement>, es decir, una secuencia de objetos IGrouping <TKey,TElement>. Esta interfaz especifica una clave que representa cada valor de agrupación. Este método crea un objeto de colección nueva, proporcionando así una visión congelada. Si se cambia la colección original no afectará a esta colección.
--------------------------------------VB------------------------------------------
Dim cars = GetCars()
Dim query = cars.ToLookup(Function(c) c.Make)
cars.Clear()
For Each group As IGrouping(Of String, Car) In query
txtLog.WriteLine("Key:{0}", group.Key)
For Each c In group
txtLog.WriteLine("Car VIN:{0} Make:{1}", c.VIN, c.Make)
Next
Next
--------------------------------------CS------------------------------------------
var cars = GetCars();
var query = cars.ToLookup(c => c.Make);
cars.Clear();
foreach (IGrouping<string, Car> group in query)
{
txtLog.WriteLine("Key:{0}", group.Key);
foreach (Car c in group)
{
txtLog.WriteLine("Car VIN:{0} Make:{1}", c.VIN, c.Make);
}
}
Resultado:
Key:Ford
Car VIN:ABC123 Make:Ford
Car VIN:DEF456 Make:Ford
Key:BMW
Car VIN:DEF123 Make:BMW
Key:Audi
Car VIN:ABC456 Make:Audi
Key:VW
Car VIN:HIJ123 Make:VW
Union: A veces, desea combinar dos colecciones y trabajar con el resultado. El método de extensión de la Unión combina los elementos de dos secuencias, y muestra los elementos distintos. Es decir, filtra los duplicados. Esto es equivalente a la ejecución de Concat y Distinct.
--------------------------------------VB------------------------------------------
Dim lastYearScores = {88, 56, 23, 99, 65, 56}
Dim thisYearScores = {93, 78, 23, 99, 90, 99}
Dim allScores = lastYearScores.Union(thisYearScores)
For Each item In allScores.OrderBy(Function(s) s)
txtLog.WriteLine(item)
Next
--------------------------------------CS------------------------------------------
int[] lastYearScores = { 88, 56, 23, 99, 65, 56 };
int[] thisYearScores = { 93, 78, 23, 99, 90, 99 };
var allScores = lastYearScores.Union(thisYearScores);
foreach (var item in allScores.OrderBy(s=>s))
{
txtLog.WriteLine(item);
}
el resultado es:
23
56
65
78
88
90
93
99
Where: permite filtrar una secuencia de origen. Este método acepta una expresión lambda como predicado.
Ejemplo, obtener los autos de la marca Ford
--------------------------------------VB------------------------------------------
Dim cars = GetCars()
For Each myCar In cars.Where(Function(c) c.Make = "Ford")
txtLog.WriteLine("Car VIN:{0}, Make:{1}, Model:{2} Year:{3}", _
myCar.VIN, myCar.Make, myCar.Model, myCar.Year)
Next
--------------------------------------CS------------------------------------------
var cars = GetCars();
foreach (var myCar in cars.Where(c => c.Make == "Ford"))
{
txtLog.WriteLine("Car VIN:{0}, Make:{1}, Model:{2} Year:{3}",
myCar.VIN, myCar.Make, myCar.Model, myCar.Year);
}
Resultado:
Car VIN:ABC123, Make:Ford, Model:F-250 Year:2000
Car VIN:DEF456, Make:Ford, Model:F-150 Year:1998
Zip: el método de extensión ZIP combina dos secuencias. Esto no es ni la Unión ni Concat porque el número de elementos resultante es igual al número mínimo de las dos secuencias. Un elemento de la secuencia 1 está acoplado a un elemento de la secuencia 2, mediante una expresión lambda pasada como predicado para definir qué tipo de salida va a tener esta unión.
Ejemplo: a cada auto se le asigna un numero y se muestra junto con la marca.
--------------------------------------VB------------------------------------------
Dim numbers = Enumerable.Range(1, 100)
Dim cars = GetCars()
Dim zip = numbers.Zip(cars, _
Function(i, c) New With {.Number = i, .CarMake = c.Make})
For Each item In zip
txtLog.WriteLine("Number:{0} CarMake:{1}", item.Number, item.CarMake)
Next
--------------------------------------CS------------------------------------------
var numbers = Enumerable.Range(1, 100);
var cars = GetCars();
var zip = numbers.Zip(cars, (i, c) => new {
Number = i, CarMake = c.Make });
foreach (var item in zip)
{
txtLog.WriteLine("Number:{0} CarMake:{1}", item.Number, item.CarMake);
}
Resultado:
Number:1 CarMake:Ford
Number:2 CarMake:BMW
Number:3 CarMake:Audi
Number:4 CarMake:VW
Number:5 CarMake:Ford
Resumen de la lección
En esta lección se proporciona información detallada sobre las características que integran LINQ.
■ Los inicializadores de objetos permiten inicializar las propiedades y campos públicos sin crear un constructor explícito.
■ El tipo implícito en variables locales permite declarar una variable sin especificar su
tipo, y el compilador inferirá el tipo para usted.
■ En muchos casos, utilizando las variables de tipo implícito local es una opción, pero,cuando se trabaja con tipos anónimos, es un requisito.
■Los tipos anónimos permiten crear un tipo “inline”. Esto le permite agrupar los datos
sin crear una clase.
■Los métodos de extensión permiten agregar métodos a un tipo, incluso cuando usted no tiene el código fuente para el tipo.
■Los métodos de extensión permiten crear métodos concretos en las interfaces, es decir,todos los tipos que implementan la interfaz recibirá estos métodos.
■ La clase Enumerable contiene los métodos de extensión de la consulta y los métodos estáticos llamados vacíos, Rango y Repetir
No hay comentarios:
Publicar un comentario