Paolo Possanzini

Custom Linq Provider (parte 1)

2008-10-03T11:25:19Z

Diciamo che il rientro dalle ferie è stato più duro del previsto. In questo tempo però ho avuto modo di approfondire alcuni argomenti piuttosto interessanti legati alla programmazione con il framework 3.5 in modo particolare con Linq.

Facendo una veloce ricerca su google possiamo accorgerci che le implementazioni custom di linq stanno crescendo in modo piuttosto veloce. Da quelle per fare le query su Amazon a quelle per cercare documenti in Sharepoint a tutto quello che vi può venire in mente. Questo è possibile perchè la sintassi introdotta con il framework 3.5 e che abbiamo visto utilizzare in LinqtoSql o in LinqtoXml non è legata alla implementazione di alcune librerie di accesso ai dati di Microsoft, ma è un nuovo tipo di sintassi introdotta a livello di linguaggio e supportata da 2 interfaccie che sono presenti nelle librerie base del framework 3.5. Quindi è sufficiente reimplementare le interfaccie di base per rendere i nostri oggetti pienamente compatibili con la sintassi Linq.

L'obiettivo di questo articolo è di comprendere come Linq viene interpretato a livello di compilatore e come viene utilizzato per effettuare ricerche sui dati. Arriveremo anche customizzare il comportamento di Linq per effettuare query su fonti dati non tradizionali. In TeamDev abbiamo seguito questo approccio per estendere le funzionalità del nostro layer di accesso ai dati al fine di sfruttare le interessantissime caratteristiche della sintassi Linq.

Le interfaccie di base

Abbiamo detto che linq si appoggia a due interfaccie :

IEnumerable (presente da tempo nella libreria mscorlib)
IQueryable (introdotta con il framework 3.5 nella libreria System.Core)

queste interfaccie vengono riconosciute dal compilatore e rendono possibile l'utilizzo della sintassi Linq. Comprendere come il compilatore utilizza le interfaccie, aiuta a comprendere come Linq funziona e come possiamo customizzarne il comportamento.

public interface IEnumerable
{
    IEnumerator GetEnumerator();
}

IEnumerable è presente dalla prima implementazione del framework a supporto della sintassi foreach. Possiamo infatti utilizzare il foreach solo sugli oggetti che implementano IEnumerable.
Siccome Linq utilizza IEnumerable per effettuare le query che coinvolgono collection e liste, questo ci lascia intuire che tutti i foreach possono essere trasformati in query Linq.

public interface IQueryable : IEnumerable
{
    Type ElementType { get; }
    Expression Expression { get; }
    IQueryProvider Provider { get; }
}

IQueryable è stata introdotta con la versione 3.5 del framework e si trova in System.Core. L'implementazione di IQueryable permette di customizzare il comportamento della query linq per adattarla ad una sorgente dati particolare.
Mentre le query su oggetti IEnumerable vengono eseguite in memoria , le query su IQueryable possono essere trasformate in query custom su oggetti di ogni tipo.

Tutto questo è possibile grazie alla classe Expression e alla interfaccia IQueryProvider esposte attraverso IQueryable

Come vengono utilizzate le interfaccie

Quando utilizzata con IQueryable, la query linq viene trasformata dal compilatore in un oggetto di tipo Expression (detto anche ExpressionTree , perchè ha una struttra ad albero).
L'oggetto Expression viene passato ad un provider che provvede ad interpretarlo e restituirà un risultato coerente con la query effettuata.

Quando utilizzata con IEnumerable, la query linq viene immediatamente eseguita attraverso degli extension methods che estendono le funzionalità della interfaccia IEnumerable.

E facile intuire quindi che per customizzare il comportamento delle query Linq dobbiamo implementare una delle suddette interfaccie.
Agendo con Reflector ci accorgiamo anche che il modo più corretto per intervenire è utilizzare IQueryable piuttosto che IEnumerable, questo perchè IEnumerable ha lo scopo di effettuare operazioni in memoria, cosa che probabilmente vorremo continuare a fare.

IQueryable invece è pensata per agire fuori dal contesto dell'applicazione e quindi è l'interfaccia che meglio si presta alla realizzazione di provider custom per l'accesso ai dati.

