Utilizzo di query parametrizzate con SqlDataSource (C#)

di Scott Mitchell

Scaricare il PDF

In questa esercitazione si continua con l'analisi del controllo SqlDataSource e si apprende come definire query con parametri. I parametri possono essere specificati sia in modo dichiarativo che a livello di codice e possono essere estratti da una serie di posizioni, ad esempio la stringa di query, lo stato della sessione, altri controlli e altro ancora.

Introduzione

Nell'esercitazione precedente abbiamo visto come utilizzare il controllo SqlDataSource per recuperare i dati direttamente da un database. Utilizzando la procedura guidata Configura origine dati, è possibile scegliere il database e quindi: selezionare le colonne da restituire da una tabella o da una vista; inserire un'istruzione SQL personalizzata; oppure utilizzare una stored procedure. Indipendentemente dal fatto che si selezioni colonne da una tabella o da una vista o si immetta un'istruzione SQL personalizzata, alla proprietà del SelectCommand controllo SqlDataSource viene assegnata l'istruzione SQL SELECT ad hoc risultante ed è questa SELECT istruzione che viene eseguita quando viene richiamato il metodo SqlDataSource Select() (a livello di codice o automaticamente da un controllo Web dati).

Le istruzioni SQL SELECT utilizzate nelle demo dell'esercitazione precedente mancavano WHERE di clausole. In un'istruzione SELECT , la WHERE clausola può essere utilizzata per limitare i risultati restituiti. Ad esempio, per visualizzare i nomi dei prodotti che costano più di $ 50,00, potremmo utilizzare la seguente query:

SELECT ProductName
FROM Products
WHERE UnitPrice > 50.00

In genere, i valori utilizzati in una WHERE clausola sono determinati da un'origine esterna, ad esempio un valore querystring, una variabile di sessione o l'input dell'utente da un controllo Web nella pagina. Idealmente, tali input vengono specificati tramite l'uso di parametri. Con Microsoft SQL Server, i parametri sono indicati utilizzando @parameterName, come in:

SELECT ProductName
FROM Products
WHERE UnitPrice > @Price

SqlDataSource supporta query con parametri, sia per le istruzioni che per SELECT le istruzioni , INSERT, andUPDATE.DELETE Inoltre, i valori dei parametri possono essere estratti automaticamente da un'ampia gamma di origini, la stringa di query, lo stato della sessione, i controlli nella pagina e così via, oppure possono essere assegnati a livello di codice. In questa esercitazione verrà illustrato come definire le query con parametri e come specificare i valori dei parametri sia in modo dichiarativo che a livello di codice.

Annotazioni

Nell'esercitazione precedente è stato confrontato ObjectDataSource, che è stato lo strumento preferito nelle prime 46 esercitazioni, con SqlDataSource, notando le somiglianze concettuali. Queste somiglianze si estendono anche ai parametri. I parametri di ObjectDataSource mappati ai parametri di input per i metodi nel livello della logica di business. Con SqlDataSource, i parametri vengono definiti direttamente all'interno della query SQL. Entrambi i controlli dispongono di raccolte di parametri per i relativi Select()metodi , Insert(), Update(), e Delete() possono avere questi valori di parametro popolati da origini predefinite (valori querystring, variabili di sessione e così via) o assegnati a livello di codice.

Creazione di una query con parametri

La procedura guidata Configura origine dati del controllo SqlDataSource offre tre modi per definire il comando da eseguire per recuperare i record del database:

• Selezionando le colonne da una tabella o vista esistente,
• Inserendo un'istruzione SQL personalizzata, oppure
• Scegliendo una stored procedure

Quando si selezionano colonne da una tabella o da una vista esistente, i parametri per la WHERE clausola devono essere specificati tramite la finestra di dialogo Aggiungi WHERE clausola. Quando si crea un'istruzione SQL personalizzata, tuttavia, è possibile inserire i parametri direttamente nella WHERE clausola (utilizzando @parameterName per indicare ogni parametro). Una stored procedure è costituita da una o più istruzioni SQL e queste istruzioni possono essere parametrizzate. I parametri utilizzati nelle istruzioni SQL, tuttavia, devono essere passati come parametri di input alla stored procedure.

Poiché la creazione di una query con parametri dipende dal modo in SelectCommand cui viene specificata l'oggetto SqlDataSource, è possibile esaminare tutti e tre gli approcci. Per iniziare, aprire la ParameterizedQueries.aspx pagina nella SqlDataSource cartella, trascinare un controllo SqlDataSource dalla Casella degli strumenti nella finestra di progettazione e impostarlo ID su Products25BucksAndUnderDataSource. Quindi, fare clic sul collegamento Configura origine dati dallo smart tag del controllo. Selezionare il database da utilizzare (NORTHWINDConnectionString) e fare clic su Avanti.

Passaggio 1: Aggiunta di una clausola WHERE durante la selezione delle colonne da una tabella o da una vista

Quando si selezionano i dati da restituire dal database con il controllo SqlDataSource, la procedura guidata Configura origine dati consente di selezionare semplicemente le colonne da restituire da una tabella o da una vista esistente (vedere la Figura 1). In questo modo viene creata automaticamente un'istruzione SQL SELECT , che viene inviata al database quando viene richiamato il metodo SqlDataSource Select() . Come abbiamo fatto nell'esercitazione precedente, seleziona la tabella Prodotti dall'elenco a discesa e controlla le ProductIDcolonne , ProductName, e UnitPrice .

Figura 1: selezionare le colonne da restituire da una tabella o da una vista (fare clic per visualizzare l'immagine a dimensione intera)

Per includere una WHERE clausola nell'istruzione SELECT , fare clic sul WHERE pulsante che consente di visualizzare la finestra di dialogo Aggiungi WHERE clausola (vedere la Figura 2). Per aggiungere un parametro per limitare i risultati restituiti dalla SELECT query, scegliere innanzitutto la colonna in base alla quale filtrare i dati. Quindi, scegli l'operatore da utilizzare per il filtro (=, <, <= >e così via). Infine, scegliere l'origine del valore s del parametro, ad esempio dalla querystring o dallo stato della sessione. Dopo aver configurato il parametro, fare clic sul pulsante Aggiungi per includerlo nella SELECT query.

Per questo esempio, Restituiamo solo i risultati in cui il UnitPrice valore è minore o uguale a $25,00. Pertanto, selezionare UnitPrice dall'elenco a discesa Colonna e <= dall'elenco a discesa Operatore. Quando si utilizza un valore di parametro hardcoded (ad esempio $25,00) o se il valore del parametro deve essere specificato a livello di codice, selezionare Nessuno dall'elenco a discesa Origine. Successivamente, immettere il valore del parametro hardcoded nella casella di testo Valore 25.00 e completare il processo facendo clic sul pulsante Aggiungi.

Figura 2: Limitare i risultati restituiti dalla finestra di dialogo Aggiungi WHERE clausola (fare clic per visualizzare l'immagine a dimensione intera)

Dopo aver aggiunto il parametro, fare clic su OK per tornare alla procedura guidata Configura origine dati. L'istruzione SELECT nella parte inferiore della procedura guidata dovrebbe ora includere una WHERE clausola con un parametro denominato @UnitPrice:

SELECT [ProductID], [ProductName], [UnitPrice]
FROM [Products]
WHERE ([UnitPrice] <= @UnitPrice)

Annotazioni

Se si specificano più condizioni nella clausola dalla WHERE finestra di dialogo Aggiungi WHERE clausola, la procedura guidata le unisce con l'operatore AND . Se è necessario includere un OR nella WHERE clausola (ad esempio WHERE UnitPrice <= @UnitPrice OR Discontinued = 1), è necessario creare l'istruzione SELECT tramite la schermata dell'istruzione SQL personalizzata.

Completare la configurazione di SqlDataSource (fare clic su Avanti, quindi su Fine) e quindi esaminare il markup dichiarativo di SqlDataSource. Il markup include ora una <SelectParameters> raccolta che indica le origini per i parametri in SelectCommand.

<asp:SqlDataSource ID="Products25BucksAndUnderDataSource" runat="server"
    ConnectionString="<%$ ConnectionStrings:NORTHWNDConnectionString %>"
    SelectCommand=
        "SELECT [ProductID], [ProductName], [UnitPrice]
        FROM [Products] WHERE ([UnitPrice] <= @UnitPrice)">
    <SelectParameters>
        <asp:Parameter DefaultValue="25.00" Name="UnitPrice" Type="Decimal" />
    </SelectParameters>
</asp:SqlDataSource>

Quando viene richiamato il metodo SqlDataSource Select() , il valore del UnitPrice parametro (25.00) viene applicato al @UnitPrice parametro prima SelectCommand di essere inviato al database. Il risultato netto è che solo i Products prodotti inferiori o uguali a $ 25,00 vengono restituiti dalla tabella. Per verificare questa condizione, aggiungi un controllo GridView alla pagina, associalo a questa origine dati e quindi visualizza la pagina tramite un browser. Dovresti vedere solo i prodotti elencati che sono inferiori o uguali a $ 25,00, come conferma la Figura 3.

Figura 3: Vengono visualizzati solo i prodotti inferiori o uguali a $ 25,00 (fare clic per visualizzare l'immagine a grandezza naturale)

Passaggio 2: Aggiunta di parametri a un'istruzione SQL personalizzata

Quando si aggiunge un'istruzione SQL personalizzata, è possibile immettere la WHERE clausola in modo esplicito o specificare un valore nella cella Filtro del Generatore di query. Per dimostrarlo, è possibile visualizzare solo i prodotti in un controllo GridView i cui prezzi sono inferiori a una determinata soglia. Per iniziare, ParameterizedQueries.aspx aggiungere un oggetto TextBox alla pagina per raccogliere questo valore di soglia dall'utente. Impostare la proprietà TextBox s ID su MaxPrice. Aggiungere un controllo Web Button e impostarne Text la proprietà su Visualizza prodotti corrispondenti.

Quindi, trascinare un controllo GridView sulla pagina e dal relativo smart tag scegliere di creare un nuovo oggetto SqlDataSource denominato ProductsFilteredByPriceDataSource. Dalla procedura guidata Configura origine dati, passare alla schermata Specificare un'istruzione SQL personalizzata o una stored procedure (vedere la Figura 4) e immettere la query seguente:

SELECT ProductName, UnitPrice
FROM Products
WHERE UnitPrice <= @MaximumPrice

Dopo aver immesso la query (manualmente o tramite il Generatore di query), fare clic su Avanti.

Figura 4: Restituire solo i prodotti inferiori o uguali a un valore di parametro (fare clic per visualizzare l'immagine a dimensione intera)

Poiché la query include parametri, nella schermata successiva della procedura guidata viene richiesta l'origine dei valori dei parametri. Scegliere Controllo dall'elenco a discesa Origine parametro e MaxPrice (valore del ID controllo TextBox) dall'elenco a discesa ControlID. È inoltre possibile immettere un valore predefinito facoltativo da utilizzare nel caso in cui l'utente non abbia immesso alcun testo nella casella di MaxPrice testo. Per il momento, non inserire un valore predefinito.

Figura 5: La MaxPrice proprietà TextBox s Text viene utilizzata come origine del parametro (fare clic per visualizzare l'immagine a dimensione intera)

Completare la procedura guidata Configura origine dati facendo clic su Avanti, quindi su Fine. Di seguito è riportato il markup dichiarativo per GridView, TextBox, Button e SqlDataSource:

Maximum price:
$<asp:TextBox ID="MaxPrice" runat="server" Columns="5" />
 
<asp:Button ID="DisplayProductsLessThanButton" runat="server"
    Text="Display Matching Products" />
<asp:GridView ID="GridView2" runat="server" AutoGenerateColumns="False"
    DataSourceID="ProductsFilteredByPriceDataSource" EnableViewState="False">
    <Columns>
        <asp:BoundField DataField="ProductName" HeaderText="Product"
            SortExpression="ProductName" />
        <asp:BoundField DataField="UnitPrice" HeaderText="Price"
            HtmlEncode="False" DataFormatString="{0:c}"
            SortExpression="UnitPrice" />
    </Columns>
</asp:GridView>
<asp:SqlDataSource ID="ProductsFilteredByPriceDataSource" runat="server"
    ConnectionString="<%$ ConnectionStrings:NORTHWNDConnectionString %>"
    SelectCommand=
        "SELECT ProductName, UnitPrice 
        FROM Products WHERE UnitPrice <= @MaximumPrice">
    <SelectParameters>
        <asp:ControlParameter ControlID="MaxPrice" Name="MaximumPrice"
            PropertyName="Text" />
    </SelectParameters>
</asp:SqlDataSource>

Si noti che il parametro all'interno della sezione s <SelectParameters> di SqlDataSource è un ControlParameter, che include proprietà aggiuntive come ControlID e PropertyName. Quando viene richiamato il metodo SqlDataSource Select() , il valore viene ControlParameter acquisito dalla proprietà del controllo Web specificata e assegnato al parametro corrispondente in SelectCommand. In questo esempio, la MaxPrice proprietà s Text viene utilizzata come valore del @MaxPrice parametro.

Prenditi un minuto per visualizzare questa pagina tramite un browser. Quando si visita la pagina per la prima volta o ogni volta che l'oggetto MaxPrice TextBox non dispone di un valore, non viene visualizzato alcun record in GridView.

Figura 6: Non viene visualizzato alcun record quando la casella di testo è vuota (MaxPrice a dimensione intera)

Il motivo per cui non vengono visualizzati prodotti è che, per impostazione predefinita, una stringa vuota per un valore di parametro viene convertita in un valore di database NULL . Poiché il confronto di [UnitPrice] <= NULL restituisce sempre False, non viene restituito alcun risultato.

Inserisci un valore nella casella di testo, ad esempio 5,00, e fai clic sul pulsante Visualizza prodotti corrispondenti. Al momento del postback, SqlDataSource informa GridView che una delle origini dei parametri è stata modificata. Di conseguenza, GridView viene riassociato a SqlDataSource, visualizzando tali prodotti inferiori o uguali a $ 5,00.

Figura 7: Vengono visualizzati prodotti inferiori o uguali a $ 5,00 (fare clic per visualizzare l'immagine a grandezza naturale)

Visualizzazione iniziale di tutti i prodotti

Anziché non mostrare alcun prodotto quando la pagina viene caricata per la prima volta, potremmo voler visualizzare tutti i prodotti. Un modo per elencare tutti i prodotti ogni volta che la MaxPrice casella di testo è vuota è quello di impostare il valore predefinito del parametro su un valore follemente alto, come 1000000, poiché è improbabile che Northwind Traders avrà mai un inventario il cui prezzo unitario supera $ 1.000.000. Tuttavia, questo approccio è miope e potrebbe non funzionare in altre situazioni.

Nelle esercitazioni precedenti - Parametri dichiarativi e filtro master/dettaglio con un DropDownList ci siamo trovati di fronte a un problema simile. La nostra soluzione è stata quella di inserire questa logica nel livello della logica di business. In particolare, il BLL esaminava il valore in ingresso e, se si trattava NULL di un valore riservato, la chiamata veniva indirizzata al metodo DAL che restituiva tutti i record. Se il valore in ingresso era un normale valore di filtraggio, veniva effettuata una chiamata al metodo DAL che eseguiva un'istruzione SQL che utilizzava una clausola parametrizzata WHERE con il valore fornito.

Sfortunatamente, quando si utilizza SqlDataSource viene ignorata l'architettura. Invece, dobbiamo personalizzare l'istruzione SQL per acquisire in modo intelligente tutti i record se il @MaximumPrice parametro è NULL o un valore riservato. Per questo esercizio, facciamo in modo che se il @MaximumPrice parametro è uguale a -1.0, allora tutti i record devono essere restituiti (-1.0 funziona come un valore riservato poiché nessun prodotto può avere un valore negativo UnitPrice ). Per fare ciò possiamo utilizzare la seguente istruzione SQL:

SELECT ProductName, UnitPrice
FROM Products
WHERE UnitPrice <= @MaximumPrice OR @MaximumPrice = -1.0

Questa WHERE clausola restituisce tutti i record se il @MaximumPrice parametro è -1.0uguale a . Se il valore del parametro non -1.0è , vengono restituiti solo i prodotti il cui UnitPrice valore è minore o uguale al valore del @MaximumPrice parametro. Impostando il valore predefinito del @MaximumPrice parametro su -1.0, al primo caricamento della pagina (o ogni volta che la MaxPrice casella di testo è vuota), @MaximumPrice avrà un valore di -1.0 e verranno visualizzati tutti i prodotti.

Figura 8: Ora tutti i prodotti vengono visualizzati quando la casella di testo è vuota (MaxPrice a dimensione intera)

Ci sono un paio di avvertimenti da notare con questo approccio. Innanzitutto, renditi conto che il tipo di dati del parametro è dedotto dal suo utilizzo nella query SQL. Se si modifica la WHERE clausola da @MaximumPrice = -1.0 a @MaximumPrice = -1, il runtime considera il parametro come un numero intero. Se si tenta quindi di assegnare l'oggetto MaxPrice TextBox a un valore decimale (ad esempio 5,00 ), si verificherà un errore perché non è possibile convertire 5,00 in un numero intero. Per rimediare a questo problema, assicurarsi di utilizzare @MaximumPrice = -1.0 nella WHERE clausola o, meglio ancora, impostare la proprietà dell'oggetto ControlParameterType su Decimal .

In secondo luogo, aggiungendo il OR @MaximumPrice = -1.0 alla clausola, il motore di query non può utilizzare un indice su WHERE (supponendo che ne esista uno), risultando così in una scansione della UnitPrice tabella. Ciò può influire sulle prestazioni se nella tabella è presente un numero sufficientemente elevato di record Products . Un approccio migliore consiste nello spostare questa logica in una stored procedure in cui un'istruzione IF esegua una SELECT query dalla Products tabella senza una WHERE clausola quando devono essere restituiti tutti i record o una la cui WHERE clausola contenga solo i UnitPrice criteri, in modo che sia possibile utilizzare un indice.

Passaggio 3: Creazione e utilizzo di stored procedure con parametri

Le stored procedure possono includere un set di parametri di input che possono quindi essere utilizzati nelle istruzioni SQL definite all'interno della stored procedure. Quando si configura SqlDataSource per l'utilizzo di una stored procedure che accetta parametri di input, è possibile specificare tali valori utilizzando le stesse tecniche utilizzate per le istruzioni SQL ad hoc.

Per illustrare l'utilizzo delle stored procedure in SqlDataSource, è possibile creare una nuova stored procedure nel database Northwind denominata GetProductsByCategory, che accetta un parametro denominato @CategoryID e restituisce tutte le colonne dei prodotti la cui CategoryID colonna corrisponde a @CategoryID. Per creare una stored procedure, passare a Esplora server ed eseguire il drill-down nel NORTHWND.MDF database. Se non vedi Esplora server, visualizzalo andando al menu Visualizza e selezionando l'opzione Esplora server.

NORTHWND.MDF Dal database, fare clic con il pulsante destro del mouse sulla cartella Stored procedure, scegliere Aggiungi nuova stored procedure e immettere la sintassi seguente:

CREATE PROCEDURE dbo.GetProductsByCategory
(
      @CategoryID int
)
AS
SELECT *
FROM Products
WHERE CategoryID = @CategoryID

Fare clic sull'icona Salva (o CTRL+S) per salvare la stored procedure. È possibile testare la stored procedure facendo clic con il pulsante destro del mouse su di essa nella cartella Stored procedure e scegliendo Esegui. Verranno richiesti i parametri della stored procedure (@CategoryIDin questo caso), dopodiché i risultati verranno visualizzati nella finestra Output.

@CategoryID di 1" />

Figura 9: Stored GetProductsByCategory procedure quando viene eseguita con un @CategoryID di 1 (fare clic per visualizzare l'immagine a dimensione intera)

Usiamo questa stored procedure per visualizzare tutti i prodotti nella categoria Bevande in un controllo GridView. Aggiungere un nuovo controllo GridView alla pagina e associarlo a un nuovo oggetto SqlDataSource denominato BeverageProductsDataSource. Passare alla schermata Specificare un'istruzione SQL personalizzata o una stored procedure, selezionare il pulsante di opzione Stored procedure e selezionare la GetProductsByCategory stored procedure dall'elenco a discesa.

Figura 10: Selezionare la GetProductsByCategory stored procedure dall'elenco Drop-Down (fare clic per visualizzare l'immagine a dimensione intera)

Poiché la stored procedure accetta un parametro di input (@CategoryID), facendo clic su Avanti viene richiesto di specificare l'origine per il valore di questo parametro. Il valore di Bevande CategoryID è 1, quindi lasciare l'elenco a discesa Origine parametro su Nessuno e immettere 1 nella casella di testo Valore predefinito.

Figura 11: Utilizzare un valore Hard-Coded pari a 1 per restituire i prodotti nella categoria Bevande (fare clic per visualizzare l'immagine a grandezza naturale)

Come illustrato nel markup dichiarativo seguente, quando si utilizza una stored procedure, la proprietà SqlDataSource s SelectCommand viene impostata sul nome della stored procedure e la SelectCommandType proprietà viene impostata su StoredProcedure, indicando che si SelectCommand tratta del nome di una stored procedure anziché di un'istruzione SQL ad hoc.

<asp:SqlDataSource ID="BeverageProductsDataSource" runat="server"
    ConnectionString="<%$ ConnectionStrings:NORTHWNDConnectionString %>"
    SelectCommand="GetProductsByCategory" SelectCommandType="StoredProcedure">
    <SelectParameters>
        <asp:Parameter DefaultValue="1" Name="CategoryID" Type="Int32" />
    </SelectParameters>
</asp:SqlDataSource>

Prova la pagina in un browser. Vengono visualizzati solo i prodotti che appartengono alla categoria Bevande, anche se vengono visualizzati tutti i campi del prodotto poiché la GetProductsByCategory stored procedure restituisce tutte le colonne della Products tabella. Potremmo ovviamente limitare o personalizzare i campi visualizzati in GridView dalla finestra di dialogo Modifica colonne di GridView.

Figura 12: Tutte le bevande vengono visualizzate (fare clic per visualizzare l'immagine a grandezza naturale)

Passaggio 4: Richiamo a livello di codice dell'istruzione Select() di SqlDataSource

Gli esempi illustrati nell'esercitazione precedente e in questa esercitazione finora hanno associato i controlli SqlDataSource direttamente a un GridView. I dati del controllo SqlDataSource, tuttavia, possono essere accessibili a livello di codice ed enumerati nel codice. Ciò può essere particolarmente utile quando è necessario eseguire query sui dati per esaminarli, ma non è necessario visualizzarli. Anziché dover scrivere tutto il codice ADO.NET standard per connettersi al database, specificare il comando e recuperare i risultati, è possibile lasciare che SqlDataSource gestisca questo codice monotono.

Per illustrare l'utilizzo dei dati di SqlDataSource a livello di codice, si supponga che il capo si sia rivolto a te con la richiesta di creare una pagina Web che visualizza il nome di una categoria selezionata in modo casuale e dei prodotti associati. Cioè, quando un utente visita questa pagina, vogliamo scegliere casualmente una categoria dalla Categories tabella, visualizzare il nome della categoria e quindi elencare i prodotti appartenenti a quella categoria.

A tale scopo, sono necessari due controlli SqlDataSource, uno per acquisire una categoria casuale dalla Categories tabella e un altro per ottenere i prodotti della categoria. In questo passaggio verrà compilato l'oggetto SqlDataSource che recupera un record di categoria casuale. Il passaggio 5 esamina la creazione di SqlDataSource che recupera i prodotti della categoria.

Per iniziare, aggiungere un oggetto SqlDataSource a ParameterizedQueries.aspx e impostarlo ID su RandomCategoryDataSource. Configurarlo in modo che utilizzi la seguente query SQL:

SELECT TOP 1 CategoryID, CategoryName
FROM Categories
ORDER BY NEWID()

ORDER BY NEWID() restituisce i record ordinati in ordine casuale (vedere Utilizzo NEWID() per ordinare i record in modo casuale). SELECT TOP 1 Restituisce il primo record del set di risultati. Nel complesso, questa query restituisce i valori di CategoryID colonna e CategoryName da una singola categoria selezionata in modo casuale.

Per visualizzare il valore della CategoryName categoria, aggiungere un controllo Web Label alla pagina, impostarne ID la proprietà su CategoryNameLabele deselezionarne Text la proprietà. Per recuperare i dati a livello di codice da un controllo SqlDataSource, è necessario richiamare il relativo Select() metodo. Il Select() metodo prevede un singolo parametro di input di tipo DataSourceSelectArguments, che specifica il modo in cui i dati devono essere inviati prima di essere restituiti. Può includere istruzioni sull'ordinamento e il filtro dei dati e viene utilizzato dai controlli Web dei dati durante l'ordinamento o il paging dei dati da un controllo SqlDataSource. Per il nostro esempio, tuttavia, non abbiamo bisogno che i dati vengano modificati prima di essere restituiti, e quindi passeremo nell'oggetto DataSourceSelectArguments.Empty .

Il Select() metodo restituisce un oggetto che implementa IEnumerable. Il tipo preciso restituito dipende dal valore della proprietà del DataSourceModecontrollo SqlDataSource. Come illustrato nell'esercitazione precedente, questa proprietà può essere impostata su un valore di DataSetDataReadero . Se impostato su DataSet, il Select() metodo restituisce un oggetto DataView ; se impostato su DataReader, restituisce un oggetto che implementa IDataReader. Poiché la RandomCategoryDataSource proprietà DataSourceMode di SqlDataSource è impostata su DataSet (impostazione predefinita), verrà utilizzato un oggetto DataView.

Nel codice seguente viene illustrato come recuperare i record da RandomCategoryDataSource SqlDataSource come DataView e come leggere il valore della CategoryName colonna dalla prima riga di DataView:

protected void Page_Load(object sender, EventArgs e)
{
    // Get the data from the SqlDataSource as a DataView
    DataView randomCategoryView =
        (DataView)RandomCategoryDataSource.Select(DataSourceSelectArguments.Empty);
    if (randomCategoryView.Count > 0)
    {
        // Assign the CategoryName value to the Label
        CategoryNameLabel.Text =
            string.Format("Here are Products in the {0} Category...",
                randomCategoryView[0]["CategoryName"].ToString());
    }
}

randomCategoryView[0] restituisce il primo DataRowView in DataView. randomCategoryView[0]["CategoryName"] Restituisce il CategoryName valore della colonna in questa prima riga. Si noti che DataView è tipizzato in modo approssimativo. Per fare riferimento a un particolare valore di colonna, è necessario passare il nome della colonna come stringa ( CategoryName, in questo caso). La Figura 13 mostra il messaggio visualizzato durante la CategoryNameLabel visualizzazione della pagina. Naturalmente, il nome effettivo della categoria visualizzato viene selezionato in modo casuale da RandomCategoryDataSource SqlDataSource a ogni visita alla pagina (inclusi i postback).

Figura 13: Viene visualizzato il nome della categoria selezionata casualmente (fare clic per visualizzare l'immagine a grandezza naturale)

Annotazioni

Se la proprietà del controllo SqlDataSource fosse DataSourceMode stata impostata su DataReader, sarebbe stato necessario eseguire il Select() cast del valore restituito dal metodo a IDataReader. Per leggere il valore della CategoryName colonna dalla prima riga, utilizzeremmo un codice come:

if (randomCategoryReader.Read())
{
   string categoryName = randomCategoryReader["CategoryName"].ToString();
   ...
}

Con SqlDataSource che seleziona in modo casuale una categoria, siamo pronti per aggiungere GridView che elenca i prodotti della categoria.

Annotazioni

Anziché utilizzare un controllo Web Label per visualizzare il nome della categoria, è possibile aggiungere un controllo FormView o DetailsView alla pagina, associandolo a SqlDataSource. L'uso di Label, tuttavia, ci ha permesso di esplorare come richiamare a livello di codice l'istruzione SqlDataSource Select() e lavorare con i dati risultanti nel codice.

Passaggio 5: Assegnazione dei valori dei parametri a livello di codice

In tutti gli esempi illustrati finora in questa esercitazione è stato utilizzato un valore di parametro hardcoded o uno ricavato da una delle origini di parametri predefinite (un valore querystring, un controllo Web nella pagina e così via). Tuttavia, i parametri del controllo SqlDataSource possono essere impostati anche a livello di codice. Per completare l'esempio corrente, è necessario un SqlDataSource che restituisca tutti i prodotti appartenenti a una categoria specificata. Questo SqlDataSource avrà un CategoryID parametro il cui valore deve essere impostato in base al valore della CategoryID colonna restituito da RandomCategoryDataSource SqlDataSource nel gestore eventi Page_Load .

Per iniziare, aggiungere un controllo GridView alla pagina e associarlo a un nuovo oggetto SqlDataSource denominato ProductsByCategoryDataSource. In modo analogo al passaggio 3, configurare SqlDataSource in modo che richiami la GetProductsByCategory stored procedure. Lasciare l'elenco a discesa Origine parametro impostato su Nessuno, ma non immettere un valore predefinito, poiché questo valore predefinito verrà impostato a livello di codice.

Figura 14: Non specificare un'origine del parametro o un valore predefinito (fare clic per visualizzare l'immagine a dimensione intera)

Dopo aver completato la procedura guidata SqlDataSource, il markup dichiarativo risultante dovrebbe essere simile al seguente:

<asp:SqlDataSource ID="ProductsByCategoryDataSource" runat="server"
    ConnectionString="<%$ ConnectionStrings:NORTHWNDConnectionString %>"
    SelectCommand="GetProductsByCategory" SelectCommandType="StoredProcedure">
    <SelectParameters>
        <asp:Parameter Name="CategoryID" Type="Int32" />
    </SelectParameters>
</asp:SqlDataSource>

Possiamo assegnare il DefaultValue del parametro a livello di codice nel gestore eventi CategoryIDPage_Load:

// Assign the ProductsByCategoryDataSource's
// CategoryID parameter's DefaultValue property
ProductsByCategoryDataSource.SelectParameters["CategoryID"].DefaultValue =
    randomCategoryView[0]["CategoryID"].ToString();

Con questa aggiunta, la pagina include un controllo GridView che mostra i prodotti associati alla categoria selezionata in modo casuale.

Figura 15: Non specificare un'origine del parametro o un valore predefinito (fare clic per visualizzare l'immagine a dimensione intera)

Riassunto

SqlDataSource consente agli sviluppatori di pagine di definire query con parametri i cui valori dei parametri possono essere hardcoded, estratti da origini di parametri predefinite o assegnati a livello di codice. In questa esercitazione è stato illustrato come creare una query con parametri dalla procedura guidata Configura origine dati sia per le query SQL ad hoc che per le stored procedure. È stato inoltre esaminato l'utilizzo di origini di parametri hardcoded, un controllo Web come origine di parametri e la specifica del valore del parametro a livello di codice.

Analogamente a ObjectDataSource, anche SqlDataSource offre funzionalità per modificare i dati sottostanti. Nell'esercitazione successiva verrà illustrato come definire INSERTle istruzioni , UPDATE, e con DELETE SqlDataSource. Dopo aver aggiunto queste istruzioni, è possibile usare le funzionalità predefinite di inserimento, modifica ed eliminazione inerenti ai controlli GridView, DetailsView e FormView.

Buon programmatori!

Informazioni sull'autore

Scott Mitchell, autore di sette libri ASP/ASP.NET e fondatore di 4GuysFromRolla.com, ha lavorato con le tecnologie Web Microsoft dal 1998. Scott lavora come consulente indipendente, formatore e scrittore. Il suo ultimo libro è Sams Teach Yourself ASP.NET 2.0 in 24 ore. Può essere raggiunto a mitchell@4GuysFromRolla.com.

Grazie speciale a

Questa serie di esercitazioni è stata esaminata da molti revisori competenti. I revisori principali di questo tutorial sono stati Scott Clyde, Randell Schmidt e Ken Pespisa. Si è interessati a esaminare i prossimi articoli MSDN? In tal caso, mandami un messaggio a mitchell@4GuysFromRolla.com.

PrecedenteAvanti