Limitando datos: Los métodos Take() & Skip().

Hasta ahora, en este capítulo de LINQ del tutorial, hemos descubierto varias formas de trabajar con fuentes de datos utilizando LINQ. Ahora ha llegado el momento de ver cómo podemos limitar la cantidad de datos para trabajar. Esto es especialmente útil cuando se utiliza una base de datos como fuente de datos, ya que a menudo involucra grandes cantidades de filas, que consumen recursos para obtenerlas.

Los métodos que discutiremos en este artículo se llaman Take () y Skip () , y en combinación, son excelentes para hacer cosas como la paginación en un sitio web. De hecho, a menudo se usan juntos, pero, por supuesto, también se pueden usar solos. El método Take () obtendrá X números de elementos de la fuente de datos, mientras que Skip () le permitirá ignorar los primeros X elementos. Un ejemplo simple podría verse así:

List<string> names = new List<string>()
{
    "John Doe",
    "Jane Doe",
    "Joe Doe",
    "Jenna Doe",
};
var middleNames = names.Skip(1).Take(2).ToList();
foreach (var name in middleNames)
    Console.WriteLine(name);

Creamos una lista simple de nombres y luego, para la salida, omitimos el primer nombre (Skip (1)) y luego tomamos los siguientes dos nombres (Take (2)), básicamente dejándonos solo los dos segundos nombres de la lista.

Paginación básica con Skip() y Take().

Como puede ver, los métodos Take () y Skip () son muy simples de usar, pero son más interesantes de usar con más datos de los que hemos usado anteriormente, veamos un ejemplo un poco más complejo , lo que demostrará mejor cómo estos métodos pueden ayudarlo. Primero, aquí tenemos el código:

using System;
using System.Globalization;
using System.Linq;
using System.Xml.Linq;

namespace LinqTakeSkip1
{
    class Program
    {
    static void Main(string[] args)
    {
        CultureInfo usCulture = new CultureInfo("en-US");
        XDocument xDoc = XDocument.Load("http://www.ecb.europa.eu/stats/eurofxref/eurofxref-daily.xml");
        var cubeNodes = xDoc.Descendants().Where(n => n.Name.LocalName == "Cube" && n.Attribute("currency") != null).ToList();
        var currencyRateItems = cubeNodes.Select(node => new
        {
        Currency = node.Attribute("currency").Value,
        Rate = double.Parse(node.Attribute("rate").Value, usCulture)
        });


        int pageSize = 5, pageCounter = 0;
        var pageItems = currencyRateItems.Take(pageSize);
        while(pageItems.Count() > 0)
        {
        foreach (var item in pageItems)
            Console.WriteLine(item.Currency + ": " + item.Rate.ToString("N2", usCulture));
        Console.WriteLine("Press any key to get the next items...");
        Console.ReadKey();
        pageCounter++;
        // Here's where we use the Skip() and Take() methods!
        pageItems = currencyRateItems.Skip(pageSize * pageCounter).Take(pageSize);
        }
        Console.WriteLine("Done!");
        
    }
    }
}

Eso es bastante código, pero repasemos. En la primera mitad, analizamos una XML source of currency exchange rates disponible públicamente. Esto me da la oportunidad de mostrarle brevemente LINQ to XML, que es una parte muy interesante del ecosistema LINQ. Analizaremos LINQ to XML en otro artículo, pero por ahora, solo sepamos que lo usamos para extraer los nodos importantes de la fuente XML y colocarlos en objetos anónimos, que consisten en el nombre y el tipo de cambio actual de la moneda, que lo usaremos más adelante.

Ahora tenemos una buena fuente de datos de información monetaria en la variable currencyRateItems. En la última mitad del ejemplo, usamos esta fuente para hacer una paginación simple: simplemente sacamos 5 entradas y luego le pedimos al usuario que presione una tecla para obtener las siguientes 5 (o las que queden en la fuente). Hacemos eso extrayendo las primeras 5 entradas y luego usamos un ciclo while para extraer continuamente las siguientes 5 entradas, hasta que la fuente esté vacía. La obtención de las siguientes 5 entradas se realiza con una combinación de Skip () y Take () : la base completa de este artículo.

Resumen.

Los métodos Skip () y Take () son muy simples de usar, pero, sin embargo, muy útiles en muchas situaciones. Como se mencionó, a menudo se usan juntos, pero especialmente el método Take () también puede usarse solo.