Cenni preliminari sul controllo server Web LinqDataSource

Aggiornamento: novembre 2007

Il controllo LinqDataSource espone LINQ (Language-Integrated Query) agli sviluppatori Web tramite l'architettura del controllo origine dati di ASP.NET. LINQ fornisce un modello di programmazione unificato per l'esecuzione di query e l'aggiornamento dei dati da tipi diversi di origini dati e estende le funzionalità correlate ai dati direttamente nei linguaggi C# e Visual Basic. LINQ semplifica l'interazione tra programmazione orientata a oggetti e dati relazionali mediante l'applicazione dei principi della programmazione orientata a oggetti ai dati relazionali. Per ulteriori informazioni su LINQ, vedere LINQ (Language-Integrated Query).

Utilizzando il markup dichiarativo, è possibile creare un controllo LinqDataSource che si connette ai dati da un database o da una raccolta di dati in memoria, ad esempio una matrice. Nel testo dichiarativo è possibile scrivere tutte le condizioni necessarie per recuperare, filtrare, ordinare e raggruppare i dati. Quando si recuperano dati da una tabella del database SQL, è inoltre possibile configurare un controllo LinqDataSource per gestire l'aggiornamento, l'inserimento e l'eliminazione dei dati. Il controllo esegue le attività senza che sia necessario scrivere i relativi comandi SQL. La classe LinqDataSource fornisce inoltre un modello di eventi che consente di gestire scenari personalizzati.

Vengono illustrati i seguenti argomenti:

• Scenari

• Background

• Esempi di codice

• Riferimento alle classi

Scenari

Il controllo LinqDataSource viene utilizzato quando si crea una pagina Web che recupera o modifica dati e si desidera trarre vantaggio dal modello di programmazione unificato fornito da LINQ. È possibile semplificare il codice in una pagina Web consentendo al controllo LinqDataSource di creare automaticamente i comandi per l'interazione con i dati.

Torna all'inizio

Background

Il controllo LinqDataSource consente di connettere un controllo dati a una vasta gamma di origini dati, tra cui dati del database, classi dell'origine dati e raccolte in memoria. Il controllo LinqDataSource consente di specificare attività di recupero simili a quelle del database (selezione, filtro, raggruppamento e ordinamento) da eseguire su tutti questi tipi di origini dati. È possibile specificare attività di modifica (aggiornamento, eliminazione e inserimento) da eseguire su tabelle di database.

È possibile connettere il controllo LinqDataSource a qualsiasi tipo di raccolta dati archiviata in una proprietà o un campo pubblico. Il markup dichiarativo e il codice per eseguire operazioni sui dati sono gli stessi per tutte le origini dati. Non è necessario utilizzare sintassi diversa quando si interagisce con i dati di una tabella di database o di una raccolta dati, ad esempio una matrice.

Per un'introduzione al controllo LinqDataSource, vedere Procedura dettagliata: recupero, aggiornamento, inserimento ed eliminazione di dati con i controlli LinqDataSource e DetailsView.

Connessione ai dati di un database

Quando si interagisce con i dati di un database, non si connette il controllo LinqDataSource direttamente al database. Si interagisce invece con classi di entità che rappresentano il database e le tabelle. È possibile generare le classi di entità tramite Object Relational Designer o eseguendo l'utilità SqlMetal.exe. Per ulteriori informazioni, vedere Progettazione relazionale oggetti o Strumento per la generazione del codice (SqlMetal.exe). Le classi di entità create sono in genere reperibili nella cartella App_Code dell'applicazione Web. O/R Designer o l'utilità SqlMetal.exe genererà una classe che rappresenta il database e una classe per ogni tabella del database.

La classe che rappresenta il database è responsabile del recupero e dell'impostazione dei valori nell'origine dati. Il controllo LinqDataSource legge e imposta le proprietà nella classe che rappresenta la tabella dati. Per supportare le operazioni di aggiornamento, inserimento ed eliminazione, la classe del database deve derivare dalla classe DataContext e la classe della tabella deve fare riferimento a una classe Table<TEntity>.

Per connettere il controllo LinqDataSource a una classe di database, è necessario impostare la proprietà ContextTypeName sul nome della classe che rappresenta il database. Per connettere invece il controllo LinqDataSource a una determinata tabella, è necessario impostare la proprietà TableName sul nome della classe che rappresenta la tabella dati. Ad esempio, per connettersi alla tabella Contacts del database AdventureWorks, è necessario impostare la proprietà ContextTypeName su AdventureWorksDataContext o su qualsiasi altro nome specificato per l'oggetto di database. È quindi necessario impostare la proprietà TableName su Contacts. Nell'esempio seguente è illustrato il markup per un controllo LinqDataSource che si connette al database AdventureWorks.

