Transformaciones de datos: el método Select ().

Hasta ahora en este capítulo de LINQ del tutorial, hemos trabajado con fuentes de datos simples, p.e. Una lista de enteros, cadenas u objetos simples como la clase Usuario. Continuaremos haciéndolo así porque es muy práctico cuando le mostramos ejemplos de los diversos métodos de LINQ, pero tenga en cuenta que con LINQ, la fuente de datos podría ser un documento XML complejo o una gran base de datos.

En este artículo, hablaremos sobre el método Select (), que le permite tomar los datos de la fuente de datos y transformarlos en otra cosa. Eso podría ser más útil con fuentes de datos más grandes y complejas, como las que se mencionó anteriormente, pero tenga paciencia conmigo de todos modos, mientras trato de mostrarle cómo funciona el método Select () y qué puede hacer con él. Como de costumbre, iremos directamente a un ejemplo:

using System;  
using System.Collections.Generic;  
using System.Linq;  

namespace LinqSelect1  
{  
    class Program  
    {  
    static void Main(string[] args)  
    {  
        List<User> listOfUsers = new List<User>()  
        {  
        new User() { Name = "John Doe", Age = 42 },  
        new User() { Name = "Jane Doe", Age = 34 },  
        new User() { Name = "Joe Doe", Age = 8 },  
        new User() { Name = "Another Doe", Age = 15 },  
        };  

        List<string> names = listOfUsers.Select(user => user.Name).ToList();  

        foreach (string name in names)  
        Console.WriteLine(name);  
    }  

    class User  
    {  
        public string Name { get; set; }  
        public int Age { get; set; }  
    }  
    }  
}

Observe cómo puedo tomar una lista de objetos, en este caso del tipo Usuario, y luego usar el método Select () para dar forma a esta lista en un nuevo tipo de lista. En este ejemplo, convierto la lista de objetos en una lista de cadenas que contienen los nombres de los usuarios. Esto es extremadamente práctico en muchas situaciones, donde necesita que sus datos se vean de manera diferente, o cuando solo necesita un subconjunto de ellos. Por supuesto, también funciona al revés: puede crear fácilmente una lista de objetos de usuario a partir de una lista de nombres (sin embargo, deberá agregar manualmente su edad más adelante):

List<User> listOfUsers = new List<User>()
{
    new User() { Name = "John Doe", Age = 42 },
    new User() { Name = "Jane Doe", Age = 34 },
    new User() { Name = "Joe Doe", Age = 8 },
    new User() { Name = "Another Doe", Age = 15 },
};

List<string> names = listOfUsers.Select(user => user.Name).ToList();

List<User> users = names.Select(name => new User { Name = name }).ToList();

foreach (User user in users)
    Console.WriteLine(user.Name);

Observe cómo puedo crear nuevos objetos con el método Select (): ¡es una característica extremadamente poderosa que le permite hacer prácticamente cualquier cosa con sus datos sobre la marcha! Un uso común de esta funcionalidad es hacer versiones menos complejas de un objeto, p.e. para volver a través de un servicio web como JSON o XML. Imagine que tiene una clase de Usuario con MUCHAS propiedades (Cumpleaños, Sexo, Correo, Dirección, País, etc.), pero solo desea devolver un conjunto limitado de estas propiedades, que también podría tener sentido, por seguridad, para asegúrese de no devolver propiedades de usuario comunes como nombre de usuario y contraseña. Aquí hay un ejemplo simplificado: imagine una clase de usuario mucho más compleja:

using System;
using System.Collections.Generic;
using System.Linq;

namespace LinqSelect2
{
    class Program
    {
    static void Main(string[] args)
    {
        List<User> listOfUsers = new List<User>()
        {
        new User() { Name = "John Doe", Mail = "john@doe.com", Age = 42 },
        new User() { Name = "Jane Doe", Mail = "jane@doe.com", Age = 34 },
        new User() { Name = "Joe Doe", Mail = "joe@doe.com", Age = 8 },
        new User() { Name = "Another Doe", Mail = "another@doe.com", Age = 15 },
        };

        var simpleUsers = listOfUsers.Select(user => new
        {
        Name = user.Name,
        Age = user.Age
        });
        foreach (var user in simpleUsers)
        Console.WriteLine(user.Name);
    }

    class User
    {
        public string Name { get; set; }
        public int Age { get; set; }
        public string Mail { get; set; }
    }
    }
}

En este ejemplo, utilizamos el método Select () para devolver una lista de tipos anónimos, que contiene solo un subconjunto de las propiedades encontradas en la fuente de datos. Luego hacemos la salida clásica de estos objetos a la consola, pero solo debe imaginarnos devolviéndolos a un sitio web o en otro lugar, donde es importante mantener el resultado lo más simple posible, sin revelar ningún secreto como contraseñas, etc.

Como ya comentamos, utilizaré principalmente la sintaxis de método de LINQ en estos ejemplos, pero, por supuesto, las operaciones que realizamos en este ejemplo también se pueden expresar con la sintaxis de consulta LINQ:

// Method syntax
var simpleUsers = listOfUsers.Select(user => new
{
    Name = user.Name,
    Age = user.Age
});

// Query syntax
var simpleUsersQ = (from user in listOfUsers
            select new
            {
            Name = user.Name,
            Age = user.Age
            }).ToList();

foreach (var user in simpleUsersQ)
    Console.WriteLine(user.Name);

Espero que esto te dé una idea más clara de la sintaxis que prefieres, ¡pero el resultado es, por supuesto, el mismo!

Resumen.

El método Select () le permite transformar y dar forma a los datos de su fuente de datos en nuevas variantes, por ejemplo, seleccionando solo una propiedad única o devolviendo objetos que solo contienen un subconjunto de las propiedades encontradas en el objeto fuente.