Restringindo dados: os métodos Take() & Skip()

Até agora, neste capítulo LINQ do tutorial, descobrimos várias maneiras de trabalhar com fontes de dados usando o LINQ. Agora chegou a hora de ver como podemos limitar a quantidade de dados para trabalhar. Isso é especialmente útil ao usar um banco de dados como uma fonte de dados, porque geralmente envolve grandes quantidades de linhas, que são recursos de recursos para buscar.

Os métodos que discutiremos neste artigo são chamados Take() e Skip() e, em combinação, eles são ótimos para fazer coisas como paginação em um site. De fato, eles são freqüentemente usados juntos, mas eles podem ser usados sozinhos também. O método Take() lhe dará um número X de itens da fonte de dados, enquanto que o Skip() permitirá que você ignore os primeiros X items. Um exemplo simples poderia ser assim:

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);

Criamos uma lista simples de nomes e então, para a saída, pulamos o primeiro nome (Skip (1)) e depois pegamos os dois nomes seguintes (Take (2)), basicamente deixando apenas os dois nomes do meio a lista.

Paginação básica com Skip() e Take()

Como você pode ver, os métodos Take() e Skip() são muito simples de usar, mas eles são mais interessantes de demonstrar com mais dados do que usamos anteriormente, então eu tomei a liberdade de criar um exemplo um pouco mais complexo , que demonstrará melhor como esses métodos podem ajudá-lo. Primeiro, aqui está o código para isso:

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!");
        
    }
    }
}

Isso é um pouco de código, mas vamos analisá-lo. No primeiro semestre, analisamos uma fonte XML das taxas de câmbio de moeda disponíveis ao público. Isso me dá a oportunidade de mostrar brevemente LINQ para XML, que é uma parte muito legal do ecossistema LINQ. Discutiremos LINQ to XML em outro artigo, mas, por enquanto, sabemos que o usamos para extrair os nós importantes da fonte XML e colocá-los em objetos anônimos, consistindo no nome e na taxa de câmbio atual da moeda, que vamos usar mais tarde.

Agora temos uma boa fonte de dados de informações sobre moedas na variável currencyRateItems. Na última metade do exemplo, usamos essa fonte para fazer uma paginação simples - simplesmente retiramos 5 entradas e depois pedimos ao usuário que pressione uma tecla para obter as próximas 5 (ou quantas ainda restarem na fonte). Fazemos isso extraindo as 5 primeiras entradas e depois usamos um loop while para extrair continuamente as próximas 5 entradas, até que a fonte esteja vazia. Obtendo as próximas 5 entradas é feito com uma combinação de Skip() e Take() - toda a base deste artigo.

Resumo

Os métodos Skip() e Take() são muito simples de usar, mas muito úteis em muitas situações. Como mencionado, eles são freqüentemente usados juntos, mas especialmente o método Take() também pode ser usado sozinho.