Extension Methods, Lambda Expression e Type Inference
Ora che abbiamo a disposizione una lista da interrogare, possiamo scrivere la prima query con LINQ To Objects.
//C#
var result = persone.Where(p => p.Eta > 30).Select(p => p);
'VB
Dim result = persone.Where(Function(p as Persona) p.Eta > 30).Select(Function(p as Persona) p)Tramite questo statement, si recuperano gli oggetti Persona che hanno la proprietà età maggiore di 30, e li si mette in una lista.
Questa query introduce altre tre nuove caratteristiche dei linguaggi: la Type Inference, gli Extension Methods e le Lambda Expression.
La Type Inference è una caratteristica che permette al compilatore di capire il tipo di una variabile senza doverlo esplicitamente dichiarare. Questo non ha nulla a che vedere con gli object o il variant del vb6 o il var del javascript, in quando la tipizzazione è sempre mantenuta. Per dichiarare una variabile senza specificarne il tipo, bisogna mettere la parola chiave var al posto del tipo (questo vale per il C#, il VB non ha bisogno di questa caratteristica poiché ha già la Dim). Ovviamente, per mantenere la tipizzazione, nel momento stesso in cui si dichiara la variabile va associato un valore così che il compilatore intuisca il tipo da usare.
Fino ad adesso, per aggiungere metodi ad una classe si è dovuto ricorrere all'ereditarietà. Tramite gli Extension Methods, ora è possibile definire nuovi metodi in una classe esterna ed "attaccarli" ad una classe. Nel caso specifico di questa query, si sono utilizzati gli Extension Method Where e Select dove il primo ha effettuato la ricerca sulla lista, mentre il secondo ha permesso di decidere l'oggetto da ritornare. Per dichiarare un Extension Method in C#, bisogna creare una classe statica e creare al suo interno un metodo statico per ogni Extension Method che si vuole creare. Il metodo deve accettare come primo parametro il tipo da estendere e la dichiarazione deve essere preceduta dalla parola chiave this.
In VB, la sintassi è leggermente diversa, in quanto non si utilizza una classe shared bensì un modulo, i metodi vanno marcati con l'attributo Extension e non esiste nessuna parola chiave da impostare sul primo parametro.
//C#
public static class Enumerable
{
public static IEnumerable Where(this IEnumerable source, Func predicate)
}
'VB
Module Enumerable
<Extension()> _
Public Shared Function Where(Of TSource)(ByVal source As IEnumerable(Of TSource), ByVal predicate As Func(Of TSource, Boolean)) As IEnumerable(Of TSource)
End Class Gli Extension Methods non sono immediatamente visibili, per utilizzarli nel codice bisogna importarli tramite la direttiva using per il C#, Imports per il VB, impostando il namespace della classe che contiene i metodi. A questo punto, quando si dichiara un oggetto nel codice, si vedranno sia i metodi normali che gli Exension Methods.
Le Lambda Expression vanno viste come una estensione agli Anonymous Methods. In realtà, tecnicamente parlando, la cosa è nettamente diversa, ma la funzionalità finale è proprio quella di poter scrivere in maniera molto più semplice e meno verbosa del codice inline. Se si analizza il codice precedente, si nota che non c'è alcuna dichiarazione del parametro di input al metodo Where, poichè questo viene indotto dalla Type Inference. Questo accade perché il metodo Where accetta in input un solo parametro generico (Persona in questo caso) e quindi il compilatore intuisce il tipo dell'oggetto da solo. In C# si usa la sintassi che prevede la sequenza => per dichiarare poi il corpo della lambda expression.
In VB la sintassi è molto meno comoda rispetto al C#, poichè non entra in gioco la Type Inference, ma comunque più compatta rispetto ad un Anonymous Delegate; si deve dichiarare tra parentesi tonde il tipo dell'oggetto in input alla lambda e poi scrivere il codice.
È importante notare, in entrambi i linguaggi, la mancanza della parola chiave return al fine di scrivere la minima quantità di codice.
Anonymous Type
Si supponga ora di voler visualizzare il nome ed il cognome delle persone con più di 30 anni. Sicuramente il codice precedente è valido; tuttavia si può scegliere anche un'altra via cioè quella di farsi restituire un oggetto ad hoc contenente solo le proprietà nome e cognome: questa possibilità è data dagli Anonymous Type. Un Anonymous Type è un tipo che viene dichiarato nel codice senza creare una classe ed il cui nome viene generato dal compilatore. Ovviamente, non avendo un tipo, quando dichiariamo una variabile simile nel codice C# dobbiamo utilizzare la parola chiave var per sfruttare la Type Inference.
//C#
var result = persone.Where(p => p.Eta > 30).Select(p => new { p.Nome, p.Cognome });
'VB
Dim result = persone.Where(Function(p as Persona) p.Eta > 30).Select(Function(p as Persona) New With { .Nome = p.Nome, .Cognome = p.Cognome })A questo punto, per ciclare i dati basta fare un foreach.
//C#
foreach(var item in result){
Console.WriteLine(item.Nome + " " + item.Cognome);
}
'VB
For Each item In result
Console.WriteLine(item + " " + item)
NextGrazie alla Type Inference, il compilatore è in grado di creare una classe con nome e cognome e Visual Studio è in grado di offrire anche l'autocompletion.
Contenuti dell'articolo
- Pagina 1
- Pagina 2
- Pagina 3
- Pagina 4
- Pagina 5
Aggiungi un nuovo commento »»»
Per inserire un commento, devi registrarti alla nostra community.
Difficoltà
Stampa 
Download 
Pagina 2, paragrafo "Object Initializer":"Se la classe non mette a disposizione un parametro senza costruttori.."forse si intendeva un "..costruttore ...
Continua »»» | Rispondi »»»