<asp:LinqDataSource 
    ContextTypeName="AdventureWorksDataContext" 
    TableName="Contacts" 
    ID="LinqDataSource1" 
    >
</asp:LinqDataSource>

Nell'esempio non è indicata la classe generata da O/R Designer perché il codice generato è troppo lungo per questo argomento. Il codice generato deve tuttavia esistere per garantire il corretto funzionamento dell'esempio. Per ulteriori informazioni, vedere Generazione di codice in LINQ to SQL.

Connessione ai dati da una raccolta in memoria

Per connettersi alla raccolta dati in memoria, ad esempio una matrice, è necessario impostare la proprietà ContextTypeName sul nome della classe che contiene la raccolta. In particolare, è necessario impostare la proprietà TableName sul nome della raccolta stessa.

Nell'esempio seguente è illustrata una classe contenente una matrice di valori stringa.

Public Class MovieLibrary
    Dim _availableGenres() As String = {"Comedy", "Drama", "Romance"}

    Public ReadOnly Property AvailableGenres() As String()
        Get
            Return _availableGenres
        End Get
    End Property

End Class

public class MovieLibrary
{
    string[] _availableGenres = { "Comedy", "Drama", "Romance" };

    public MovieLibrary()
    {
    }

    public string[] AvailableGenres
    {
        get
        {
            return _availableGenres;
        }
    }
}

Nell'esempio seguente è illustrato un controllo LinqDataSource che legge l'elenco di generi cinematografici dalla classe dell'esempio precedente. Per recuperare la matrice di generi, è necessario impostare la proprietà ContextTypeName su MovieLibrary e la proprietà TableName su AvailableGenres.

<asp:LinqDataSource 
    ContextTypeName="MovieLibrary" 
    TableName="AvailableGenres" 
    ID="LinqDataSource1" 
    >
</asp:LinqDataSource>

Utilizzo del controllo LinqDataSource con controlli con associazione a dati

Per visualizzare i dati di un controllo LinqDataSource, è possibile associare un controllo con associazione a dati al controllo LinqDataSource. Ad esempio, è possibile associare un controllo DetailsView, GridView o ListView a un controllo LinqDataSource. A tale scopo, impostare la proprietà DataSourceID del controllo con associazione a dati all'ID del controllo LinqDataSource. Nell'esempio seguente è illustrato un controllo GridView che visualizza tutti i dati di un controllo LinqDataSource.

<asp:LinqDataSource 
    
    ContextTypeName="AdventureWorksDataContext" 
    TableName="Contacts" 
    ID="LinqDataSource1">
</asp:LinqDataSource>
<asp:GridView 
    ID="GridView1" 
    
    DataSourceID="LinqDataSource1" >
</asp:GridView>

Il controllo con associazione a dati crea automaticamente l'interfaccia utente per visualizzare i dati del controllo LinqDataSource. Può inoltre fornire l'interfaccia per l'ordinamento e il paging dei dati. Quando le modifiche dei dati sono attivate, un controllo con associazione a dati fornisce l'interfaccia per l'aggiornamento, l'inserimento e l'eliminazione di record.

Per restringere i dati (proprietà) da visualizzare, è possibile configurare il controllo con associazione a dati in modo da non generare automaticamente i campi del controllo dati. È quindi possibile definire in modo esplicito tali campi nel controllo con associazione a dati. Il controllo LinqDataSource recupera tutte le proprietà, tuttavia il controllo con associazione a dati visualizza solo le proprietà specificate. Nell'esempio seguente è illustrato un controllo GridView che visualizza solo le proprietà Name e StandardCost della tabella Products del database AdventureWorks. La proprietà AutoGenerateColumns è impostata su false.

<asp:LinqDataSource 
    ContextTypeName="AdventureWorksDataContext" 
    TableName="Products" 
    ID="LinqDataSource1" 
    >
</asp:LinqDataSource>
<asp:GridView 
    DataSourceID="LinqDataSource1" 
    AutoGenerateColumns="false"
    ID="GridView1" 
    >
    <Columns>
        <asp:BoundField DataField="Name" />
        <asp:BoundField DataField="StandardCost" />
    </Columns>
</asp:GridView>

Se è necessario restringere il numero di proprietà restituite nella query, è possibile definire tali proprietà impostando la proprietà Select del controllo LinqDataSource.