Nel prossimo post vedremo come è strutturata la classe Expression e come creare un parser per tradurre le Expression Tree in tutto ciò che vogliamo.

Book Review: Beginning Web Development, Silverlight, and ASP.NET Ajax

2008-08-22T09:57:00Z

Il libro “Beginning Web Development, Silverlight, and ASP.NET Ajax”, scritto da Laurance Moroney, è una introduzione alla programmazione Web, adatto in modo particolare per chi inizia ad affacciarsi a questo mondo. E’ diviso in 3 parti principali di cui la prima, dopo un capitolo di storia sul mondo web, introduce ai principi dello sviluppo ASP.Net 2.0. Guida passo-passo il principiante a creare la prima applicazione Web, spiegando anche il funzionamento di base di Visual Studio e affrontando progressivamente gli argomenti fondamentali come WebForms, DataBing, WebServices.

Nella seconda parte viene fatta una carrellata delle nuove tecnologie introdotte con la versione 3.0 di Microsoft .Net Framework: Windows Communication Foundation, Windows Presentation Foundation, Windows Workflow Foundation.
Nell’ultima parte viene ripreso l’argomento Web, dove viene illustrata l’evoluzione che ha portato ad Ajax per affrontare infine Silverlight.

Il libro è decisamente introduttivo e getta le basi per ulteriori approfondimenti. Di facile lettura è pienamente comprensibile anche da un programmatore inesperto. Non approfondisce troppo nessun argomento lasciando al lettore la giusta dose di curiosità per ulteriori letture. Una cosa molto importante da sottolineare è la visione di insieme che si ottiene dalla lettura di questo libro dove tutte le tecnologie affrontate trovano il loro giusto posto.

[OT] TS: MS .NET Framework 3.5, ADO .NET Application Development --> Passed

2008-07-23T20:31:00Z

Anche io mi sto dilettando con gli esami in Beta. E proprio questa sera ho saputo di aver passato il 70-561 : TS: MS .NET Framework 3.5, ADO .NET Application Development

Uno snippet per le DependencyProperty su WPF

2008-05-27T07:59:00Z

Mi capita molto spesso di creare DependencyProperty per i miei oggetti da utilizzare con WPF.
Nello snippet base devo sostituire continuamente UIPropertyMetadata con FrameworkElementMetadata, quindi ho deciso di farmi uno snippet gia modificato.

Ve lo allego.
Potete richiamarlo con propdpf

Per installarlo è sufficiente copiare il file nella cartella
C:\Program Files\Microsoft Visual Studio 9.0\VC#\Snippets\1033\NetFX30\

WPF - VS 2008 {Community} Launch - Il Codice della demo

2008-05-12T00:24:00Z

In allegato a questo Post trovate il codice della demo della sessione su WPF utilizzata durante l'evento dell'8 Aprile.

WPF: Costruiamo un RSS Reader passo 4 (ListView)

2008-05-11T21:24:00Z

Riprendiamo la nostra serie di articoli per la costruzione dell'RSS Reader in WPF. Questa è la volta della definizione della ListView.

Iniziamo a creare 2 wrapper che nascondono gli oggetti COM a WPF.
Incorriamo in questo modo in meno problematiche di Binding.

Ecco i due Wrapper

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.Feeds.Interop;
using System.Collections;

namespace WpfRssReader
{
public class myFeed
{
private IFeed _currentFeed;

    public string Copyright
    {
      get { return _currentFeed.Copyright; }
    }

    public string Description
    {
      get { return _currentFeed.Description; }
    }

    public string Image
    {
      get { return _currentFeed.Image; }
    }

    public myFeedItem[] Items
    {
      get
      {
        List<myFeedItem> _items = new List<myFeedItem>();
        foreach (IFeedItem item in (IEnumerable)_currentFeed.Items)
        {
          _items.Add(new myFeedItem() { CurrentFeedItem = item });
        }
        return _items.ToArray();
      }
    }

    public DateTime PubDate
    {
      get { return _currentFeed.PubDate; }
    }

    public string Title
    {
      get { return _currentFeed.Title; }
    }

    public string Url
    {
      get { return _currentFeed.Url; }
    }

    public IFeed CurrentFeed
    {
      get { return _currentFeed; }
      set
      {
        _currentFeed = value;
      }
    }

}
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.Feeds.Interop;

namespace WpfRssReader
{
public class myFeedItem : IFeedItem
{
private IFeedItem _currentFeedItem;

