Data transformations: the Select() method

Fino ad ora, in questo capitolo del tutorial di LINQ, abbiamo lavorato con fonti di dati semplici, per esempio un array di interi o concatenazioni di oggetti semplici come la classe Utente. Continueremo facendo in questo modo poiché è molto pratico nel momento in cui andremo a mostrare gli esempi dei diversi metodi di LINQ, bisogna però considerare che con LINQ, la fonte dei dati potrebbe essere un documento XML o un grande database.

In questo articolo tratteremo il metodo Select(), il quale permette di prendere i dati da una fonte di dati e trasformarli in un altro tipo/formato. Questo potrebbe essere molto utile con fonti di dati più grandi e complesse, come quelle citate sopra, ma seguitemi comunque, mentre cerco di mostrarvi come funziona il metodo Select() e cosa potete fare con esso. Come al solito, passiamo subito a un esempio:

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

Osserva come posso prendere una lista di oggetti, in questo caso di tipo Utente, e successivamente usare il metodo Select() per dar forma a questa lista in un nuovo tipo di lista. In questo esempio, converto la lista di oggetti in una lista concatenata, dove è necessario che i suoi dati si vedano in maniera differente, o quando si ha bisogno di un sottoinsieme di questi dati. Ovviamente, funziona anche al contrario: puoi creare facilmente una lista di oggetti partendo da una lista di nomi( senza dubbio, dovrai aggiungere manualmente la sua età più avanti):

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

Osserva come posso creare nuovi oggetti con il metodo Select (): questa è una caratteristica estremamente potente che permette di fare qualsiasi cosa con i dati, in modo rapido! Un utilizzo comune di questa funzionalità è quella di fare delle versioni meno complesse di un oggetto, p.e. per ritornare da un servizio web come JSON o XML . Immagina di avere una classe Utente con molti attributi ( Compleanno, Sesso, Email, Indirizzo, Paese ecc.), ma desideri che ritorni un output con solo alcuni di questi attributi, che abbiano senso, per sicurezza, per essere sicuri di non rivelare degli attributi personali dell'utente come ad esempio nome e password. Qui hai un esempio semplificato: immagina una classe di utenti molto più complessa:

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

In questo esempio, utilizziamo il metodo Select() per ottenere in output una lista di tipo anonimo, che contiene solo un sottoinsieme degli attributi trovati nella fonte di dati. Dopo otteniamo un output classico di questi oggetti in Console, ma dobbiamo immaginarci di farli ritornare ad un sito web o in un altro posto, dove è importante mantenere il risultato il più semplice possibile senza rivelare nessun segreto come password ecc.

Come abbiamo già discusso, utilizzeremo principalmente la sintassi del Metodo LINQ in questo esempio, però, certamente, le operazione che realizziamo in questo esempio si possono anche esprimere con la sintassi di Query 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);

Spero che questo ti darà un'idea più chiara della sintassi che preferisci , però il risultato è certamente lo stesso!

Summary

Il metodo Select() permette di trasformare e dar forma ai dati dalla sua fonte di dati ,in una nuova variante, per esempio, selezionando solo un unico attributo o ritornando oggetti che contengono solo un sottoinsieme degli attributi trovati nella fonte dell'oggetto.