Vue d'ensemble du contrôle serveur Web LinqDataSource
Mise à jour : novembre 2007
Le contrôle LinqDataSource expose LINQ (Language-Integrated Query) aux développeurs Web à travers l'architecture de contrôle de source de données ASP.NET. LINQ fournit un modèle de programmation unifié pour interroger et mettre à jour des données de différents types de sources de données et étend directement les fonctions de données des langages C# et Visual Basic. LINQ simplifie l'interaction entre programmation orientée objet et données relationnelles en appliquant les principes de programmation orientée objet aux données relationnelles. Pour plus d'informations sur LINQ, consultez LINQ (Language-Integrated Query).
En utilisant le balisage déclaratif, vous pouvez créer un contrôle LinqDataSource qui se connecte aux données d'une base de données ou d'une collection de données en mémoire telle qu'un tableau. Dans le texte déclaratif, vous pouvez écrire toutes les conditions requises pour récupérer, filtrer, ordonner et grouper les données. En récupérant des données d'une table de base de données SQL, vous pouvez également configurer un contrôle LinqDataSource pour gérer la mise à jour, l'insertion et la suppression de données. Le contrôle s'en charge sans que vous ayez besoin d'écrire les commandes SQL pour effectuer ces tâches. La classe LinqDataSource fournit également un modèle d'événement qui vous permet de gérer des scénarios personnalisés.
Cette rubrique contient les sections suivantes :
Scénarios
Contexte
Exemples de code
Référence de classe
Scénarios
Vous utilisez le contrôle LinqDataSource pour créer une page Web qui récupère ou modifie des données en exploitant les avantages du modèle de programmation unifié offert par LINQ. Vous pouvez simplifier le code d'une page Web en permettant au contrôle LinqDataSource de créer automatiquement les commandes pour agir sur les données.
Retour au début
Contexte
Le contrôle LinqDataSource vous fournit un moyen de connecter un contrôle de données à toute une variété de sources de données, notamment les données de base de données, les classes source de données et les collections en mémoire. Le contrôle LinqDataSource vous permet de spécifier des tâches de récupération de style base de données (sélection, filtrage, groupement et classement) sur tous ces types de sources de données. Vous pouvez spécifier des tâches de modification (mise à jour, suppression et insertion) sur les tables de base de données.
Vous pouvez connecter le contrôle LinqDataSource à tout type de collection de données stocké dans un champ ou une propriété public. Le balisage et le code déclaratifs pour exécuter des opérations de données sont les mêmes pour toutes les sources de données. Vous n'avez pas à utiliser de syntaxe différente pour agir sur les données d'une table de base de données ou d'une collection de données tel qu'un tableau.
Pour une présentation du contrôle LinqDataSource, consultez Procédure pas à pas : récupération, mise à jour, insertion et suppression de données avec les contrôles LinqDataSource et DetailsView.
Connexion aux données d'une base de données
Pour agir sur les données d'une base de données, vous ne connectez pas directement le contrôle LinqDataSource à la base de données. Vous agissez en revanche sur les classes d'entité qui représentent la base de données et les tables. Vous pouvez générer les classes d'entité à l'aide d'Concepteur Objet/Relationnel ou en exécutant l'utilitaire SqlMetal.exe. Pour plus d'informations, consultez Concepteur Objet/Relationnel (Concepteur O/R) ou Outil de génération de code (SqlMetal.exe). Les classes d'entité que vous créez se trouvent, en général, dans le dossier App_Code de l'application Web. L'Concepteur O/R ou l'utilitaire SqlMetal.exe génère une classe qui représente la base de données et une classe pour chaque table dans la base de données.
La classe qui représente la base de données est chargée de récupérer et définir des valeurs dans la source de données. Le contrôle LinqDataSource lit et définit les propriétés dans la classe qui représente la table de données. Pour prendre en charge les opérations de mise à jour, d'insertion et de suppression, la classe de base de données doit dériver de la classe DataContext et la classe de table doit faire référence à une classe Table<TEntity>.
Vous connectez le contrôle LinqDataSource à une classe de base de données en donnant à la propriété ContextTypeName le nom de la classe qui représente la base de données. Vous connectez le contrôle LinqDataSource à une table particulière en donnant à la propriété TableName le nom de la classe qui représente la table de données. Par exemple, pour vous connecter à la table Contacts de la base de données AdventureWorks, vous affectez à la propriété ContextTypeName la valeur AdventureWorksDataContext (ou le nom que vous spécifiez pour l'objet de base de données, quel qu'il soit). Affectez à la propriété TableName la valeur Contacts. L'exemple suivant illustre le balisage d'un LinqDataSource contrôle qui se connecte à la base de données AdventureWorks.
<asp:LinqDataSource
ContextTypeName="AdventureWorksDataContext"
TableName="Contacts"
ID="LinqDataSource1"
>
</asp:LinqDataSource>
L'exemple n'illustre pas la classe générée par le Concepteur O/R, parce que le code généré est trop long pour cette rubrique. Toutefois, le code généré doit exister pour permettre à l'exemple de fonctionner. Pour plus d'informations, consultez Génération de code dans LINQ to SQL.
Connexion aux données d'une collection en mémoire
Lorsque vous vous connectez à une collection de données en mémoire telle qu'un tableau, vous affectez à la propriété ContextTypeName le nom de la classe qui contient la collection. Affectez à la propriété TableName le nom de la collection elle-même.
L'exemple suivant illustre une classe qui contient un tableau de valeurs de chaîne.
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;
}
}
}
L'exemple suivant illustre un LinqDataSource contrôle qui lit la liste de styles de films de la classe dans l'exemple précédent. Pour récupérer le tableau des styles, affectez à la propriété ContextTypeName la valeur MovieLibrary et à la propriété TableName la valeur AvailableGenres.
<asp:LinqDataSource
ContextTypeName="MovieLibrary"
TableName="AvailableGenres"
ID="LinqDataSource1"
>
</asp:LinqDataSource>
Utilisation du contrôle LinqDataSource avec les contrôles liés aux données
Pour afficher les données d'un contrôle LinqDataSource, vous pouvez lier un contrôle lié aux données à un contrôle LinqDataSource. Par exemple, vous liez un contrôle DetailsView, un contrôle GridView ou un contrôle ListView à un contrôle LinqDataSource. Pour ce faire, affectez à la propriété DataSourceID du contrôle lié aux données l'ID du contrôle LinqDataSource. L'exemple suivant illustre un contrôle GridView qui affiche toutes les données d'un contrôle LinqDataSource.
<asp:LinqDataSource
ContextTypeName="AdventureWorksDataContext"
TableName="Contacts"
ID="LinqDataSource1">
</asp:LinqDataSource>
<asp:GridView
ID="GridView1"
DataSourceID="LinqDataSource1" >
</asp:GridView>
Le contrôle lié aux données crée automatiquement l'interface utilisateur pour afficher les données du contrôle LinqDataSource. Il peut également fournir l'interface pour trier et paginer les données. Lorsque les modifications de données sont activées, un contrôle lié aux données fournit l'interface pour mettre à jour, insérer et supprimer des enregistrements.
Vous pouvez restreindre les données (propriétés) affichées en configurant le contrôle lié aux données pour ne pas générer automatiquement des champs de contrôle de données. Vous pouvez définir ensuite explicitement ces champs dans le contrôle lié aux données. Le contrôle LinqDataSource récupère toutes les propriétés, mais le contrôle lié aux données affiche uniquement les propriétés que vous spécifiez. L'exemple suivant illustre un GridView contrôle qui affiche uniquement les propriétés Name et StandardCost de la table Products dans la base de données AdventureWorks. La propriété AutoGenerateColumns a la valeur 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>
Si vous devez restreindre les propriétés retournées dans la requête, définissez-les en configurant la propriété Select du contrôle LinqDataSource.
Comparaison du contrôle LinqDataSource à d'autres contrôles de source de données
En utilisant le contrôle LinqDataSource, vous pouvez écrire moins de code pour exécuter des opérations de données en utilisant les contrôles SqlDataSource ou ObjectDataSource. Le contrôle LinqDataSource peut déduire des informations à propos de la source de données à laquelle vous vous connectez et créer dynamiquement les commandes pour sélectionner, mettre à jour, insérer et supprimer des données. Avec le contrôle LinqDataSource, vous n'avez en outre à apprendre qu'un seul modèle de programmation pour agir sur les différents types de sources de données.
Comparaison du contrôle SqlDataSource
Contrairement au contrôle SqlDataSource, qui fonctionne uniquement avec les tables de bases de données relationnelle, le contrôle LinqDataSource permet de se connecter aux données stockées dans les collections en mémoire. Lorsque vous utilisez le contrôle SqlDataSource, vous devez définir explicitement les propriétés SelectCommand, UpdateCommand, InsertCommand et DeleteCommand aux requêtes SQL. Toutefois, vous n'avez pas besoin de définir explicitement ces commandes avec le contrôle LinqDataSource, parce que le contrôle LinqDataSource utilise LINQ to SQL pour les créer automatiquement. Pour modifier les colonnes sélectionnées dans une source de données, vous n'avez pas à écrire une commande de sélection SQL complète. À la place, vous fournissez le nom des colonnes à renvoyer dans la requête à l'aide de la propriété Select.
Lorsque vous mettez à jour ou que vous insérez des données, vous n'avez pas à créer de paramètres pour chaque valeur qui sera enregistrée dans la base de données. Le contrôle LinqDataSource peut créer des commandes de mise à jour qui incluent les valeurs appropriées faisant correspondre la propriété DataField aux noms de propriété dans la classe d'entité.
Comparaison du contrôle ObjectDataSource
Lorsque vous utilisez le contrôle ObjectDataSource, vous devez créer manuellement l'objet qui représente les données puis écrire les méthodes pour agir sur les données. Vous devez ensuite faire correspondre les propriétés SelectMethod, UpdateMethod, InsertMethod et DeleteMethod aux méthodes qui exécutent ces fonctions. Dans le contrôle LinqDataSource, vous utilisez l'Concepteur O/R pour créer automatiquement les classes qui représentent les données. Vous n'avez pas à écrire de code pour spécifier les colonnes qui existent dans la table de base de données ou comment sélectionner, mettre à jour, insérer et supprimer des données. Vous pouvez également utiliser le contrôle LinqDataSource pour agir directement sur une collection de données comme un tableau. Dans ce cas, vous ne devez pas créer une classe pour gérer la logique d'interaction avec la collection de données.
Sélection de données
Si vous ne spécifiez pas de valeur pour la propriété Select du contrôle LinqDataSource, toutes les propriétés dans la classe source de données sont récupérées. Par exemple, le contrôle LinqDataSource retourne une valeur pour chaque colonne dans une table de base de données.
Vous pouvez restreindre les propriétés récupérées dans la source de données en donnant à la propriété Select le nom des propriétés requises. Pour renvoyer une seule propriété, affectez-la à la propriété Select. Par exemple, pour retourner uniquement les valeurs de la colonne City d'une table de base de données, affectez à la propriété Select la valeur City. Le contrôle LinqDataSource retourne une collection List<T> qui contient les éléments correctement tapés de la propriété. Si la propriété City est tapée sous forme de texte (chaîne), la sélection de la propriété City retourne une collection List<T> de valeurs de chaîne.
Pour récupérer uniquement certaines des propriétés de la classe de données, vous devez utiliser la fonction new dans la propriété Select et spécifier les colonnes à retourner. La fonction new est requise parce que vous créez dynamiquement une classe qui contient uniquement les propriétés que vous avez spécifiées. Par exemple, pour récupérer les propriétés City et PostalCode d'une source de données qui contient des adresses complètes, affectez à la propriété Select la valeur new(City, PostalCode). Le contrôle LinqDataSource retourne une collection List<T> qui contient des instances d'une classe qui inclut ces propriétés.
Vous n'avez pas à utiliser la fonction new lorsque vous sélectionnez une seule propriété, parce que l'objet retourné est une simple collection de valeurs pour cette propriété. Toutefois, pour de multiples propriétés, le contrôle LinqDataSource doit créer une classe nouvelle contenant les propriétés que vous spécifiez.
Calcul de valeurs avec la clause Select
Vous pouvez calculer des valeurs dans une clause Select. Par exemple, pour calculer le total d'une ligne d'articles dans une commande, affectez à la propriété Select la valeur new(SalesOrderDetailID, OrderQty * UnitPrice As LineItemTotal). Le mot clé As vous permet d'assigner un nom (alias) à la valeur calculée. Pour plus d'informations, consultez Procédure pas à pas : sélection et filtrage d'un sous-ensemble de données avec les contrôles LinqDataSource et GridView.
L'exemple suivant illustre l'utilisation d'un contrôle LinqDataSource pour récupérer un sous-ensemble de données. Dans l'exemple, la propriété Select est définie de manière à assigner un alias aux valeurs retournées et calculer une valeur.
<asp:LinqDataSource
ContextTypeName="ExampleDataContext"
TableName="OrderDetails"
Select="new(SalesOrderDetailID As DetailID,
OrderQty * UnitPrice As LineItemTotal,
DateCreated As SaleDate)"
ID="LinqDataSource1"
>
</asp:LinqDataSource>
Filtrage des données avec la clause Where
Vous pouvez filtrer les données retournées pour récupérer uniquement les enregistrements qui répondent aux critères particuliers. Pour ce faire, définissez les conditions à réunir pour inclure en enregistrement dans les données retournées à l'aide de la propriété Where. Si vous ne spécifiez pas de valeur pour la propriété Where, tous les enregistrements dans la source de données sont récupérés. Pour filtrer, créez une expression de filtre qui utilise une comparaison pour déterminer si un enregistrement doit être inclus. La comparaison peut être réalisée par rapport à une valeur statique ou à une valeur variable que vous spécifiez avec un espace réservé de paramètre.
Création d'une clause Where avec valeurs statiques
Pour comparer la valeur d'une propriété à une valeur statique, vous définissez la propriété Where à l'aide de la propriété et de la valeur statique. Par exemple, pour retourner uniquement les enregistrements qui ont une valeur ListPrice supérieure à 1 000, affectez à la propriété Where la valeur ListPrice > 1000.
Vous pouvez utiliser l'opérateur && ou and pour effectuer une comparaison AND logique et l'opérateur || ou or pour une comparaison OR logique. Par exemple, affectez à la propriété Where la valeur ListPrice > 1000 || UnitCost > 500 || DaysToManufacture > 3 pour retourner les enregistrements ayant une valeur ListPrice supérieure à 1 000, une valeur UnitCost supérieure à 500 ou une valeur DaysToManufacture supérieure à 3. Pour spécifier que toutes les conditions doivent être remplies pour retourner un enregistrement, affectez à la propriété Where la valeur ListPrice > 1000 && UnitCost > 500 && DaysToManufacture > 3.
Pour comparer des valeurs de chaîne, vous devez délimiter les conditions par des guillemets simples et la valeur littérale par des guillemets doubles. Par exemple, affectez à la propriété Where la valeur 'Category = "Sports"' pour récupérer uniquement les enregistrements dont la colonne Category contient « Sports ».
L'exemple suivant illustre un contrôle LinqDataSource qui récupère des données filtrées à la fois par une valeur de chaîne et par une valeur numérique.
<asp:LinqDataSource
ContextTypeName="ExampleDataContext"
TableName="Product"
Where='Category = "Sports" && Weight < 10'
ID="LinqDataSource1"
</asp:LinqDataSource>
Création d'une clause Where paramétrée
Pour comparer une valeur de propriété à une valeur connue uniquement au moment de l'exécution, définissez un paramètre dans la collection de propriétés WhereParameters. Par exemple, pour filtrer à l'aide d'une valeur fournie par l'utilisateur, vous devez créer un paramètre qui représente la valeur en question. Le contrôle LinqDataSource crée la clause Where avec la valeur actuelle du paramètre.
L'exemple suivant illustre un contrôle LinqDataSource qui récupère des données en fonction de la sélection de l'utilisateur dans un contrôle nommé 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>
Le contrôle LinqDataSource crée automatiquement la clause Where lorsque vous affectez à la propriété AutoGenerateWhereClause la valeur true. Cette option est utile avec plusieurs paramètres, parce que vous n'avez pas à spécifier chaque condition dans la propriété Where. À la place, vous ajoutez les paramètres dans la collection de propriétés WhereParameters et le contrôle LinqDataSource crée une clause Where qui inclut chaque paramètre.
Lorsque vous affectez à la propriété AutoGenerateWhereClause la valeur true, le nom des paramètres doit s'aligner sur le nom des propriétés correspondantes. Par exemple, pour vérifier la valeur d'un paramètre par rapport à la propriété Category, le paramètre doit être nommé Category. Toutes les comparaisons sont des comparaisons d'égalité ; vous ne pouvez pas tester si une valeur est supérieure ou inférieure à celle du paramètre. Lorsque vous spécifiez plusieurs paramètres dans la collection WhereParameters, ils sont liés par un AND logique.
Pour vérifier des conditions d'inégalité ou de lien avec un OU logique, vous affectez à la propriété AutoGenerateWhereClause la valeur false. Vous pouvez ensuite définir les conditions dans la propriété Where. Vous devez inclure un espace réservé pour chaque paramètre dans la propriété Where.
L'exemple suivant montre comment tester une inégalité lors du filtrage des données.
<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>
Pour plus d'informations, consultez AutoGenerateWhereClause.
Groupement et agrégation des données
Vous pouvez grouper des données pour les consolider dans les enregistrements qui ont des valeurs communes dans une ou plusieurs colonnes. Pour ce faire, affectez à la propriété GroupBy le nom des propriétés de celles qui doivent être utilisées pour le regroupement des données. Par exemple, pour regrouper les enregistrements d'une table d'adresses qui contiennent la même ville, définissez GroupBy à City.
Vous pouvez calculer des valeurs sur les données groupées, telles que la moyenne ou la somme d'une propriété, en utilisant des fonctions d'agrégation avec la propriété GroupBy. Vous récupérez les valeurs utilisées pour le groupement en référençant l'objet Key.
L'exemple suivant illustre le groupement des données à l'aide d'une propriété nommée ProductCategory. Les valeurs groupées sont récupérées en incluant Key dans la propriété Select. Les méthodes d'agrégation Average et Count sont également inclues dans la propriété Select.
<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>
Vous pouvez récupérer les enregistrements individuels qui appartiennent à un groupe à l'aide du mot clé It. Pour plus d'informations, consultez Comment : grouper et regrouper des données à l'aide du contrôle LinqDataSource.
Méthodes d'agrégation
Le tableau suivant répertorie les méthodes d'agrégation disponibles avec le contrôle LinqDataSource.
Fonction d'agrégation |
Description |
|---|---|
Count() |
Retourne le nombre total d'enregistrements pour un groupe de données. |
Average(colonne) |
Retourne la valeur moyenne de la colonne spécifiée pour tous les enregistrements retournés. |
Sum(colonne) |
Retourne la somme de toutes les valeurs dans la colonne spécifiée pour tous les enregistrements retournés. |
Max(colonne) |
Retourne la valeur maximum de la colonne spécifiée pour tous les enregistrements retournés. |
Min(colonne) |
Retourne la valeur minimum de la colonne spécifiée pour tous les enregistrements retournés. |
Where(condition) |
Filtre les enregistrements retournés d'après la condition spécifiée. |
Any() |
Détermine si la collection contient des enregistrements. |
All(condition) |
Détermine si tous les enregistrements dans la collection satisfont la condition spécifiée. |
- Pour plus d'informations, consultez Comment : grouper et regrouper des données à l'aide du contrôle LinqDataSource.
Mise à jour, insertion et suppression de données
Vous pouvez configurer le contrôle LinqDataSource pour créer automatiquement les commandes de mise à jour, insertion et suppression de données. Pour activer les mises à jour automatiques, affectez à la propriété EnableUpdate, EnableInsert ou EnableDelete la valeur true.
.gif "Remarque") Remarque : |
|---|
Pour que le contrôle LinqDataSource génère automatiquement des commandes de mise à jour, vous ne pouvez pas définir la propriété Select. Lorsque la propriété Select est définie, le contrôle LinqDataSource retourne un objet qui est une instance d'une classe dynamique. Il ne s'agit pas d'une instance de la classe qui représente la table de base de données. Par conséquent, la classe dynamique ne peut pas déduire comment mettre à jour les valeurs dans la table de base de données. |
Pour définir par programme toutes les valeurs à mettre à jour, vous pouvez créer des gestionnaires d'événements pour les événements Updating, Inserting ou Deleting. Dans le gestionnaire, vous pouvez définir une valeur avant le démarrage de l'opération de données. Pour plus d'informations, consultez Comment mettre à jour, insérer et supprimer des données avec le contrôle LinqDataSource.
Tri des données
L'objet LinqDataSource prend en charge deux façons de trier les données d'une requête. Vous pouvez trier les données par valeurs statiques lorsque vous développez la page Web. Vous pouvez également permettre aux utilisateurs de trier dynamiquement les données au moment de l'exécution.
Pour classer les données d'après des valeurs statiques, assignez le nom d'une propriété à la propriété OrderBy. Pour laisser les utilisateurs trier les données au moment de l'exécution, affectez à la propriété AutoSort la valeur true (valeur par défaut). Passez ensuite une expression de tri au contrôle LinqDataSource. Un contrôle lié aux données tel que le contrôle GridView passe une expression de tri lorsque sa propriété AllowSorting a la valeur true.
Pour spécifier plusieurs noms de colonne dans la propriété OrderBy, séparez-les par une virgule. Par exemple, si vous spécifiez « LastName, FirstName », les enregistrements seront classés en premier par LastName et ceux qui contiennent des valeurs correspondantes dans le champ LastName, par FirstName.
Vous pouvez utiliser les deux méthodes de tri pour renvoyer en premier les données dans un ordre particulier, puis permettre aux utilisateurs de modifier cet ordre. Dans ce cas, affectez à la propriété AutoSort la valeur true et affectez à la propriété OrderBy le nom d'une propriété.
L'exemple suivant illustre un LinqDataSource contrôle qui classe d'abord les enregistrements par LastName, puis par FirstName, et enfin par MiddleName. Le contrôle LinqDataSource est également configuré pour permettre aux utilisateurs de trier les lignes dynamiquement. Vous pouvez lier un contrôle de données, tel que le contrôle GridView, au contrôle LinqDataSource pour afficher les données et permettre aux utilisateurs de spécifier un ordre de tri.
<asp:LinqDataSource
ContextTypeName="ExampleDataContext"
TableName="Contact"
OrderBy="LastName, FirstName, MiddleName"
AutoSort="true"
ID="LinqDataSource1"
</asp:LinqDataSource>
Utilisation de paramètres pour évaluer des valeurs dynamiquement
Lorsque vous utilisez le contrôle LinqDataSource, vous spécifiez les valeurs à interpréter ou à convertir au moment de l'exécution à l'aide de paramètres. Contrairement à d'autres contrôles de source de données, vous ne devez pas spécifier chaque valeur qui fait partie de l'opération de mise à jour, d'insertion ou de suppression. Le contrôle LinqDataSource définit automatiquement ces valeurs et utilise LINQ to SQL pour générer les commandes SQL. Vous spécifiez uniquement des paramètres pour fournir des valeurs par défaut ou convertir des valeurs vides. Vous pouvez également utiliser les collections de paramètres WhereParameters et OrderByParameters pour classer ou filtrer les données selon des valeurs au moment de l'exécution. Pour plus d'informations sur LINQ to SQL, consultez LINQ to SQL.
Le contrôle LinqDataSource contient les collections de paramètres suivantes :
Pour obtenir un exemple d'utilisation de la collection WhereParameters afin de permettre dynamiquement aux utilisateurs de filtrer les enregistrements retournés par un contrôle LinqDataSource, consultez Filtrage des données avec la clause Where précédemment dans cette rubrique.
Contrôle d'accès concurrentiel
Si vous permettez aux utilisateurs de mettre à jour ou de supprimer des données, vous pourrez souhaiter vous assurer que les données dans la source de données n'ont pas été modifiées par un autre processus avant de continuer la mise à jour ou la suppression. Si vous ne vérifiez pas si les valeurs ont changé, vous risquez de remplacer involontairement des valeurs définies par un autre processus et de laisser les données dans un état incohérent.
Le contrôle LinqDataSource vous permet de déterminer si les données ont changé. Le contrôle stocke les valeurs de données d'origine dans l'état d'affichage sur la page Web. Lorsque la page Web est publiée, elle contient à la fois les valeurs d'origine et toutes les valeurs mises à jour. Le contrôle LinqDataSource utilise LINQ to SQL pour comparer les valeurs d'origine aux valeurs actuelles dans la source de données. Si les valeurs sont les mêmes, les données n'ont pas changé et LINQ to SQL met à jour ou supprime les données. Si les données ont changé, LINQ to SQL lève une exception.
Vous pouvez spécifier manuellement les valeurs de colonne à vérifier en définissant la propriété UpdateCheck d'une colonne dans la classe d'entité. Lorsque l'Concepteur O/R génère le code d'une table de base de données, il donne à la propriété UpdateCheck la valeur Never pour les colonnes gérées par la base de données. La valeur de toute autre colonne est Always, qui signifie qu'elle est toujours incluse dans un contrôle d'accès concurrentiel. Affectez à la propriété UpdateCheck la valeur Never pour empêcher cette colonne d'être incluse dans le contrôle d'accès concurrentiel. En donnant à la propriété la valeur Never, vous empêchez également les valeurs de cette colonne d'être stockées dans l'état d'affichage. Affectez à la propriété UpdateCheck la valeur WhenChanged pour vérifier la valeur par rapport à la source de données uniquement lorsque l'utilisateur a modifié cette valeur.
Si vous devez stocker des données sensibles dans l'état d'affichage, vous devez chiffrer l'état d'affichage. Pour plus d'informations, consultez Encrypt ViewState in ASP.NET 2.0
| Remarque : |
|---|
Le chiffrement de l'état d'affichage peut affecter les performances d'une page Web. |
Optimisation des contrôles d'accès concurrentiel pour les données SQL Server
Stocker de nombreuses valeurs dans l'état d'affichage peut augmenter la taille d'une page Web et potentiellement exposer des données sensibles aux utilisateurs. En travaillant sur les données d'une base de données SQL Server, vous pouvez améliorer la performance et sécurité d'une page Web en créant une colonne contenant une valeur d'horodatage dans la base de données. SQL Server met automatiquement à jour une colonne d'horodatage chaque fois l'enregistrement est modifié. Dans ce cas, le contrôle LinqDataSource ne doit pas comparer chaque colonne dans un enregistrement pour déterminer si l'enregistrement a changé. À la place, il peut comparer uniquement l'horodatage dans l'état d'affichage avec l'horodatage dans la base de données.
Si vous ajoutez une colonne d'horodatage dans une base de données SQL Server, l'Concepteur O/R crée automatiquement la classe d'entité afin que seul l'horodatage soit stocké dans l'état d'affichage. Pour plus d'informations, consultez Procédure pas à pas : utilisation d'un horodatage avec le contrôle LinqDataSource pour vérifier l'intégrité des données.
Utilisation des procédures stockées
Pour utiliser le contrôle LinqDataSource pour récupérer les données d'une procédure stockée, vous créez un gestionnaire d'événements pour l'événement Selecting. Dans le gestionnaire d'événements, vous appelez la méthode dans la classe de contexte de données qui représente la procédure stockée, puis vous affectez le résultat de la procédure stockée à la propriété Result de l'objet LinqDataSourceSelectEventArgs. Si vous souhaitez activer les opérations automatiques de mise à jour, d'insertion et de suppression, le type retourné par la méthode doit correspondre au type spécifié dans la propriété TableName.
L'exemple suivant montre comment assigner à la propriété Result l'objet retourné par une méthode qui représente une procédure stockée.
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();
}
Pour plus d'informations sur la création des méthodes de contexte des données, consultez Procédure : créer des méthodes DataContext mappées à des procédures stockées et à des fonctions (Concepteur O/R).
Validation des valeurs lors de la modification de données
Avant de modifier un enregistrement de données, il peut s'avérer nécessaire de valider les valeurs. En règle générale, vous incluez les contrôles de validation dans la classe de données, pas dans la page Web. Ainsi, grâce à la centralisation des contrôles de validation dans la classe de données, vous vous assurez que les contrôles de validation peuvent être utilisés indépendamment du mode d'utilisation de la classe de données. Pour plus d'informations sur l'ajout de la validation à une classe, consultez Procédure : ajouter une validation à des classes d'entité et Procédure pas à pas : ajout d'une validation à des classes d'entité.
Les exceptions de validation sont levées avant la mise à jour, l'insertion ou la suppression de données. Pour récupérer les exceptions de validation, vous pouvez créer des gestionnaires pour les événements Inserting, Updating et Deleting. Pour plus d'informations, consultez les classes LinqDataSourceUpdateEventArgs, LinqDataSourceInsertEventArgs et LinqDataSourceDeleteEventArgs.
Événements de contrôle de LinqDataSource
Le contrôle LinqDataSource déclenche des événements à des points spécifiques pendant son traitement pour vous permettre de personnaliser la sélection, l'insertion, la mise à jour ou la suppression des données.
Lorsque le contrôle LinqDataSource sélectionne des données, il génère les événements suivants (dans l'ordre indiqué) :
ContextCreating (si nécessaire)
ContextCreated (si nécessaire)
Si vous créez par programme l'objet contexte dans l'événement Selecting et vous n'avez pas à stocker de valeurs d'origine dans l'état d'affichage, les événements ContextCreating et ContextCreated sont ignorés.
Le contrôle LinqDataSource génère les événements suivants (dans l'ordre indiqué) lorsqu'il met à jour, insère ou supprime des données :
L'ordre des événements pour les opérations de mise à jour, de suppression et d'insertion est différent de celui des opérations de sélection. En effet, le contrôle LinqDataSource doit obtenir une instance de l'objet de donnée et passer cette instance aux événements Inserting, Updating ou Deleting.
Les événements Selecting, Inserting, Updating et Deleting sont déclenchés avant d'exécuter l'opération de données. Vous créez des gestionnaires d'événements pour ces événements afin de valider et de modifier des valeurs avant l'opération, ou d'annuler l'opération. Par exemple, si la base de données contient une colonne qui enregistre le dernier utilisateur a avoir modifié un enregistrement, vous pouvez utiliser l'événement Updating pour définir la valeur de nom d'utilisateur par programme.
Les événements Selected, Inserted, Updated et Deleted sont déclenchés après la fin de l'opération. Vous créez des gestionnaires d'événements pour ces événements afin d'intercepter des exceptions et d'examiner des valeurs retournées par l'opération.
L'événement ContextCreating est déclenché avant que le contrôle LinqDataSource crée le type spécifié dans la propriété ContextTypeName. Vous gérez cet événement pour créer le type de contexte par programme. Par exemple, vous pouvez le faire si la méthode de constructeur du type de contexte requiert des paramètres. L'événement ContextCreated est déclenché une fois que le type spécifié dans la propriété ContextTypeName a été créé. Vous gérez cet événement pour intercepter des exceptions ou examiner l'objet contexte créé. L'événement ContextDisposing est déclenché avant que le contrôle LinqDataSource supprime le type de contexte spécifié dans la propriété ContextTypeName. Vous gérez cet événement pour annuler la suppression d'un objet très cher à créer (en temps ou en ressources). Vous pouvez également utiliser l'événement pour exécuter un nettoyage spécifique à l'objet avant que l'objet soit détruit.
Retour au début
Exemples de code
Comment : grouper et regrouper des données à l'aide du contrôle LinqDataSource
Comment mettre à jour, insérer et supprimer des données avec le contrôle LinqDataSource
Retour au début
Référence de classe
Le tableau suivant répertorie les classes clés relatives à la classe LinqDataSource.
Membre |
Description |
|---|---|
Applique des expressions LINQ à une source de données et représente les données pour les contrôles liés aux données. |
|
Prend en charge le contrôle LinqDataSource et fournit une interface pour les contrôles liés aux données pour exécuter des opérations avec des objets de données. Cette classe est destinée à l'origine pour être utilisée par les contrôles liés aux données et non comme objet programmable dans le code de page. |
|
Fournit des données pour l'événement ContextDisposing. |
|
Fournit des données pour l'événement ContextCreating. |
|
Fournit des données pour l'événement Deleting. |
|
Fournit des données pour l'événement Inserting. |
|
Fournit des données pour l'événement Selecting. |
|
Fournit des données pour les événements ContextCreated, Deleted, Inserted, Selected et Updated. |
|
Fournit des données pour l'événement Updating. |
Retour au début