    public IFeedItem CurrentFeedItem
    {
      get { return _currentFeedItem; }
      set { _currentFeedItem = value; }
    }

    public string Author
    {
      get { return _currentFeedItem.Author; }
    }

    public string Comments
    {
      get { return _currentFeedItem.Comments; }
    }

    public string Description
    {
      get { return _currentFeedItem.Description; }
    }

    public string DownloadUrl
    {
      get { return _currentFeedItem.DownloadUrl; }
    }

    public object Enclosure
    {
      get { return _currentFeedItem.Enclosure; }
    }

    public string Guid
    {
      get { return _currentFeedItem.Guid; }
    }

    public bool IsRead
    {
      get
      {
        return _currentFeedItem.IsRead;
      }
      set
      {
        _currentFeedItem.IsRead = value;
      }
    }

    public DateTime LastDownloadTime
    {
      get { return _currentFeedItem.LastDownloadTime; }
    }

    public string Link
    {
      get { return _currentFeedItem.Link; }
    }

    public int LocalId
    {
      get { return _currentFeedItem.LocalId; }
    }

    public DateTime Modified
    {
      get { return _currentFeedItem.Modified; }
    }

    public object Parent
    {
      get { return _currentFeedItem.Parent; }
    }

    public DateTime PubDate
    {
      get { return _currentFeedItem.PubDate; }
    }

    public string Title
    {
      get { return _currentFeedItem.Title; }
    }

    public void Delete()
    {
      _currentFeedItem.Delete();
    }

