Stefano ha già parlato delle novità introdotte, ma voglio rendervi partecipi di alcuni dubbi e riflessioni che mi girano in testa. Innanzitutto è possibile scaricare un po' di documentazione ed esempi da qua.

Trovo utile il covariance e il contravariance. Attualmente infatti non è possibile fare questo:

IEnumerable<Strings> strings = ...;
IEnumerable<object> objects = strings;

Anche se in teoria è possibile farlo perché l'argomento generico String eredita da Object e perché sappiano che IEnumerable non permette di modificare la lista. Se infatti fosse possibile avremmo la possibilità tramite la variabile objects di inserire per esempio un intero in una lista di stringhe avendo di conseguenza un errore. In .NET 4.0 tramite le parole chiavi out e in è possibile specificare se l'interfaccia supporta il covariance e il contravariance. Non si tratta quindi di una conversione ma di un modo di riferirsi ad un oggetto in base ad un'inferfaccia o un tipo base (questo era già possibile farlo con i tipi e i delegates). Viceversa la controvariance permette di fare questo:

IComparable<Object> objCom = ...;
IComparable<String> stringCom = objCom;

Questo è possibile perché si può assumere che se un oggetto è in grado di comparare un object è in grado di farlo anche per una stringa. Ovviamente così facendo non è detto che useremo un'implementazione che lavora sui caratteri invece che sull'istanza.

Interessante anche i parametri opzionali e nominali. Si può dichiarare un metodo con dei parametri e indicare direttamente il valore di default. Se non ho capito male, diversamente da VB, il compilatore crea automaticamente gli overload necessari per avere n metodi quanti sono i parametri, chiamando il metodo principale con gli eventuali parametri predefini. Per essere sicuro devo provare Visual Studio 2010 che non ho ancora tra le mani :-).

Infine sciocca un po' vedere C# aggiunto di funzionalità dinamiche. Con la parola chiave dynamic si chiede al compilatore di posticipare la risoluzione delle chiamate ai membri, nella fase di runtime. Infatti in C# 3.0 quando si compila viene emesso l'IL completo di namespace, tipo, membro e parametri per qualificare correttamente la chiamata. Con la parola chiave dynamic, il cui "uso" è simile a var (non ha niente a che fare), si è la possibilità di chiamare qualsiasi membro e di scegliere il più adatto in funzione dell'istanza sulla quale si chiama (potrebbe essere un oggetto COM o managed) e dei parametri e valori di ritorno. Da una parte questo rende C# un po' come Ruby o Python, dall'altra fa un po' stortare il naso perché toglie il controllo a compile time, permettendoci di chiamare anche membri che non esistono.
E' interessante come questo sia possibile grazie ad un'interfaccia IDynamicObject che contiene una serie di membri per impostare o leggere campi, proprietà o effettuare chiamate a metodi. Il compilatore e il runtime lavorano su di essa lasciando il lavoro all'implementazione. L'oggetto predefinito dovrebbe lavorare via reflection e quindi le performance dovrebbero un po' diminuire, ma è indubbio la comodità di questo approccio in certi scenari. Illuminante la demo dove Anders ha usato una propria semplice implementazione dove qualsiasi chiamata a proprietà finiva in un contenitore di valore.

Può piacere o non piacere ma credo che le riflessioni iniziali fatte da Anders siano fondamentali. Abbiamo sempre più bisogno di un linguaggio che sia in parte dichiarativo, dinamico che supporti la programmazione parallela. Ovviamente questi sono in contrasto tra di loro e più descriviamo come fare una cosa più perdiamo cosa fa quel codice, viceversa più descriviamo cosa fare (LINQ) e più ignoriamo come fa. C# 4.0 dovrebbe soddisfare queste isegenze con caratteristiche che andrebbero utilizzate in modo diligente a seconda delle situazioni. Se questo può non dovesse bastare allora si potrà passare ad usare linguaggi specifici: C# per quello che siamo già abituati a fare, Iron[Python|Ruby] per avere dinamicità e magari F# per pensare gli algoritmi in modo diverso.