C# 3.0 (noto anche con il nome C# Orcas) introduce una serie di estensioni al linguaggio rispetto alla versione attuale. Se nella versione 2.0 l'introduzione dei generics ha rappresentato sicuramente l'aspetto più interessante e innovativo, nella versione 3.0 la parte del leone la fa certamente LINQ, una sintassi integrata nel linguaggio per comporre query su collezioni di dati in modo simile a quello con cui è possibile eseguire interrogazioni utilizzando il linguaggio SQL in ambito database. Le novità di C# 3.0 peraltro non si limitano a LINQ, anche se alcune di esse sono comunque direttamente o indirettamente collegate a LINQ.

Possiamo riassumere le novità di C # 3.0 di seguito:

• proprietà automatiche, ovvero un nuovo modo per dichiarare in forma compatta le proprietà di una classe;
• variabili locali tipizzate implicitamente sfruttando la type inference, ovvero la capacità di ricavare il tipo della variabile dall'espressione di inizializzazione;
• array tipizzati implicitamente sfruttando la type inference in funzione dell'inizializzazione dell'array;
• inizializzatori di oggetti e collezioni per facilitare la valorizzazione rispettivamente delle proprietà di una classe durante la creazione dell'istanza e degli elementi appartenenti alla collezione;
• anonymous types, ovvero la possibilità di utilizzare l'operatore new su una variabile tipizzata implicitamente per istanziare un tipo generato automaticamente dal compilatore;
• extension methods, ovvero la possibilità di aggiungere metodi a classi preesistenti, estendendo le funzionalità del tipo di riferimento;
• lambda expressions, ovvero un nuovo tipo di espressione basata sull'operatore => equivalente agli anonymous methods di C# 2.0 (delegati);
• query expressions (LINQ), ovvero espressioni finalizzate ad eseguire interrogazioni su oggetti in modo analago a quanto si fa con SQL o XQuery;
• expression trees, che consentono alle lambda espressions di essere rappresentate come dati piuttosto che come codice.

L'articolo si concentra sulle novità di C# 3.0 diverse da LINQ (che merita una trattazione a parte), fornendo utili esempi per facilitare la comprensione dei concetti esposti e degli aspetti di sintassi. Per approfondire LINQ e le query expressions si rimanda all'articolo specifico dedicato all'argomento.

Proprietà automatiche

C# 3.0 introduce un modo alternativo rispetto a quanto siamo abituati a fare oggi per dichiarare le proprietà all'interno di una classe. Si tratta di una modalità di dichiarazione molto compatta che ci permette di evitare di dover dichiarare esplicitamente il campo privato reso accessibile tramite la proprietà e di dover implementare gli accessor in scrittura e lettura. In questo nuovo tipo di dichiarazione è il compilatore che fa il lavoro sporco, creando dietro le quinte sia il campo privato, sia il contenuto di default delle operazioni set/get della proprietà.

L'esempio mostra un semplice caso di utilizzo della nuova sintassi nella definizione di una entità costituita unicamente da proprietà.

public class Contact
{
  public int ID { get; set; }
  public string FirstName { get; set; }
  public string LastName { get; set; }
  public string PhoneNumber { get; set; }
  public string EmailAddress { get; set; }
}

L'estratto di codice appena visto è in tutto e per tutto equivalente all'esempio riportato di seguito. Si noti perlatro come nel primo caso la compattezza e l'essenzialità del codice siano molto maggiori, con un conseguente miglioramento della leggibilità.

public class Contact
{
  private int _id;
  private string _firstName;
  private string _lastName;
  private string _phoneNumber;
  private string _emailAddress;

  public int ID
  {
    get { return _id; }
    set { _id = value; }
  }

  public string FirstName
  {
    get { return _firstName; }
    set { _firstName = value; }
  }

  public string LastName
  {
    get { return _lastName; }
    set { _lastName = value; }
  }

  public string PhoneNumber
  {
    get { return _phoneNumber; }
    set { _phoneNumber = value; }
  }

  public string EmailAddress
  {
    get { return _emailAddress; }
    set { _emailAddress = value; }
  }
}

Variabili locali tipizzate implicitamente

Nella dichiarazione di una variabile locale tipizzata implicitamente il tipo della variabile viene ricavato dall'espressione usata per l'inizializzazione (type inference). Questo tipo di dichiarazione richiede l'uso della parola chiave var da inserire al posto del tipo della variabile da inizializzare.

La type inference può essere applicata sia nel caso di variabili il cui tipo è di valore (tipi primitivi e strutture), sia nel caso di variabili il cui tipo è di riferimento (classi). Affinchè sia possibile ricavare il tipo, la dichiarazione deve includere obbligatoriamente un'espressione di inizializzazione. Nel caso dei tipi di riferimento non è ammessa l'inizializzazione a null, ma solo ad istanze di classi.

L'esempio seguente mostra alcuni casi di utilizzo.

var i = 1; // Equivale a int i = 1;
var s = "Riccardo"; // Equivale a string s = "Riccardo";
var a = new int[] {1, 2, 3}; // Equivale a int[] a = ...;
var c = new Contact(); // Equivale a Contact c = new Contact();

var x; // Errore
var y = null; // Errore

Contact c1;
var c2 = c1; // Errore
var c3 = c; // OK