Confronto tra LinqDataSource Controllo e altri controlli origine dati

Il controllo LinqDataSource consente di scrivere una minor quantità di codice per eseguire operazioni sui dati rispetto a quando si utilizza il controllo SqlDataSource o ObjectDataSource. Il controllo LinqDataSource può dedurre informazioni sull'origine dati cui eseguire la connessione e creare dinamicamente i comandi per la selezione, l'aggiornamento, l'inserimento e l'eliminazione dei dati. Quando si utilizza il controllo LinqDataSource, è inoltre necessario imparare a utilizzare un unico modello di programmazione per interagire con tipi diversi di origini dati.

Confronto con il controllo SqlDataSource

A differenza del controllo SqlDataSource, che viene utilizzato solo con le tabelle di database relazionali, il controllo LinqDataSource consente di connettersi ai dati archiviati nelle raccolte in memoria. Quando si utilizza il controllo SqlDataSource, è necessario impostare in modo esplicito le proprietà SelectCommand, UpdateCommand, InsertCommande DeleteCommand su query SQL. Con il controllo LinqDataSource non è tuttavia necessario impostare in modo esplicito questi comandi, perché il controllo LinqDataSource utilizza LINQ to SQL per crearli automaticamente. Se si desidera modificare le colonne da selezionare in un'origine dati, non è necessario scrivere un comando SQL Select completo. È invece sufficiente specificare nella proprietà Select i nomi delle colonne che si desidera vengano restituite nella query.

Quando si aggiornano o si inseriscono dati, non è necessario creare parametri per ogni valore che verrà salvato nel database. Il controllo LinqDataSource può creare comandi di aggiornamento che includono i valori adatti mettendo in corrispondenza la proprietà DataField con i nomi di proprietà della classe di entità.

Confronto con il controllo ObjectDataSource

Quando si utilizza il controllo ObjectDataSource, è necessario creare manualmente l'oggetto che rappresenta i dati e quindi scrivere i metodi per l'interazione con i dati. È quindi necessario mettere in corrispondenza le proprietà SelectMethod, UpdateMethod, InsertMethod e DeleteMethod con i metodi che eseguono tali funzioni. Nel controllo LinqDataSource viene utilizzato O/R Designer per creare automaticamente le classi che rappresentano i dati. Non è necessario scrivere apposito codice per specificare le colonne esistenti nella tabella di database o le modalità di selezione, aggiornamento, inserimento ed eliminazione dei dati. È inoltre possibile utilizzare il controllo LinqDataSource per interagire direttamente con una raccolta dati, ad esempio una matrice. In tal caso, non è necessario creare una classe per gestire il codice per l'interazione con la raccolta dati.

Selezione dei dati

Se non si specifica un valore per la proprietà Select del controllo LinqDataSource, verranno recuperate tutte le proprietà della classe di origine dati. Ad esempio, il controllo LinqDataSource restituisce un valore per ogni colonna di una tabella di database.

È possibile restringere il numero delle proprietà recuperate dall'origine dati impostando la proprietà Select sui nomi delle proprietà desiderate. Se si desidera che venga restituita una sola proprietà, impostare la proprietà Select su tale proprietà. Ad esempio, per fare in modo che vengano restituiti solo i valori della colonna City di una tabella di database, impostare la proprietà Select su City. Il controllo LinqDataSource restituirà una raccolta List<T> che contiene elementi della proprietà correttamente tipizzati. Se il tipo della proprietà City è testo (stringa), quando si seleziona la proprietà City, verrà restituita una raccolta List<T> di valori stringa.

Per recuperare solo alcune delle proprietà della classe di dati, utilizzare la funzione new nella proprietà Select e specificare le colonne da restituire. La funzione new è obbligatoria perché si intende creare dinamicamente una classe contenente solo le proprietà specificate. Ad esempio, se si desidera recuperare le proprietà City e PostalCode da un'origine dati che contiene indirizzi completi, impostare la proprietà Select su new(City, PostalCode). Il controllo LinqDataSource restituirà una raccolta List<T> contenente le istanze di una classe che include tali proprietà.

Non è necessario utilizzare la funzione new quando si seleziona una sola proprietà, perché l'oggetto restituito è una semplice raccolta di valori relativi a tale proprietà. Se si selezionano più proprietà, tuttavia, il controllo LinqDataSource deve creare una nuova classe che include le proprietà specificate.

Calcolo dei valori con la clausola Select

