Tipi Anonimi

Finora, abbiamo imparato che gli oggetti derivano da una classe. Una classe viene dichiarata con un certo numero di campi, proprietà e/o metodi e solo dopo si può creare un'istanza di questa classe come un oggetto. Tuttavia, con l'introduzione dei tipi anonimi, non è più necessario dichiarare una classe prima di creare un oggetto. Niente paura, le classi non sono affatto defunte, perché i tipi (o gli oggetti) anonimi viaggiano con diverse limitazioni, ma, per alcune situazioni, sono davvero ottime.

Un tipo anonimo viene inizializzato usando l'operatore new, in combinazione con un inizializzatore di oggetti. In questo, assomiglia molto all'istanziazione di una classe, solo che si omette il nome della classe. Inoltre, siccome non c'è alcuna classe retrostante l'oggetto, si deve usare la parola chiave var quando si ottiene il riferimento all'oggetto. Questo potrebbe sembrare complicato, ma l'esempio seguente dimostrerà che non lo è affatto:

var user = new    
{    
    Name = "John Doe",    
    Age = 42   
};
Console.WriteLine(user.Name + " - " + user.Age + " years old");

Tutto qui. Adesso abbiamo un oggetto con le informazioni (nome ed età) di un utente. I tipi anonimi sono ottimi per molte situazioni, specialmente quando si ha bisogno di ritornare velocemente qualcosa, com maggiore complessità di una stringa o un numero solamente. I tipi anonimi permettono di creare proprietà al volo, senza preoccuparsi di dichiarare prima una classe e poi dover modificare questa classe quando cambiano le necessità. Ma, come detto, ci sono diverse limitazioni di cui essere consci quando si considera l'uso di un tipo anonimo al posto di una classe:

• A differenza di una vera classe, un tipo anonimo non può avere campi o metodi, solo proprietà
• Una volta che l'oggetto è stato inizializzato, non si possono aggiungere nuove proprietà
• Le proprietà sono di sola lettura (readonly). Una volta che l'oggetto è stato inizializzato, non si possono cambiare i loro valori

Ma, detto questo, i tipi anonimi sono comunque estremamente pratici per molte attività. Uno scenario tipico è quando si ha un oggetto complesso (da una classe definita) e si ha bisogno di semplificarlo, ad esempio, perché si deve mantenere l'oggetto il più piccolo possibile per inoltrarlo ad un browser oppure perché l'oggetto completo ha informazioni sensibili che non si vuole esporre al consumatore. I tipi anonimi sono ottimi per questo, come illustrato nel prossimo esempio:

using System;
using System.IO;

namespace AnonymousTypes
{
    class Program
    {
    static void Main(string[] args)
    {
        string pathOfExe = System.Reflection.Assembly.GetEntryAssembly().Location;
        FileInfo fileInfo = new FileInfo(pathOfExe);
        var simpleFileInfo = new
        {
        Filename = fileInfo.Name,
        FileSize = fileInfo.Length
        };
        Console.WriteLine("File name: " + simpleFileInfo.Filename + ". Size: " + simpleFileInfo.FileSize + " bytes");
    }
    }
}

La prima linea recupera semplicemente il nome del file attualmente in esecuzione, cioè dell'applicazione. Lo usiamo per creare un'istanza della classe FileInfo, che conterrà MOLTE informazioni su questo file specifico. Non ci servono tutte queste informazioni, così ne creiamo una versione semplificata con un tipo anonimo, usando le informazioni dell'istanza originale di FileInfo. Nell'ultima linea, usiamo queste informazioni per un semplice output.

Avrete probabilmente notato che diamo un nome a ciascuna proprietà definita nel tipo anonimo (Filename eFileSize). Questo ha perfettamente senso, se vogliamo accedervi succesivamente. Comunque, basando l'oggetto anonimo su informazioni di un oggetto esistente, possiamo effettivamente omettere il nome e lasciare che il compilatore usi semplicemente quello della proprietà che stiamo assegnando, in questo modo:

var simpleFileInfo = new
{
    fileInfo.Name,
    fileInfo.Length
};

Adesso abbiamo due proprietà chiamate Name eLength, invece di Filename eFileSize. Molto pratico, se non ci interessa il nome o meglio, se preferiamo effettivamente lo stesso nome dell'oggetto originale.

Riepilogo

I tipi anonimi permettono di instanziare velocemente un oggetto con una o più proprietà. Queste proprietà sono di sola lettura (readonly) e non si possono aggiungere altre proprietà in un secondo momento.