    public string Xml(FEEDS_XML_INCLUDE_FLAGS includeFlags)
    {
      return _currentFeedItem.Xml(includeFlags);
    }

}
}

Una volta preparate le classi dobbiamo apportare una piccolissima correzione al codice che inserisce il feed all'interno del TAG degli oggetti della TreeView in modo da utilizzare le nuove classi al posto degli oggetti COM che ci restituisce il FeedFolder.

[code language="c#"]

foreach (IFeed feed in ((IFeedsEnum)feedfolder.Feeds))
{
    TreeViewItem tvi = new TreeViewItem()
    {
      Header = feed.Name,
      Tag = new myFeed() { CurrentFeed = feed }                                        // <<<-------- Riga modificata.
    };

// Esegue il download asincrono degli items presenti nel feed
ThreadPool.QueueUserWorkItem(delegate

[/code]

A questo punto facciamo una piccola modifica anche allo xaml ed inseriamo il DataTemplate per la visualizzazione dei feed.

[code language="XML"]

[/code]

Aggiungiamo in fine un elemento Frame che ci permetterà di visualizzazre il contenuto HTML dei posts.

[code language="XML"]

[/code]

In allegato a questo post trovate il progetto completo con le parti sviluppate fino a questo punto.

Nei post futuri vedremo compe personalizzare il layout di quest'applicazione con Blend e come applicare alcuni Effetti che WPF ci permette di realizzare.
Buon divertimento.

WPF: Costruiamo un RSS Reader passo 3 (TreeView)

2008-04-23T12:47:12Z

Inseriamo la TreeView che conterrà la struttura ad albero dei feed sottoscritti.

[code language="XML"]

[/code]

Inseriamo un oggetto di ObjectDataProvider per preparare il Binding.
Utilizziamo il metodo GetFeedSubTree dell'oggetto di tipo FeedHelper per popolare la TreeView

[code language="XML"]

<Window.Resources>
<ObjectDataProvider x:Key="FeedTreeDS" ObjectType="{x:Type rssreader:FeedHelper}" MethodName="GetFeedSubTree" />
</Window.Resources>

[/code]

A questo punto andiamo ad inserire il binding all'interno dell'oggetto TreeView

[code language="XML"]

[/code]

Inseriamo subito anche un'altro Grid che con i controlli necessari a sottoscrivere i feeds, per adesso inseriamo solo due textbox, una per il nome che vogliamo dare al feed ed una per l'uri
Posizioniamo questo nuovo Grid nella prima cella in alto a sinistra.

[code language="XML"]

<Grid Margin="0,0,0,0">
        <Rectangle Fill="#FFFFFFFF" Stroke="#FF000000" RadiusX="4" RadiusY="4" Margin="0,0,0,0"/>
        <TextBox Text="<url>" TextWrapping="Wrap" Margin="8,36,8,0" VerticalAlignment="Top" Name="txtUrl" />
        <TextBox Height="24" Text="<nome>" TextWrapping="Wrap" Margin="8,8,8,0" VerticalAlignment="Top" Name="txtNome" />
        <Button d:LayoutOverrides="Height" x:Name="btnSubscribe" Height="28" Content="Sottoscrivi" Click="btnSubscribe_Click" HorizontalAlignment="Right" Margin="0,0,8,8" VerticalAlignment="Bottom" Width="76"/>
    </Grid>

[/code]

Scriviamo il codice necessario a gestire l'evento Click del bottone che abbiamo inserito.
Il metodo dovrà controllare qual'è il folder selezionato nella Treeview ed inserire la sottoscrizione all'interno di quel folder.
Poi dovrà invocare il metodo FeedHelper.SubscribeFeed

[code language="C#"]

private void btnSubscribe_Click(object sender, RoutedEventArgs e)
{
TreeViewItem tvi = tvFeedsFolders.SelectedItem as TreeViewItem;
if (tvi != null)
{
IFeedFolder folder = null;

    folder = tvi.Tag as IFeedFolder;
    if (folder == null)
    {
      IFeed feed = tvi.Tag as IFeed;
      if (feed != null)
      {
        folder = feed.Parent as IFeedFolder;
      }
    }

if (folder == null)
folder = new FeedsManagerClass().RootFolder as IFeedFolder;

FeedHelper.SubscribeFeed(folder, txtUrl.Text, txtNome.Text);
}
}

[/code]

Ecco il risultato del lavoro svolto fino a questo momento

WPF: Costruiamo un RSS Reader passo 2 (L'interfaccia utente)

2008-04-21T07:30:24Z

Come secondo passo iniziano a creare l'interfaccia utente.

Creiamo un nuovo Windows Forms e lo chiamiamo MainForm.xaml. Ci spostiamo sul file App.xaml e impostiamo StartupUri a MainForm.xaml.
Vediamo come creare la nostra UI. La mia idea iniziale è quella di creare un menù in alto e dividere il resto della UI in due colonne. Quella di sinistra come colonna di controllo, il resto come area di lettura dei feeds.

[code language="XML"]

[/code]

Ho già inserito nella struttura, lo spazio dei nomi dell'applicazione e l'ho chiamata "rssreader".
Dividiamo inoltre il form in due righe, una ad altezza fissa e una ad altezza variabile attraverso i due tag RowDefinition . Inserisco due oggetti per dare al form un leggero stile "Heros".

Inseriamo all'interno del form un nuovo Grid che utilizzeremo come area per il posizionamento dei controlli.
Dividiamo il Grid in righe e colonne. Dimensioniamo le colonne con un rapporto 1 a 3 utilizzando la notazione "*" e creiamo 3 righe.
Una ad altezza fissa e due riproporzionabili.

[code language="XML" ]

[/code]

Questo è il risultato del lavoro fino a questo momento.

WPF: Costruiamo un RSS Reader passo 1 (utilizzare Microsoft.Feeds.dll)

2008-04-19T20:44:00Z

Questo vuole essere il primo di una serie di articoli dedicati alla scrittura di applicazioni complete, dalla A alla Z sviluppate con il Framework 3.5, ponendo particolare attenzione al layer di presentazione attraverso WPF. Come primo esercizio creiamo un RSS reader.

Microsoft ci mette a disposizione una libreria COM per la lettura dei Feed. La utilizzeremo in questo progetto.

Iniziamo.

Creiamo la nostra applicazione con VS2008 e scegliamo WPF Application come tipo di progetto.
Per prima cosa aggiungiamo la reference alla Microsoft.Feeds.dll che possiamo trovare tra i componenti COM.

Creiamo una classe che ci permetta di gestire in modo agevole i feeds. Chiameremo questa classe FeedHelper

[code language="C#"]

public static class FeedHelper
{

    /// <summary>
    /// Get The subtree for RootFolder folder
    /// </summary>
    /// <param name="feedfolder"></param>
    /// <returns></returns>
    [Description("Get The subtree for each folder")]
    public static TreeViewItem[] GetFeedSubTree()
    {
      return GetFeedSubTree((IFeedFolder)(new FeedsManagerClass().RootFolder));
    }

    /// <summary>
    /// Get The subtree for each folder
    /// </summary>
    /// <param name="feedfolder"></param>
    /// <returns></returns>
    [Description("Get The subtree for each folder")]
    public static TreeViewItem[] GetFeedSubTree(IFeedFolder feedfolder)
    {
      try
      {

        // Creiamo una lista di nodi per questo folder
        List<TreeViewItem> result = new List<TreeViewItem>();
        foreach (IFeedFolder folder in ((IFeedsEnum)feedfolder.Subfolders))
        {
          TreeViewItem tvi = new TreeViewItem()
          {
            Header = folder.Name,
            Tag = folder,
            ItemsSource = GetFeedSubTree(folder)
          };
          result.Add(tvi);
        }

        // Creiamo i nodi anche per i feed gia scaricati.
        if (feedfolder.Feeds != null)
        {
          foreach (IFeed feed in ((IFeedsEnum)feedfolder.Feeds))
          {
            TreeViewItem tvi = new TreeViewItem()
            {
              Header = feed.Name,
              Tag = feed
            };

            // Esegue il download asincrono degli items presenti nel feed
            ThreadPool.QueueUserWorkItem(delegate
            {
              try
              {
                feed.Download();
              }
              catch (Exception ex)
              {
                Debug.WriteLine(ex.Message);
              }
            }, null);
            result.Add(tvi);
          }
        }

        return result.ToArray();
      }
      catch (Exception ex)
      {
        Debug.WriteLine(ex.Message);
      }
      return null;
    }

    /// <summary>
    /// Create a Feed in a foder
    /// </summary>
    /// <param name="folder"></param>
    /// <param name="uri"></param>
    /// <param name="name"></param>
    public static void SubscribeFeed(IFeedFolder folder, string uri, string name)
    {
      folder.CreateFeed(name, uri);
    }
}

[/code]

Estenderemo questa classe se necessario in seguito. Per adesso ci basta porre attenzione sui due overloads GetFeedSubTree In questi due metodi viene creato in modo ricorsivo l'albero che descrive i feed sottoscritti eseguendo anche il download dei feed da ogni sottoscrizione. Da notare che non abbiamo bisogno di creare una struttura di storage dei feeds sottoscritti e scaricati. La libreria Microsoft.Feeds si occuperà di tutto per conto nostro.

WPF Performance Tuning

2008-04-17T10:11:21Z

Ho trovato un link utile a chi si diletta nello sviluppo di applicazioni WPF.
Sono riportati tutti gli oggetti WPF che inficiano in qualche modo le performance della nostra applicazione.

Sono riportati anche suggerimenti per migliorare le performances.

http://blogs.msdn.com/wpfsdk/archive/2007/01/15/maximizing-wpf-3d-performance-on-tier-2-hardware.aspx

Vi riporto inoltre il link ai tools di profiling delle performances.

http://msdn2.microsoft.com/en-us/library/aa969767.aspx

Un link per migliorare le nostre animazioni

http://msdn2.microsoft.com/en-us/library/bb613592.aspx

Un link che ci spiega come funziona il Tier della struttura grafica.

http://msdn2.microsoft.com/en-us/library/ms742196.aspx

Ed infine un link per risolvere i problemi dovuti all'interazione con la scheda grafica

http://msdn2.microsoft.com/en-us/library/aa970912.aspx

C# ReaderWriterLock

2008-04-14T17:30:53Z

In .Net quando dobbiamo creare applicazioni multithread siamo soliti utilizzare l'istruzione lock per sincronizzare l'accesso alle risorse condivise.
Questo potrebbe non essere l'approccio più corretto se si eseguono molte letture e poche scritture perchè costringiamo i vari thread ad accedere alla risorsa anche in lettura uno alla volta.

La classe ReaderWriterLock ci aiuta a inserire i lock solo quando necessari e permette accessi multipli in lettura e accessi singoli in scrittura.
Vi rimando ad MSDN per una trattazione dell'argomento più dettagliata.

http://msdn2.microsoft.com/en-us/library/system.threading.readerwriterlock.aspx

http://msdn2.microsoft.com/en-us/magazine/cc163846.aspx

JET4 + .Net + x64 ....

2008-04-01T14:18:02Z

Mi sono trovato ad utilizzare JET4 con .Net e x64...

Diciamo che c'è qualche piccolo problema. Nelle macchine x64 infatti non esiste una versione a 64bit per i drivers JET4 (Per Itanium c'è una versione specifica)
Quindi le nostre applicazioni compilate e ottimizzate per x64 dal compilatore JIT di .Net, non avranno a disposizione tali drivers.

Se non potete fare altrimenti, dovete necessariamente utilizzare la versione a 32bit che è comunque presente nella macchina, ma dobbiamo forzare il compilatore a generare codice x86 e non x64 perdendo tutti i vantaggi dell'architettura x64 per la nostra applicazione. Per fare questo andiamo nelle configurazioni avanzate del progetto e spostiamo la Target CPU da Any a x86.

Buona fortuna.

Esplodere le gerarchie con Linq to SQL

2008-03-06T09:42:00Z

Utilizzando Linq to Sql mi sono reso conto di quanto sia facile ed immediato scrivere codice che intergra all'interno della sintassi di Linq delle chiamate a metodi.
Una delle attività che affronto spesso, è scrivere metodi ricorsivi per manipolare le gerarchie. Con Linq è tutto molto più facile eseguire questa attività da codice, possiamo infatti creare una funzione ricorsiva inserendo all'interno di Linq la chiamata alla funzione che stiamo scrivendo.

Nell'esempio che vi propongo esplodiamo l'organigramma definito nella tabella Employes del database AdventureWorks.

Vediamo subito il codice.

[code language="C#"]

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;

namespace WindowsFormsApplication1
{
public partial class Form1 : Form
{
    /// <summary>
    /// Costruttore del form
    /// </summary>
    public Form1()
    {
      InitializeComponent();

      // Chiamata al metodo per generare la struttura ad albero.
      this.treeView1.Nodes.AddRange(this.GetNodes(0));
    }

    /// <summary>
    /// Metodo per generare la struttura ad albero con Linq
    /// </summary>
    /// <param name="managerid"> Id del manager. 0 se si vuole ottenere ottenere l'albero a partire dal General Manager</param>
    /// <returns></returns>
    private TreeNode[] GetNodes(int managerid)
    {

// DataContext definito con Linq
DbDataContext db = new DbDataContext();

      var result = from empl in db.Employees    // Tabella Employees
                         join cont in db.Contacts on // Join con la tabella Contacts per ricavare il nome degli impiegati
                                empl.ContactID equals cont.ContactID
                        where (managerid == 0 && empl.ManagerID == null) ||      // Verifico se devo cercare il General Manager
                                            empl.ManagerID == managerid                       // Where per ottenere i rami figli del manager passato
                        let node = new TreeNode(empl.EmployeeID.ToString() + " " + cont.LastName, // Utilizzo Let per generare una
                                                                                              // variabile all'interno della query che contiene
                                                                                              // direttamente il TreeNode da inseride nella TreeView
                                          GetNodes(empl.EmployeeID))        // Il TreeNode accetta un array di childs.
                                                                            // Inseriamo una chiamata al metodo che stiamo scrivendo per rendere la
                                                                            // funzione ricorsiva.
                   select node;                                             // Limitiamo la select all'elenco di nodi del ramo corrente.

return result.ToArray(); // Trasformiamo il tutto in un array di TreeNodes
}

}
}

[/code]

Ecco il risultato

Allego il progetto VS2008. Per farlo funzionare vi serve il DB AdventureWorks che potete scaricare dal sito Microsoft.

Una query expression in Linq veramente lunga ed interessante

2008-02-26T14:06:01Z

Vi riporto un link ad un post che potete trovare anche nei link della StartPage di VisualStudio. Sono rimasto senza parole.

http://blogs.msdn.com/lukeh/archive/2007/10/01/taking-linq-to-objects-to-extremes-a-fully-linqified-raytracer.aspx

Nuova area dedicata a Sql Server

2008-02-20T16:10:59Z

Vi segnalo una nuova area dedicata a Tips e Best Practices per SQL Server 2005.

http://dotnetumbria.org/blogs/sql_tips_practices/

Buona lettura.