È possibile calcolare valori in una clausola Select. Ad esempio, per calcolare un totale delle voci di un ordine, impostare la proprietà Select su new(SalesOrderDetailID, OrderQty * UnitPrice As LineItemTotal). La parola chiave As consente di assegnare un nome (alias) al valore calcolato. Per ulteriori informazioni, vedere Procedura dettagliata: selezione e applicazione di filtri a un sottoinsieme di dati con i controlli LinqDataSource e GridView.

Nell'esempio seguente viene spiegato come utilizzare un controllo LinqDataSource per recuperare un sottoinsieme di dati. Nell'esempio viene impostata la proprietà Select per assegnare un alias ai valori restituiti e calcolare un valore.

<asp:LinqDataSource 
    ContextTypeName="ExampleDataContext" 
    TableName="OrderDetails" 
    Select="new(SalesOrderDetailID As DetailID, 
      OrderQty * UnitPrice As LineItemTotal, 
      DateCreated As SaleDate)"
    ID="LinqDataSource1" 
    >
</asp:LinqDataSource>

Filtro dei dati con la clausola Where

È possibile filtrare i dati restituiti in modo da recuperare solo i record che soddisfano particolari criteri. Per eseguire tale operazione, impostare la proprietà Where sulle condizioni che devono essere soddisfatte affinché un record possa essere incluso nei dati restituiti. Se non si specifica un valore per la proprietà Where, verranno recuperati tutti i record dell'origine dati. Per filtrare i dati, è possibile creare un'espressione di filtro, in cui viene utilizzato un confronto per determinare se includere un record. Per il confronto è possibile utilizzare un valore statico o un valore variabile specificato con un segnaposto di parametro.

Creazione di una clausola Where con valori statici

Quando si confronta il valore di una proprietà con un valore statico, si definisce la proprietà Where utilizzando la proprietà e il valore statico. Ad esempio, per fare in modo che vengano restituiti solo i record il cui valore ListPrice è maggiore di 1000, impostare la proprietà Where su ListPrice > 1000.

È possibile utilizzare l'operatore && o and per l'AND logico e l'operatore || o or per l'OR logico. Ad esempio, impostare la proprietà Where su ListPrice > 1000 || UnitCost > 500 || DaysToManufacture > 3 per fare in modo che vengano restituiti record con un valore ListPrice maggiore di 1000, un valore UnitCost maggiore di 500 o un valore DaysToManufacture maggiore di 3. Per specificare che un record può essere restituito solo se tutte le condizioni sono true, impostare la proprietà Where su ListPrice > 1000 && UnitCost > 500 && DaysToManufacture > 3.

Quando si confrontano valori stringa, è necessario racchiudere le condizioni tra virgolette singole e il valore letterale tra virgolette doppie. Ad esempio, impostare la proprietà Where su 'Category = "Sports"' per recuperare solo i record in cui il valore della colonna Category è uguale a "Sports".

Nell'esempio seguente è illustrato un controllo LinqDataSource che recupera dati filtrati sia in base a un valore stringa che a un valore numerico.

<asp:LinqDataSource
  ContextTypeName="ExampleDataContext"
  TableName="Product"
  Where='Category = "Sports" && Weight < 10'
  ID="LinqDataSource1"
  
</asp:LinqDataSource>

Creazione di una clausola Where con parametri

Se si desidera confrontare un valore di proprietà con un valore noto solo in fase di esecuzione, definire un parametro nella raccolta di proprietà WhereParameters. Ad esempio, se si desidera filtrare utilizzando un valore fornito dall'utente, creare un parametro che rappresenta tale valore. Il controllo LinqDataSource crea la clausola Where con il valore corrente del parametro.

Nell'esempio seguente viene illustrato un controllo LinqDataSource che recupera dati in base alla selezione dell'utente in un controllo denominato DropDownList1.

<asp:DropDownList AutoPostBack="true" ID="DropDownList1" >
  <asp:ListItem Value="Sports">Sports</asp:ListItem>
  <asp:ListItem Value="Garden">Garden</asp:ListItem>
  <asp:ListItem Value="Auto">Auto</asp:ListItem>
</asp:DropDownList>
<asp:LinqDataSource 
    ContextTypeName="ExampleDataContext" 
    TableName="Products" 
    AutoGenerateWhereClause="true"
    ID="LinqDataSource1" 
    >
  <WhereParameters>
    <asp:ControlParameter 
      Name="Category" 
      ControlID="DropDownList1" 
      Type="String" />
  </WhereParameters>
</asp:LinqDataSource>
<asp:GridView 
    DataSourceID="LinqDataSource1"
    ID="GridView1" 
    >
