Utilisation de requêtes paramétrables avec SqlDataSource (C#)
par Scott Mitchell
Dans ce tutoriel, nous poursuivons notre présentation du contrôle SqlDataSource et apprenons à définir des requêtes paramétrables. Les paramètres peuvent être spécifiés à la fois de manière déclarative et programmatique, et peuvent être extraits à partir d’un certain nombre d’emplacements tels que la chaîne de requête, l’état de session, d’autres contrôles, etc.
Introduction
Dans le tutoriel précédent, nous avons vu comment utiliser le contrôle SqlDataSource pour récupérer des données directement à partir d’une base de données. À l’aide de l’Assistant Configuration de la source de données, nous pouvons choisir la base de données, puis choisir les colonnes à retourner à partir d’une table ou d’une vue ; entrez une instruction SQL personnalisée ; ou utiliser une procédure stockée. Qu’il s’agisse de sélectionner des colonnes à partir d’une table ou d’une vue ou d’entrer une instruction SQL personnalisée, la propriété du SelectCommand contrôle SqlDataSource se voit attribuer l’instruction SQL SELECT ad hoc résultante et c’est cette SELECT instruction qui est exécutée lorsque la méthode SqlDataSource Select() est appelée (par programmation ou automatiquement à partir d’un contrôle Web de données).
Les instructions SQL SELECT utilisées dans les démonstrations du didacticiel précédent n’ont pas de WHERE clauses. Dans une SELECT instruction, la WHERE clause peut être utilisée pour limiter les résultats retournés. Par exemple, pour afficher les noms des produits dont le coût est supérieur à 50,00 $, nous pouvons utiliser la requête suivante :
SELECT ProductName
FROM Products
WHERE UnitPrice > 50.00
En règle générale, les valeurs utilisées dans une clause sont définies par une WHERE source externe, telle qu’une valeur de chaîne de requête, une variable de session ou une entrée utilisateur à partir d’un contrôle Web sur la page. Dans l’idéal, ces entrées sont spécifiées à l’aide de paramètres. Avec Microsoft SQL Server, les paramètres sont indiqués à l’aide @parameterNamede , comme dans :
SELECT ProductName
FROM Products
WHERE UnitPrice > @Price
SqlDataSource prend en charge les requêtes paramétrables, à la fois pour SELECT les instructions et INSERTles instructions , UPDATEet DELETE . En outre, les valeurs des paramètres peuvent être automatiquement extraites d’une variété de sources que la chaîne de requête, l’état de session, les contrôles sur la page, etc. ou peuvent être affectées par programmation. Dans ce tutoriel, nous allons voir comment définir des requêtes paramétrables et comment spécifier les valeurs de paramètre de manière déclarative et par programmation.
Notes
Dans le tutoriel précédent, nous avons comparé l’ObjectDataSource, qui était notre outil de choix sur les 46 premiers tutoriels avec sqlDataSource, en notant leurs similitudes conceptuelles. Ces similitudes s’étendent également aux paramètres. Paramètres d’ObjectDataSource mappés aux paramètres d’entrée des méthodes dans la couche de logique métier. Avec SqlDataSource, les paramètres sont définis directement dans la requête SQL. Les deux contrôles ont des collections de paramètres pour leurs Select()méthodes , Insert(), Update()et Delete() . Ils peuvent tous deux avoir ces valeurs de paramètre remplies à partir de sources prédéfinies (valeurs de chaîne de requête, variables de session, etc.) ou affectées par programmation.
Création d'une requête paramétrée
L’Assistant Configuration de la source de données du contrôle SqlDataSource offre trois possibilités pour définir la commande à exécuter pour récupérer les enregistrements de base de données :
- En sélectionnant les colonnes d’une table ou d’une vue existante,
- En entrant une instruction SQL personnalisée, ou
- En choisissant une procédure stockée
Lors de la sélection de colonnes d’une table ou d’une vue existante, les paramètres de la WHERE clause doivent être spécifiés via la boîte de dialogue Ajouter une WHERE clause. Toutefois, lors de la création d’une instruction SQL personnalisée, vous pouvez entrer les paramètres directement dans la WHERE clause (à l’aide @parameterName de pour désigner chaque paramètre). Une procédure stockée se compose d’une ou plusieurs instructions SQL, et ces instructions peuvent être paramétrables. Toutefois, les paramètres utilisés dans les instructions SQL doivent être passés en tant que paramètres d’entrée à la procédure stockée.
Étant donné que la création d’une requête paramétrable dépend de la façon dont les SqlDataSource sont SelectCommand spécifiés, examinons les trois approches. Pour commencer, ouvrez la ParameterizedQueries.aspx page dans le SqlDataSource dossier, faites glisser un contrôle SqlDataSource de la boîte à outils vers le Designer, puis définissez-le ID sur Products25BucksAndUnderDataSource. Cliquez ensuite sur le lien Configurer la source de données à partir de la balise active du contrôle. Sélectionnez la base de données à utiliser (NORTHWINDConnectionString), puis cliquez sur Suivant.
Étape 1 : Ajout d’une clause WHERE lors de la sélection des colonnes d’une table ou d’une vue
Lorsque vous sélectionnez les données à retourner à partir de la base de données avec le contrôle SqlDataSource, l’Assistant Configuration de la source de données nous permet de sélectionner simplement les colonnes à retourner à partir d’une table ou d’une vue existante (voir la figure 1). Cela génère automatiquement une instruction SQL SELECT , qui est envoyée à la base de données lorsque la méthode SqlDataSource Select() est appelée. Comme nous l’avons fait dans le tutoriel précédent, sélectionnez la table Products dans la liste déroulante et case activée les ProductIDcolonnes , ProductNameet UnitPrice .
Figure 1 : Sélectionner les colonnes à retourner à partir d’une table ou d’une vue (cliquer pour afficher l’image en taille réelle)
Pour inclure une WHERE clause dans l’instruction SELECT , cliquez sur le WHERE bouton qui affiche la boîte de dialogue Ajouter WHERE une clause (voir figure 2). Pour ajouter un paramètre afin de limiter les résultats retournés par la SELECT requête, choisissez d’abord la colonne par laquelle filtrer les données. Ensuite, choisissez l’opérateur à utiliser pour le filtrage (=, <, <=, >, et ainsi de suite). Enfin, choisissez la source de la valeur s du paramètre, par exemple dans l’état de la chaîne de requête ou de la session. Après avoir configuré le paramètre, cliquez sur le bouton Ajouter pour l’inclure dans la SELECT requête.
Pour cet exemple, ne renvoyons que les résultats dont la UnitPrice valeur est inférieure ou égale à 25,00 $. Par conséquent, choisissez UnitPrice dans la liste déroulante Colonne et <= dans la liste déroulante Opérateur. Lorsque vous utilisez une valeur de paramètre codée en dur (par exemple, 25,00 $) ou si la valeur du paramètre doit être spécifiée par programmation, sélectionnez Aucun dans la liste déroulante Source. Ensuite, entrez la valeur du paramètre codé en dur dans la zone de texte Valeur 25.00 et terminez le processus en cliquant sur le bouton Ajouter.
Figure 2 : Limiter les résultats retournés à partir de la boîte de dialogue Ajouter WHERE une clause (cliquer pour afficher l’image en taille réelle)
Après avoir ajouté le paramètre, cliquez sur OK pour revenir à l’Assistant Configuration de la source de données. L’instruction SELECT en bas de l’Assistant doit maintenant inclure une WHERE clause avec un paramètre nommé @UnitPrice:
SELECT [ProductID], [ProductName], [UnitPrice]
FROM [Products]
WHERE ([UnitPrice] <= @UnitPrice)
Notes
Si vous spécifiez plusieurs conditions dans la WHERE clause à partir de la boîte de dialogue Ajouter une WHERE clause, l’Assistant les joint à l’opérateur AND . Si vous devez inclure un OR dans la WHERE clause (par exemple WHERE UnitPrice <= @UnitPrice OR Discontinued = 1, ), vous devez générer l’instruction via l’écran SELECT d’instruction SQL personnalisée.
Terminez la configuration de SqlDataSource (cliquez sur Suivant, puis sur Terminer), puis inspectez le balisage déclaratif de SqlDataSource. Le balisage inclut désormais une <SelectParameters> collection, qui indique les sources des paramètres dans le 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>
Lorsque la méthode SqlDataSource Select() est appelée, la valeur du UnitPrice paramètre (25.00) est appliquée au paramètre dans le @UnitPriceSelectCommand avant d’être envoyée à la base de données. Le résultat net est que seuls les produits inférieurs ou égaux à 25,00 $ sont retournés à partir du Products tableau. Pour confirmer cela, ajoutez un GridView à la page, liez-le à cette source de données, puis affichez la page via un navigateur. Vous devriez voir uniquement les produits répertoriés qui sont inférieurs ou égaux à 25,00 $, comme le confirme la figure 3.
Figure 3 : Seuls les produits inférieurs ou égaux à 25,00 $ sont affichés (Cliquez pour afficher l’image en taille réelle)
Étape 2 : Ajout de paramètres à une instruction SQL personnalisée
Lorsque vous ajoutez une instruction SQL personnalisée, vous pouvez entrer la WHERE clause explicitement ou spécifier une valeur dans la cellule Filter du Générateur de requêtes. Pour illustrer cela, nous allons afficher uniquement les produits dans un GridView dont les prix sont inférieurs à un certain seuil. Commencez par ajouter une zone de texte à la ParameterizedQueries.aspx page pour collecter cette valeur de seuil auprès de l’utilisateur. Définissez la propriété textbox sur IDMaxPrice. Ajoutez un contrôle Button Web et définissez sa Text propriété sur Afficher les produits correspondants.
Ensuite, faites glisser un GridView sur la page et, à partir de sa balise active, choisissez de créer un objet SqlDataSource nommé ProductsFilteredByPriceDataSource. À partir de l’Assistant Configuration de la source de données, passez à l’écran Spécifier une instruction SQL personnalisée ou une procédure stockée (voir figure 4) et entrez la requête suivante :
SELECT ProductName, UnitPrice
FROM Products
WHERE UnitPrice <= @MaximumPrice
Après avoir entré la requête (manuellement ou via le Générateur de requêtes), cliquez sur Suivant.
Figure 4 : Renvoyer uniquement les produits inférieurs ou égaux à une valeur de paramètre (cliquez pour afficher l’image en taille réelle)
Étant donné que la requête inclut des paramètres, l’écran suivant de l’Assistant nous invite à entrer la source des valeurs des paramètres. Choisissez Contrôle dans la liste déroulante Source du paramètre et MaxPrice (valeur du ID contrôle TextBox) dans la liste déroulante ControlID. Vous pouvez également entrer une valeur par défaut facultative à utiliser dans le cas où l’utilisateur n’a pas entré de texte dans textBox MaxPrice . Pour le moment, n’entrez pas de valeur par défaut.
Figure 5 : La MaxPrice propriété de Text TextBox est utilisée comme source du paramètre (cliquer pour afficher l’image de taille réelle)
Terminez l’Assistant Configuration de la source de données en cliquant sur Suivant, puis sur Terminer. Le balisage déclaratif pour GridView, TextBox, Button et SqlDataSource est le suivant :
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>
Notez que le paramètre dans la section SqlDataSource est <SelectParameters> un ControlParameter, qui inclut des propriétés supplémentaires telles que ControlID et PropertyName. Lorsque la méthode SqlDataSource est Select() appelée, le ControlParameter récupère la valeur de la propriété de contrôle Web spécifiée et l’affecte au paramètre correspondant dans le SelectCommand. Dans cet exemple, la MaxPrice propriété Text de est utilisée comme valeur de @MaxPrice paramètre.
Prenez une minute pour afficher cette page via un navigateur. Lors de la première visite de la page ou chaque fois que la MaxPrice zone de texte n’a pas de valeur, aucun enregistrement n’est affiché dans gridView.
Figure 6 : Aucun enregistrement n’est affiché lorsque la MaxPrice zone de texte est vide (cliquez pour afficher l’image en taille réelle)
La raison pour laquelle aucun produit n’est affiché est que, par défaut, une chaîne vide pour une valeur de paramètre est convertie en valeur de base de données NULL . Étant donné que la comparaison de [UnitPrice] <= NULL a toujours la valeur False, aucun résultat n’est retourné.
Entrez une valeur dans la zone de texte, par exemple 5.00, puis cliquez sur le bouton Afficher les produits correspondants. Lors de la publication, SqlDataSource informe gridView que l’une de ses sources de paramètres a changé. Par conséquent, le GridView se relie à SqlDataSource, affichant ces produits inférieurs ou égaux à 5,00 $.
Figure 7 : Les produits inférieurs ou égaux à 5,00 $ sont affichés (Cliquer pour afficher l’image en taille réelle)
Affichage initial de tous les produits
Au lieu d’afficher aucun produit lorsque la page est chargée pour la première fois, nous pouvons souhaiter afficher tous les produits. Une façon de répertorier tous les produits chaque fois que la MaxPrice Zone de texte est vide consiste à définir la valeur par défaut du paramètre sur une valeur follement élevée, comme 10000000, car il est peu probable que Northwind Traders ait un inventaire dont le prix unitaire dépasse 1 000 000 $. Toutefois, cette approche est à courte vue et peut ne pas fonctionner dans d’autres situations.
Dans les tutoriels précédents - Paramètres déclaratifs et Filtrage maître/détail avec un DropDownList , nous avons été confrontés à un problème similaire. Notre solution était de placer cette logique dans la couche logique métier. Plus précisément, le BLL a examiné la valeur entrante et, s’il s’agissait NULL d’une valeur réservée, l’appel a été acheminé vers la méthode DAL qui a retourné tous les enregistrements. Si la valeur entrante était une valeur de filtrage normale, un appel a été effectué à la méthode DAL qui a exécuté une instruction SQL qui utilisait une clause paramétrable WHERE avec la valeur fournie.
Malheureusement, nous contournons l’architecture lors de l’utilisation de SqlDataSource. Au lieu de cela, nous devons personnaliser l’instruction SQL pour récupérer intelligemment tous les enregistrements si le @MaximumPrice paramètre est NULL ou une valeur réservée. Pour cet exercice, faisons en sorte que si le @MaximumPrice paramètre est égal à -1.0, tous les enregistrements doivent être retournés (-1.0 fonctionne comme une valeur réservée, car aucun produit ne peut avoir une valeur négative UnitPrice ). Pour ce faire, nous pouvons utiliser l’instruction SQL suivante :
SELECT ProductName, UnitPrice
FROM Products
WHERE UnitPrice <= @MaximumPrice OR @MaximumPrice = -1.0
Cette WHERE clause retourne tous les enregistrements si le @MaximumPrice paramètre est égal à -1.0. Si la valeur du paramètre n’est pas -1.0, seuls les produits dont UnitPrice la valeur est inférieure ou égale à la valeur du @MaximumPrice paramètre sont retournés. En définissant la valeur par défaut du @MaximumPrice paramètre -1.0sur , lors du premier chargement de page (ou chaque fois que la MaxPrice zone de texte est vide), @MaximumPrice a la valeur et -1.0 tous les produits s’affichent.
Figure 8 : Maintenant tous les produits sont affichés lorsque la MaxPrice zone de texte est vide (cliquez pour afficher l’image en taille réelle)
Il y a quelques mises en garde à noter avec cette approche. Tout d’abord, réalisez que le type de données du paramètre est déduit par son utilisation dans la requête SQL. Si vous remplacez la WHERE clause par @MaximumPrice = -1@MaximumPrice = -1.0 , le runtime traite le paramètre comme un entier. Si vous tentez ensuite d’affecter la MaxPrice Zone de texte à une valeur décimale (par exemple, 5.00 ), une erreur se produit, car elle ne peut pas convertir 5.00 en entier. Pour y remédier, vérifiez que vous utilisez @MaximumPrice = -1.0 dans la WHERE clause ou, mieux encore, définissez la propriété s de l’objet ControlParameterType sur Decimal .
Deuxièmement, en ajoutant à OR @MaximumPrice = -1.0 la clause, le WHERE moteur de requête ne peut pas utiliser d’index sur UnitPrice (en supposant qu’il en existe un), ce qui entraîne une analyse de table. Cela peut avoir un impact sur les performances s’il y a un nombre suffisamment important d’enregistrements dans la Products table. Une meilleure approche consisterait à déplacer cette logique vers une procédure stockée où une IF instruction exécuterait une SELECT requête à partir de la Products table sans WHERE clause lorsque tous les enregistrements doivent être retournés ou dont WHERE la clause contient uniquement les UnitPrice critères, afin qu’un index puisse être utilisé.
Étape 3 : Création et utilisation de procédures stockées paramétrables
Les procédures stockées peuvent inclure un ensemble de paramètres d’entrée qui peuvent ensuite être utilisés dans les instructions SQL définies dans la procédure stockée. Lors de la configuration de SqlDataSource pour utiliser une procédure stockée qui accepte les paramètres d’entrée, ces valeurs de paramètres peuvent être spécifiées à l’aide des mêmes techniques que pour les instructions SQL ad hoc.
Pour illustrer l’utilisation de procédures stockées dans SqlDataSource, créons une procédure stockée dans la base de données Northwind nommée GetProductsByCategory, qui accepte un paramètre nommé @CategoryID et retourne toutes les colonnes des produits dont CategoryID la colonne correspond @CategoryIDà . Pour créer une procédure stockée, accédez au serveur Explorer et explorez la NORTHWND.MDF base de données. (Si l’Explorer serveur ne s’affiche pas, affichez-le en accédant au menu Affichage et en sélectionnant l’option Server Explorer.)
Dans la NORTHWND.MDF base de données, cliquez avec le bouton droit sur le dossier Procédures stockées, choisissez Ajouter une nouvelle procédure stockée, puis entrez la syntaxe suivante :
CREATE PROCEDURE dbo.GetProductsByCategory
(
@CategoryID int
)
AS
SELECT *
FROM Products
WHERE CategoryID = @CategoryID
Cliquez sur l’icône Enregistrer (ou Ctrl+S) pour enregistrer la procédure stockée. Vous pouvez tester la procédure stockée en cliquant avec le bouton droit sur celle-ci dans le dossier Procédures stockées et en choisissant Exécuter. Vous êtes alors invité à entrer les paramètres de la procédure stockée (@CategoryIDdans ce instance), après quoi les résultats s’affichent dans la fenêtre Sortie.
@CategoryID de 1 » />
Figure 9 : GetProductsByCategory Procédure stockée en cas d’exécution avec un @CategoryID de 1 (cliquer pour afficher l’image en taille réelle)
Nous allons utiliser cette procédure stockée pour afficher tous les produits de la catégorie Boissons dans un GridView. Ajoutez un nouveau GridView à la page et liez-le à un nouveau SqlDataSource nommé BeverageProductsDataSource. Passez à l’écran Spécifier une instruction SQL personnalisée ou une procédure stockée, sélectionnez la case d’option Procédure stockée, puis sélectionnez la GetProductsByCategory procédure stockée dans la liste déroulante.
Figure 10 : Sélectionnez la GetProductsByCategory procédure stockée dans la liste Drop-Down (cliquez pour afficher l’image en taille réelle)
Étant donné que la procédure stockée accepte un paramètre d’entrée (@CategoryID), le fait de cliquer sur Suivant nous invite à spécifier la source pour la valeur de ce paramètre. Les boissons CategoryID étant 1, laissez la liste déroulante Source du paramètre sur Aucun et entrez 1 dans la zone de texte DefaultValue.
Figure 11 : Utilisez une valeur Hard-Coded de 1 pour renvoyer les produits de la catégorie Boissons (cliquer pour afficher l’image en taille réelle)
Comme le montre le balisage déclaratif suivant, lors de l’utilisation d’une procédure stockée, la propriété SqlDataSource SelectCommand est définie sur le nom de la procédure stockée et la propriété a la SelectCommandType valeurStoredProcedure, ce qui indique que est SelectCommand le nom d’une procédure stockée plutôt qu’une instruction 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>
Testez la page dans un navigateur. Seuls les produits appartenant à la catégorie Boissons sont affichés, bien que tous les champs de produit soient affichés, car la GetProductsByCategory procédure stockée retourne toutes les colonnes de la Products table. Bien sûr, nous pourrions limiter ou personnaliser les champs affichés dans gridView à partir de la boîte de dialogue Modifier les colonnes de GridView.
Figure 12 : Toutes les boissons sont affichées (cliquer pour afficher l’image en taille réelle)
Étape 4 : Appel par programmation de l’instruction Select() de SqlDataSource
Les exemples que nous avons vus dans le tutoriel précédent et ce tutoriel jusqu’à présent ont lié des contrôles SqlDataSource directement à un GridView. Toutefois, les données du contrôle SqlDataSource sont accessibles par programmation et énumérées dans le code. Cela peut être particulièrement utile lorsque vous devez interroger des données pour les inspecter, mais que vous n’avez pas besoin de les afficher. Au lieu d’écrire tout le code ADO.NET réutilisable pour se connecter à la base de données, spécifier la commande et récupérer les résultats, vous pouvez laisser SqlDataSource gérer ce code monotone.
Pour illustrer l’utilisation des données de SqlDataSource par programme, imaginez que votre patron vous a demandé de créer une page web qui affiche le nom d’une catégorie sélectionnée de manière aléatoire et les produits associés. Autrement dit, lorsqu’un utilisateur visite cette page, nous voulons choisir aléatoirement une catégorie dans la Categories table, afficher le nom de la catégorie, puis répertorier les produits appartenant à cette catégorie.
Pour ce faire, nous avons besoin de deux contrôles SqlDataSource l’un pour récupérer une catégorie aléatoire dans la Categories table et l’autre pour obtenir les produits de catégorie s. Nous allons générer le SqlDataSource qui récupère un enregistrement de catégorie aléatoire dans cette étape ; L’étape 5 examine la création de SqlDataSource qui récupère les produits de catégorie s.
Commencez par ajouter un SqlDataSource à ParameterizedQueries.aspx et définissez-le ID sur RandomCategoryDataSource. Configurez-le de sorte qu’il utilise la requête SQL suivante :
SELECT TOP 1 CategoryID, CategoryName
FROM Categories
ORDER BY NEWID()
ORDER BY NEWID() retourne les enregistrements triés dans l’ordre aléatoire (voir Utilisation NEWID() des enregistrements de tri aléatoire). SELECT TOP 1 retourne le premier enregistrement du jeu de résultats. Ensemble, cette requête retourne les valeurs de colonne CategoryID et CategoryName d’une catégorie unique sélectionnée de manière aléatoire.
Pour afficher la valeur de catégorie s CategoryName , ajoutez un contrôle Label Web à la page, définissez sa ID propriété sur CategoryNameLabelet effacez sa Text propriété. Pour récupérer par programmation les données d’un contrôle SqlDataSource, nous devons appeler sa Select() méthode. La Select() méthode attend un paramètre d’entrée unique de type DataSourceSelectArguments, qui spécifie la façon dont les données doivent être renvoyées. Cela peut inclure des instructions sur le tri et le filtrage des données, et est utilisé par les contrôles Web de données lors du tri ou de la pagination des données à partir d’un contrôle SqlDataSource. Pour notre exemple, cependant, nous n’avons pas besoin que les données soient modifiées avant d’être retournées, et par conséquent, nous transmettons l’objet DataSourceSelectArguments.Empty .
La Select() méthode retourne un objet qui implémente IEnumerable. Le type précis retourné dépend de la valeur de la propriété s du DataSourceModecontrôle SqlDataSource. Comme indiqué dans le tutoriel précédent, cette propriété peut être définie sur une valeur de DataSet ou DataReader. Si la valeur est définie DataSetsur , la Select() méthode retourne un objet DataView ; si elle a la valeur DataReader, elle renvoie un objet qui implémente IDataReader. Étant donné que sqlDataSource RandomCategoryDataSource a sa DataSourceMode propriété définie sur DataSet (valeur par défaut), nous allons utiliser un objet DataView.
Le code suivant montre comment récupérer les enregistrements de RandomCategoryDataSource SqlDataSource en tant que DataView et comment lire la valeur de colonne CategoryName de la première ligne 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] retourne le premier DataRowView dans le DataView. randomCategoryView[0]["CategoryName"] retourne la valeur de la CategoryName colonne de cette première ligne. Notez que le DataView est faiblement typé. Pour référencer une valeur de colonne particulière, nous devons passer le nom de la colonne sous forme de chaîne ( CategoryName, dans ce cas). La figure 13 montre le message affiché dans lors de l’affichage CategoryNameLabel de la page. Bien sûr, le nom de catégorie affiché est sélectionné de manière aléatoire par sqlDataSource RandomCategoryDataSource à chaque visite de la page (y compris les publications).
Figure 13 : Le nom de catégorie sélectionné aléatoirement est affiché (cliquez pour afficher l’image en taille réelle)
Notes
Si la propriété s du DataSourceMode contrôle SqlDataSource avait été définie sur DataReader, la valeur de retour de la Select() méthode aurait dû être castée en IDataReader. Pour lire la CategoryName valeur de colonne de la première ligne, nous utilisons du code comme suit :
if (randomCategoryReader.Read())
{
string categoryName = randomCategoryReader["CategoryName"].ToString();
...
}
Avec SqlDataSource sélectionnant aléatoirement une catégorie, nous sommes prêts à ajouter le GridView qui répertorie les produits de catégorie.
Notes
Au lieu d’utiliser un contrôle Label Web pour afficher le nom de la catégorie, nous aurions pu ajouter un Contrôle FormView ou DetailsView à la page, le liant à SqlDataSource. Toutefois, l’utilisation de l’étiquette nous a permis d’explorer comment appeler par programmation l’instruction s Select() SqlDataSource et utiliser ses données résultantes dans le code.
Étape 5 : Affectation de valeurs de paramètre par programmation
Tous les exemples que nous avons vus jusqu’à présent dans ce tutoriel ont utilisé soit une valeur de paramètre codée en dur, soit une valeur provenant de l’une des sources de paramètres prédéfinies (une valeur de chaîne de requête, un contrôle Web sur la page, etc.). Toutefois, les paramètres du contrôle SqlDataSource peuvent également être définis par programme. Pour compléter notre exemple actuel, nous avons besoin d’un SqlDataSource qui retourne tous les produits appartenant à une catégorie spécifiée. Ce SqlDataSource aura un CategoryID paramètre dont la valeur doit être définie en fonction de la CategoryID valeur de colonne retournée par SqlDataSource RandomCategoryDataSource dans le Page_Load gestionnaire d’événements.
Commencez par ajouter un GridView à la page et liez-le à un nouveau SqlDataSource nommé ProductsByCategoryDataSource. Comme nous l’avons fait à l’étape 3, configurez SqlDataSource afin qu’il appelle la GetProductsByCategory procédure stockée. Laissez la liste déroulante Source du paramètre définie sur Aucun, mais n’entrez pas de valeur par défaut, car nous allons définir cette valeur par défaut par programme.
Figure 14 : Ne pas spécifier de source de paramètre ou de valeur par défaut (cliquez pour afficher l’image en taille réelle)
Une fois l’Assistant SqlDataSource terminé, le balisage déclaratif résultant doit ressembler à ce qui suit :
<asp:SqlDataSource ID="ProductsByCategoryDataSource" runat="server"
ConnectionString="<%$ ConnectionStrings:NORTHWNDConnectionString %>"
SelectCommand="GetProductsByCategory" SelectCommandType="StoredProcedure">
<SelectParameters>
<asp:Parameter Name="CategoryID" Type="Int32" />
</SelectParameters>
</asp:SqlDataSource>
Nous pouvons affecter le DefaultValue du CategoryID paramètre par programmation dans le gestionnaire d’événements Page_Load :
// Assign the ProductsByCategoryDataSource's
// CategoryID parameter's DefaultValue property
ProductsByCategoryDataSource.SelectParameters["CategoryID"].DefaultValue =
randomCategoryView[0]["CategoryID"].ToString();
Avec cet ajout, la page inclut un GridView qui affiche les produits associés à la catégorie sélectionnée de manière aléatoire.
Figure 15 : Ne pas spécifier de source de paramètre ou de valeur par défaut (cliquez pour afficher l’image en taille réelle)
Résumé
SqlDataSource permet aux développeurs de pages de définir des requêtes paramétrables dont les valeurs de paramètres peuvent être codées en dur, extraites de sources de paramètres prédéfinies ou affectées par programmation. Dans ce tutoriel, nous avons vu comment créer une requête paramétrable à partir de l’Assistant Configurer la source de données pour les requêtes SQL ad hoc et les procédures stockées. Nous avons également examiné l’utilisation de sources de paramètres codées en dur, un contrôle Web en tant que source de paramètres et la spécification programmatique de la valeur du paramètre.
Comme avec ObjectDataSource, SqlDataSource fournit également des fonctionnalités permettant de modifier ses données sous-jacentes. Dans le tutoriel suivant, nous allons voir comment définir INSERTdes instructions , UPDATEet DELETE avec SqlDataSource. Une fois ces instructions ajoutées, nous pouvons utiliser les fonctionnalités intégrées d’insertion, de modification et de suppression inhérentes aux contrôles GridView, DetailsView et FormView.
Bonne programmation !
À propos de l’auteur
Scott Mitchell, auteur de sept livres ASP/ASP.NET et fondateur de 4GuysFromRolla.com, travaille avec les technologies Web Microsoft depuis 1998. Scott travaille comme consultant indépendant, formateur et écrivain. Son dernier livre est Sams Teach Yourself ASP.NET 2.0 in 24 Heures. Il est accessible à l’adressemitchell@4GuysFromRolla.com . ou via son blog, qui peut être trouvé à l’adresse http://ScottOnWriting.NET.
Un merci spécial à
Cette série de tutoriels a été examinée par de nombreux réviseurs utiles. Les principaux réviseurs de ce tutoriel étaient Scott Clyde, Randell Schmidt et Ken Pespisa. Vous souhaitez consulter mes prochains articles MSDN ? Si c’est le cas, déposez-moi une ligne à mitchell@4GuysFromRolla.com.