Quando si parla delle novità del .NET Framework 3.5 non si può non parlare di LINQ. E' innegabile che questa tecnologia sia la novità più importante e che pretenda di cambiare notevolmente la vita agli sviluppatori dato il suo impatto sulla modalità di accesso ai dati, qualsiasi essi siano. Stringhe o file XML, database, entità modellate in classi: tutte queste sorgenti dati diventano interrogabili e modificabili grazie alla sintassi di LINQ.

In questo articolo si parlerà per la maggior parte di "LINQ to SQL" cioè la parte di LINQ che permette, con i provider nativi nel Framework 3.5, il dialogo con database SQL Server (2000, 2005, 2008 ed Express). Altri database potranno essere utilizzati con LINQ quando saranno creati provider appositi (esiste già una versione per MySql, mentre per Oracle c'è una beta al momento della scrittura di questo articolo).

Esempio di LINQ to SQL

Grazie a questa tecnologia, anche uno sviluppatore completamente privo di conoscenza della sintassi SQL potrebbe interrogare un database pur sapendo il meno possibile della struttura presente. Per fare un esempio di come cambia il modo di accedere ad un database, facciamo un paragone tra la modalità di programmazione che sfrutta direttamente ADO.NET e quella che utilizza LINQ. In questo esempio, si recupera il contenuto della tabella "Orders" nel database "Northwind" e lo si mette in una nostra collection.

List<Order> coll = new List<Order>();
using (SqlConnection conn = new SqlConnection(connectionString))
{
  conn.Open();
  using (SqlCommand comm = new SqlCommand("select orderid, orderdate from orders where orderid>1", conn))
  {
    SqlDataReader re = comm.ExecuteReader();
    while (re.Read())
    {
      Order o = new Order();
      o.OrderId = int.Parse(re["orderid"].ToString());
      o.OrderDate = DateTime.Parse(re["orderdate"].ToString());
      coll.Add(o);
    }
  }
}
return coll;

// Linq con C#
DataContext db = new DataContext(connectionString);
Table<Order> res = db.GetTable<Order>();
IQueryable<Order> collx = from c in res where c.OrderId > 1
select new Order
{
  OrderId=c.OrderId,
  OrderDate=c.OrderDate
};
List<Order> coll = collx.ToList<Order>();
return coll;

'LINQ con VB
Dim db As New DataContext(connectionString)
Dim res As Table(of Order) = db.GetTable(of Order)
Dim collx As IQueryable(of Order) =From c In res where c.OrderId > 1 _
Select New Order with { _
  .OrderId=c.OrderId, _
  .OrderDate=c.OrderDate _
}
Dim coll As List(of Order)= collx.ToList ()
Return coll

Utilizzare LINQ to SQL nelle nostre applicazioni

L'esempio riportato nella sezione precedente è molto banale:

• Viene creato un nuovo oggetto "DataContext" - oggetto indispensabile perché crocevia tra la nostra applicazione e la fonte dati
• Viene creato un oggetto "Table" che rappresenterà la tabella nel database
• Nella query specifichiamo quali dati ci interessa recuperare dal database e come questi devono essere esposti una volta ottenuti

Quest'ultimo è un punto importante su cui si fa spesso confusione. La richiesta dati non avviene nel momento in cui si compila la query, bensì quando effettivamente si utilizzano i dati. Nell'esempio, il popolamento dell'array di oggetti "Order" avviene al momento dell'escuzione del metodo ToList sulla variabile collx ottenuta dalla query LINQ e non prima.

Per utilizzare l'esempio, dobbiamo creare una classe che esponga i singoli campi interessati:

using System.Data.Linq.Mapping;
[Table(Name = "Orders")]
public class Order
{
  [Column(Name = "OrderID", DbType = "int")]
  public int OrderId { get; set; }
  [Column(Name = "OrderDate", DbType="datetime")]
  public DateTime OrderDate { get; set; }
  }

Import System.Data.Linq.Mapping;
<Table(Name = "Orders")>
Public Class Order
  <Column(Name = "OrderID", DbType = "int")>
  Public Property OrderId as Integer ?
  <Column(Name = "OrderDate", DbType="datetime")>
  Public OrderDate As DateTime ?
End Class

Gli attributi sono necessari per specificare il mapping della classe sulla tabella nel db. L'attributo Table specifica il collegamento con la tabella mentre Column specifica quello con i campi ed il relativo tipo (necessario solo se il nome della proprietà è differente dal campo all'interno della tabella).