</asp:GridView>

Il controllo LinqDataSource crea automaticamente la clausola Where quando la proprietà AutoGenerateWhereClause viene impostata su true. Questa opzione risulta utile quando sono presenti più parametri, perché non è necessario specificare ogni condizione nella proprietà Where. È infatti sufficiente aggiungere i parametri nella raccolta di proprietà WhereParameters per fare in modo che il controllo LinqDataSource crei una clausola Where che include i singoli parametri.

Quando si imposta la proprietà AutoGenerateWhereClause su true, il nome dei parametri deve corrispondere a quello delle proprietà corrispondenti. Ad esempio, per verificare il valore di un parametro rispetto alla proprietà Category, è necessario che il nome del parametro sia Category. Tutti i confronti consentono di verificare l'uguaglianza dei dati. Non è possibile verificare se un valore è maggiore o minore del valore del parametro. Quando si specifica più di un parametro nella raccolta WhereParameters, i parametri vengono collegati con un AND logico.

Se è necessario verificare condizioni di disuguaglianza o di collegamento con un OR logico, impostare la proprietà AutoGenerateWhereClause su false. Sarà quindi possibile definire le condizioni nella proprietà Where. Includere un segnaposto nella proprietà Where per ogni parametro.

Nell'esempio seguente viene illustrato come verificare la disuguaglianza quando si filtrano i dati.

<asp:DropDownList 
    AutoPostBack="true" 
    ID="DropDownList1" 
    >
  <asp:ListItem Value="0">0</asp:ListItem>
  <asp:ListItem Value="25">25</asp:ListItem>
  <asp:ListItem Value="100">100</asp:ListItem>
  <asp:ListItem Value="400">400</asp:ListItem>
</asp:DropDownList>
<asp:LinqDataSource 
    ContextTypeName="ExampleDataContext" 
    TableName="Products" 
    Where="Price > @UserPrice"
    ID="LinqDataSource1" 
    >
  <WhereParameters>
    <asp:ControlParameter 
      Name="UserPrice" 
      DefaultValue="0" 
      ControlID="DropDownList1" 
      Type="Int32" />
  </WhereParameters>
</asp:LinqDataSource>
<asp:GridView 
    DataSourceID="LinqDataSource1"
    ID="GridView1" 
    >
</asp:GridView>

Per ulteriori informazioni, vedere AutoGenerateWhereClause.

Raggruppamento e aggregazione dei dati

È possibile raggruppare i dati per consolidare quelli relativi a record che contengono valori comuni in una o più colonne. A tale scopo, impostare la proprietà GroupBy sul nome delle proprietà che si desidera utilizzare per consolidare i dati. Ad esempio, per raggruppare i record che contengono lo stesso valore per la colonna della città in una tabella che contiene indirizzi, impostare GroupBy su City.

È possibile calcolare valori sui dati raggruppati, ad esempio la media o la somma di una proprietà, utilizzando funzioni di aggregazione combinate alla proprietà GroupBy. Per recuperare i valori utilizzati per il raggruppamento, fare riferimento all'oggetto Key.

Nell'esempio seguente viene illustrato come raggruppare i dati in una proprietà denominata ProductCategory. I valori raggruppati vengono recuperati includendo Key nella proprietà Select. Nella proprietà Select sono inclusi anche i metodi di aggregazione Average e Count.

<asp:LinqDataSource 
  ContextTypeName="ExampleDataContext" 
  TableName="Products" 
  GroupBy="ProductCategory"
  Select="new(Key, 
    Average(ListPrice) As AverageListPrice, 
    Average(Cost) As AverageCost, 
    Count() As RecordCount)"
  ID="LinqDataSource1" 
  >
</asp:LinqDataSource>

È possibile recuperare i singoli record appartenenti a un gruppo utilizzando la parola chiave It. Per ulteriori informazioni, vedere Procedura: raggruppare e aggregare dati mediante il controllo LinqDataSource.

Metodi di aggregazione

Nella tabella seguente sono elencati i metodi di aggregazione disponibili quando si utilizza il controllo LinqDataSource.

• Per ulteriori informazioni, vedere Procedura: raggruppare e aggregare dati mediante il controllo LinqDataSource.

Aggiornamento, inserimento ed eliminazione dei dati

È possibile configurare il controllo LinqDataSource per creare automaticamente i comandi per l'aggiornamento, l'inserimento e l'eliminazione dei dati. Per attivare gli aggiornamenti automatici dei dati, impostare la proprietà EnableUpdate, EnableInsert o EnableDelete su true.

