Mapping dinamico con LINQ to SQL

In questo post vi vorrei mostrare un modo per poter cambiare il mapping di LINQ to SQL in modo da puntare a tabelle differenti ma referenziate allo stesso modo all’interno di un datacontext LINQ to SQL.

Immaginiamo di avere un semplicissimo database (che chiameremo Archivio) con due tabelle assolutamente uguali in struttura:

Creiamo la nostra applicazione di prova (una semplice windows form) e aggiungiamo un modello LINQ 2 SQL (file .dbml).

A questo punto trasciniamo (prendendola dalla finestra Server Explorer) una delle due tabelle (ad esempio la Principale) sul nostro design e cambiamo il nome all’entità generata dal designer chiamandola Tabella

Per poter cambiare al volo il mapping del datacontext è necessario ricavare l’xml che descrive il mapping stesso.

Per fare questo possiamo ricorrere all’utility SQLMetal.exe (la stessa che Visual Studio utilizza per generare il dbml) da riga di comando.

Nel nostro caso eseguiamo il seguente comando:

sqlmetal.exe /map:Archivio.map ArchivioDataClasses.dbml /code:Archivio.vb /language:VB

Lo switch /map permette di generare in maniera separata il file di mapping e il file della classe corrispondente:

1. <?xml version="1.0" encoding="utf-8"?>
2. <Database Name="Archivio" xmlns="http://schemas.microsoft.com/linqtosql/mapping/2007">
3.   <Table Name="dbo.Principale" Member="Tabellas">
4.     <Type Name="Tabella">
5.       <Column Name="Id" Member="Id" Storage="_Id" DbType="Int NOT NULL IDENTITY" IsPrimaryKey="true" IsDbGenerated="true" AutoSync="OnInsert" />
6.       <Column Name="Descrizione" Member="Descrizione" Storage="_Descrizione" DbType="NVarChar(100) NOT NULL" CanBeNull="false" />
7.     </Type>
8.   </Table>
9.   <Function Name="dbo.GetAllTables" Method="GetAllTables">
10.     <ElementType Name="GetAllTablesResult">
11.       <Column Name="NomeTabella" Member="NomeTabella" Storage="_NomeTabella" DbType="VarChar(14) NOT NULL" CanBeNull="false" />
12.       <Column Name="DescrizioneTabella" Member="DescrizioneTabella" Storage="_DescrizioneTabella" DbType="VarChar(18) NOT NULL" CanBeNull="false" />
13.     </ElementType>
14.   </Function>
15. </Database>

Se apriamo il file VB generato vedremo la presenza delle stesse classi generate dal designer di LINQ 2 SQL ma depurate degli attributi di mapping.

Il nodo <Table>, del precedente XML, riporta il mapping relativo alla tabella Principale. Nel file è presente anche una Stored Procedure che ci servirà per recuperare l’elenco delle tabelle su cui eseguire il mapping dinamico.

Il trucco per poter cambiare il mapping dinamicamente passa proprio da questo xml.

E’ possibile, infatti, creare il datacontext per l’accesso alla banca dati utilizzando il costruttore prevede come argomenti la stringa di connessione e un oggetto di tipo MappingSource. In particolare possiamo utilizzare un XmlMappingSource creato con l’XML di cui sopra opportunamente modificato. Normalmente quando istanziamo il datacontext senza modificare il mapping ma utilizzando quello generato dal designer, lo stesso datacontext utilizza come tipologia di mapping la classe AttributeMappingSource.

Per esemplificare il discorso, creiamo nella nostra applicazione una classe composta di metodi  e proprietà statiche (una classe utility) che ci consente di creare il mapping XML al “volo”.

1. Public NotInheritable Class ConfigurationData
2.     Private Sub New()
3.  
4.     End Sub
5.  
6.     Public Shared ReadOnly Property ConnectionString As String
7.         Get
8.             Dim connString = Configuration.ConfigurationManager.ConnectionStrings("LINQ2SQLDynamicMapping.My.MySettings.ArchivioConnectionString")
9.             If connString Is Nothing Then
10.                 Return Nothing
11.             Else
12.                 Return connString.ConnectionString
13.             End If
14.         End Get
15.     End Property
16.  
17.     Public Shared Function GetMapData(ByVal nomeTabella As String) As String
18.         Dim xml = <?xml version="1.0" encoding="utf-8"?>
19.                   <Database Name="Archivio" xmlns="http://schemas.microsoft.com/linqtosql/mapping/2007">
20.                       <Table Name=<%= nomeTabella %> Member="Tabellas">
21.                           <Type Name="Tabella">
22.                               <Column Name="Id" Member="Id" Storage="_Id" DbType="Int NOT NULL IDENTITY" IsPrimaryKey="true" IsDbGenerated="true" AutoSync="OnInsert"/>
23.                               <Column Name="Descrizione" Member="Descrizione" Storage="_Descrizione" DbType="NVarChar(100) NOT NULL" CanBeNull="false"/>
24.                           </Type>
25.                       </Table>
26.                   </Database>
27.         Return Xml.ToString()
28.     End Function
29.  
30. End Class

La proprietà ConnectionString è stata creata per incapsulare la lettura del file di configurazione (ci servirà nel costruttore del datacontext) mentre il metodo GetMapData() genera la stringa XML necessaria al mapping (depurata della stored procedure che non ci serve per l’accesso alla tabelle di archivio).

In questo modo possiamo cambiare il mapping utilizzando il seguente pezzo di codice:

1. Dim connectionString = ConfigurationData.ConnectionString
2. Dim mappingSource = XmlMappingSource.FromXml(ConfigurationData.GetMapData(nomeTabella))
3. Using dc As New ArchivioDataContext(connectionString, mappingSource)
4.     ' Accesso ai dati con il nuovo mapping
5.     '
6. End Using

L’applicazione demo riportata in allegato prevede una combo riempita con i dati recuperati dalla stored procedure di cui sopra (e sta a simulare il fatto che tali tabelle potrebbero cambiare nel tempo e che i loro nomi potrebbero arrivare da una fonte esterna), un tasto per recuperare effettivamente i dati e una griglia per la visualizzazione:

Quando si preme il pulsante, semplicemente si esegue il codice:

1. Private Sub btnCaricaDati_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btnCaricaDati.Click
2.     Dim nomeTabella = CStr(Me.cmbTabella.SelectedValue)
3.     Dim connectionString = ConfigurationData.ConnectionString
4.     Dim mappingSource = XmlMappingSource.FromXml(ConfigurationData.GetMapData(nomeTabella))
5.     Using dc As New ArchivioDataContext(connectionString, mappingSource)
6.         Me.dgvDati.AutoGenerateColumns = True
7.         Me.dgvDati.DataSource = dc.Tabellas
8.     End Using
9. End Sub

La classe XMLMappingSource mette a disposizione anche dei metodi per creare il mapping a partire da un URL (che punta all’XML), da uno stream (per esempio leggendolo da un file) oppure da un lettore XML.

Tutto ciò, unito anche al fatto che, potenzialmente, possiamo modificare l’XML a nostro piacimento (aggiungendo colonne, modificando tipi e così via) fa si che si possano implementare scenari decisamente interessanti di accesso ai dati.

Ultima osservazione importante è che se utilizziamo sempre il mapping dinamico e la classe generata dall’SQLMetal, togliendo dal progetto il dbml, otteniamo che le classi che rappresentano i record della tabella sono di tipo POCO, ovvero non hanno nessun riferimento alla sorgente dati.

Technorati Tag: linq to sql,mapping,table mapping,sqlmetal,mappingsource,xmlmappingsource,attributemappingsourde,poco