Nota:

Se si desidera che il controllo LinqDataSource generi automaticamente comandi di aggiornamento, non è possibile impostare la proprietà Select. Quando la proprietà Select è impostata, il controllo LinqDataSource restituisce un oggetto che corrisponde a un'istanza di una classe dinamica, ovvero non è un'istanza della classe che rappresenta la tabella di database. La classe dinamica non può pertanto dedurre la modalità di aggiornamento dei valori nella tabella di database.

Se si desidera impostare a livello di codice tutti i valori da aggiornare, è possibile creare gestori eventi per gli eventi Updating, Inserting o Deleting. Nel gestore è possibile impostare un valore prima dell'avvio dell'operazione sui dati. Per ulteriori informazioni, vedere Procedura: aggiornare, inserire ed eliminare dati con il controllo LinqDataSource.

Ordinamento dei dati

Con l'oggetto LinqDataSource è possibile ordinare i dati restituiti da una query in due modi diversi. È possibile ordinare i dati in base a valori statici quando si sviluppa la pagina Web, nonché consentire agli utenti di ordinare dinamicamente i dati in fase di esecuzione.

Per ordinare i dati in base a valori statici, assegnare il nome di una proprietà alla proprietà OrderBy. Per consentire agli utenti di ordinare i dati in fase di esecuzione, impostare la proprietà AutoSort su true (valore predefinito). Passare quindi un'espressione di ordinamento al controllo LinqDataSource. Un controllo con associazione a dati, ad esempio il controllo GridView, passerà un'espressione di ordinamento quando la relativa proprietà AllowSorting è impostata su true.

Per specificare più di un nome di colonna nella proprietà OrderBy, separare i nomi con una virgola. Ad esempio, se si specifica "LastName, FirstName", i record verranno ordinati dapprima in base a LastName, quindi i record che contengono valori corrispondenti nel campo LastName verranno ordinati in base a FirstName.

È possibile utilizzare entrambi i tipi di ordinamento se si desidera che i dati vengano restituiti in un ordine specifico prima di consentire agli utenti di modificare tale ordine. In questo caso impostare la proprietà AutoSort su true e la proprietà OrderBy sul nome di una proprietà.

Nell'esempio seguente è illustrato un controllo LinqDataSource che ordina dapprima i record in base a LastName, poi a FirstName e infine a MiddleName. Il controllo LinqDataSource è inoltre configurato in modo da consentire agli utenti di ordinare dinamicamente le righe. È possibile associare al controllo LinqDataSource un controllo dati, ad esempio il controllo GridView, per visualizzare i dati e consentire agli utenti di specificare un ordinamento.

<asp:LinqDataSource
  ContextTypeName="ExampleDataContext"
  TableName="Contact"
  OrderBy="LastName, FirstName, MiddleName"
  AutoSort="true"
  ID="LinqDataSource1"
  
</asp:LinqDataSource>

Utilizzo di parametri per valutare dinamicamente i valori

Quando si utilizza il controllo LinqDataSource, si utilizzano i parametri per specificare valori che devono essere interpretati o convertiti in fase di esecuzione. A differenza di quando si utilizzano altri controlli origine dati, non è necessario specificare ogni singolo valore incluso nell'operazione di aggiornamento, inserimento o eliminazione. Il controllo LinqDataSource imposta automaticamente tali valori e utilizza LINQ to SQL per generare automaticamente i comandi SQL. I parametri vengono specificati solo per fornire valori predefiniti o per convertire valori vuoti. È inoltre possibile utilizzare le raccolte di parametri WhereParameters e OrderByParameters per ordinare o filtrare i dati in base ai valori in fase di esecuzione. Per ulteriori informazioni su LINQ to SQL, vedere LINQ to SQL.

Il controllo LinqDataSource contiene le seguenti raccolte di parametri:

• DeleteParameters

• GroupByParameters

• InsertParameters

• OrderByParameters

• SelectParameters

• UpdateParameters

• WhereParameters.

Per un esempio relativo all'utilizzo della raccolta WhereParameters per consentire agli utenti di filtrare in modo dinamico i record restituiti da un controllo LinqDataSource, vedere la sezione Filtro dei dati con la clausola Where riportata in precedenza in questo argomento.

Controllo della concorrenza

Quando si consente agli utenti di aggiornare o eliminare dati, è opportuno verificare che i dati dell'origine dati non siano stati modificati da un altro processo prima di procedere con l'aggiornamento o l'eliminazione. Se non si esegue questa verifica, è possibile che i valori impostati da un altro processo vengano sovrascritti accidentalmente e che i dati risultino incoerenti.

Il controllo LinqDataSource consente di determinare se i dati sono stati modificati. Il controllo archivia i valori dei dati originali nello stato di visualizzazione della pagina Web. Quando la pagina Web viene reinserita, conterrà i valori originali ed eventuali valori aggiornati. Il controllo LinqDataSource utilizza LINQ to SQL per confrontare i valori originali con quelli attualmente presenti nell'origine dati. Se i valori sono identici, i dati non sono stati modificati e LINQ to SQL aggiornerà o eliminerà i dati. Se i dati sono stati modificati, LINQ to SQL genererà un'eccezione.

È possibile specificare manualmente i valori della colonna da verificare impostando la proprietà UpdateCheck di una colonna nella classe di entità. Quando O/R Designer genera codice per una tabella di database, imposta la proprietà UpdateCheck su Never per le colonne gestite dal database. Il valore relativo a qualsiasi altra colonna viene impostato su Always, per indicare che viene sempre incluso in un controllo della concorrenza. Impostare la proprietà UpdateCheck su Never per escludere la colonna dal controllo della concorrenza. Quando la proprietà viene impostata su Never, i valori di tale colonna non verranno archiviati nello stato di visualizzazione. Impostare la proprietà UpdateCheck su WhenChanged per verificare il valore in base all'origine dati solo quando l'utente ha modificato il valore.

Se è necessario archiviare dati sensibili nello stato di visualizzazione, è opportuno crittografare lo stato di visualizzazione. Per ulteriori informazioni, vedere Encrypt ViewState in ASP.NET 2.0 (informazioni in lingua inglese).

Nota:
La crittografia dello stato di visualizzazione può influire sulle prestazioni di una pagina Web.

Ottimizzazione dei controlli della concorrenza per dati SQL Server

L'archiviazione di un numero elevato di valori nello stato di visualizzazione può comportare l'incremento delle dimensioni di una pagina Web e la potenziale esposizione di dati sensibili. Se si intende utilizzare dati di un database SQL Server, è possibile ottimizzare prestazioni e sicurezza di una pagina Web creando nel database una colonna contenente un valore di timestamp. SQL Server aggiorna automaticamente una colonna timestamp ogni volta che il record viene modificato. In tal caso il controllo LinqDataSource non dovrà confrontare ogni singola colonna di un record per determinare se il record è stato modificato, ma potrà confrontare solo il timestamp dello stato di visualizzazione con il timestamp del database.

Se si aggiunge una colonna timestamp in un database SQL Server, O/R Designer crea automaticamente la classe di entità°in modo da archiviare solo il timestamp nello stato di visualizzazione. Per ulteriori informazioni, vedere Procedura dettagliata: utilizzo di un timestamp con il controllo LinqDataSource per controllare l'integrità dei dati.

Utilizzo delle stored procedure

Per utilizzare il controllo LinqDataSource per recuperare i dati da una stored procedure, creare un gestore per l’evento Selecting. Nel gestore eventi, chiamare il metodo della classe del contesto dati che rappresenta la stored procedure. Impostare quindi il risultato della stored procedure sulla proprietà Result dell'oggetto LinqDataSourceSelectEventArgs. Se si desidera attivare le operazioni automatiche di inserimento, aggiornamento ed eliminazione, il tipo restituito dal metodo deve corrispondere al tipo specificato nella proprietà TableName.

Nell’esempio seguente viene illustrato come assegnare la proprietà Result all’oggetto restituito dal metodo che rappresenta una stored procedure.

Protected Sub LinqDataSource_Selecting(ByVal sender As Object, _
        ByVal e As LinqDataSourceSelectEventArgs)
    Dim exampleContext As ExampleDataContext = New ExampleDataContext()
    e.Result = exampleContext.GetRegisteredCustomers()
End Sub

protected void LinqDataSource_Selecting(object sender, 
        LinqDataSourceSelectEventArgs e)
{
    ExampleDataContext exampleContext = new ExampleDataContext();
    e.Result = exampleContext.GetRegisteredCustomers();
}

Per ulteriori informazioni sulla creazione di metodi di contesto dati, vedere Procedura: creare metodi DataContext con mapping a stored procedure e funzioni (Progettazione relazionale oggetti).

Convalida di valori durante la modifica dei dati

Prima di modificare un record di dati, potrebbe essere necessario convalidare i valori. In genere si includono i controlli di convalida nella classe di dati anziché nella pagina Web. La centralizzazione dei controlli di convalida nella classe di dati garantisce che vengano utilizzati a prescindere dal modo in cui la classe di dati viene utilizzata. Per ulteriori informazioni sulla modalità di aggiunta della convalida a una classe, vedere Procedura: aggiungere la convalida a classi di entità e Procedura dettagliata: aggiunta della convalida a classi di entità.

Le eccezioni di convalida vengono generate prima che i dati siano aggiornati, inseriti o eliminati. Per recuperare le eccezioni di convalida, è possibile creare gestori per gli eventi Inserting, Updating e Deleting. Per ulteriori informazioni, vedere le classi LinqDataSourceUpdateEventArgs, LinqDataSourceInsertEventArgs e LinqDataSourceDeleteEventArgs.

Eventi del controllo LinqDataSource

Il controllo LinqDataSource genera eventi in punti specifici durante l'elaborazione per consentire la personalizzazione della modalità di selezione, inserimento, aggiornamento o eliminazione dei dati.

Quando seleziona i dati, il controllo LinqDataSource genera i seguenti eventi (nell'ordine indicato):

1. Selecting

2. ContextCreating (se necessario)

3. ContextCreated (se necessario)

4. Selected

5. ContextDisposing

Se si crea l'oggetto di contesto nell'evento Selecting a livello di codice e non è necessario archiviare valori originali nello stato di visualizzazione, gli eventi ContextCreating e ContextCreated verranno ignorati.

Quando aggiorna, inserisce o elimina dati, il controllo LinqDataSource genera i seguenti eventi (nell'ordine indicato):

1. ContextCreating

2. ContextCreated

3. Inserting oppure Updating oppure Deleting

4. Inserted oppure Updated oppure Deleted

5. ContextDisposing

L'ordine degli eventi per le operazioni di aggiornamento, eliminazione e inserimento è diverso rispetto alle operazioni di selezione perché il controllo LinqDataSource deve ottenere un'istanza dell'oggetto dati e deve passare tale istanza all'evento Inserting, Updating o Deleting.

Gli eventi Selecting, Inserting, Updating e Deleting vengono generati prima dell'esecuzione dell'operazione sui dati. Creare gestori per questi eventi per convalidare e modificare i valori prima dell'operazione oppure per annullare l'operazione. Ad esempio, se il database contiene una colonna in cui viene archiviato il nome utente dell'autore dell'ultima modifica apportata a un record, è possibile utilizzare l'evento Updating per impostare il valore relativo al nome utente a livello di codice.

Gli eventi Selected, Inserted, Updated e Deleted vengono generati al termine dell'operazione. Creare gestori eventi per consentire a questi eventi di rilevare eccezioni ed esaminare i valori restituiti dall'operazione.

L'evento ContextCreating viene generato prima che il controllo LinqDataSource crei il tipo specificato nella proprietà ContextTypeName. Gestire questo evento se si desidera creare il tipo di contesto a livello di codice. Ad esempio, è possibile eseguire questa operazione se per il metodo del costruttore del tipo di contesto è necessario specificare parametri. L'evento ContextCreated viene generato dopo la creazione del tipo specificato nella proprietà ContextTypeName. Gestire questo evento per rilevare eccezioni o esaminare l'oggetto di contesto creato. L'evento ContextDisposing viene generato prima che il controllo LinqDataSource elimini il tipo di contesto specificato nella proprietà ContextTypeName. Gestire questo evento per annullare l'eliminazione di un oggetto la cui creazione richiede molto tempo o un numero elevato di risorse. È inoltre possibile utilizzare questo evento per eseguire la pulitura specifica per l'oggetto prima che venga eliminato.

Torna all'inizio

Esempi di codice

Procedura dettagliata: recupero, aggiornamento, inserimento ed eliminazione di dati con i controlli LinqDataSource e DetailsView

Procedura dettagliata: selezione e applicazione di filtri a un sottoinsieme di dati con i controlli LinqDataSource e GridView

Procedura dettagliata: utilizzo di un timestamp con il controllo LinqDataSource per controllare l'integrità dei dati

Procedura: raggruppare e aggregare dati mediante il controllo LinqDataSource

Procedura: aggiornare, inserire ed eliminare dati con il controllo LinqDataSource

Torna all'inizio

Riferimento alle classi

Nella tabella seguente sono elencate le classi principali correlate alla classe LinqDataSource.

Torna all'inizio

Vedere anche

Altre risorse

LINQ (Language-Integrated Query)

LINQ to SQL

Progettazione relazionale oggetti