Language-Integrated Query (LINQ) is a query syntax that defines a set of query operators that enable traversal, filter, and projection operations to be expressed in a declarative way in any .NET-based programming language. The data object can be an in-memory data collection or an object that represents data from a database. You can retrieve or modify the data without having to write SQL commands for each operation.

The LinqDataSource control enables you to use LINQ in an ASP.NET Web page by setting properties in markup text. The LinqDataSource control uses LINQ to SQL to automatically generate the data commands. For more information about LINQ to SQL, see LINQ to SQL.

When you are retrieving data from an in-memory data collection, you set the ContextTypeName property to the class that contains the data collection. You set the TableName property to the property or field that returns the data collection. For example, you might have a class named Person that contains a property named FavoriteCities that returns an array of string values. In that case, you set the ContextTypeName property to Person and set the TableName property to FavoriteCities.

When you are querying a database, you must first create entity classes that represent the database and its tables. You can use the Object Relational Designer or the SqlMetal.exe utility to generate these classes. You then set the ContextTypeName property to the class that represents the database and set the TableName property to the property that represents the database table.

The LinqDataSource control applies data operations in the following order:

1. Where (specify which data records to return).

2. Order By (sort).

3. Group By (aggregate data records that share values).

4. Order Groups By (sort grouped data).

5. Select (specify which fields or properties to return).

6. Auto-sort (sort data records by a property that the user has selected).

7. Auto-page (retrieve a subset of data records that were selected by the user).

You can add conditions to the Where property to filter the data records that are returned from a query. If the Where property is not set, the LinqDataSource control retrieves every record from the data object.

You use the OrderBy property to specify the names of properties from the returned data to sort by.

Note
When you use the LinqDataSource control with SQL Server 2000 or SQL Server Compact 3.5 and the AutoPage property is set to true, you must provide a value in the OrderBy property. By default, the AutoPage property is true. If you assign a value to the Select property, you must also include all identity columns in the list of properties that is returned in the query.

You use the GroupBy property to specify which properties are used to consolidate data records that have the same values. When you group data, you can include Key and It, which are dynamically created properties, in the Select property. The Key property refers to the values in the property or properties that were used to group the data. For example, if you group by a property named Category, the Key property will contain all unique values in the Category property. The It property refers to a collection of individual records in a grouping of data. You can iterate over the It property to retrieve the individual records that have been consolidated in the grouping operation. For example, if you group by a property named Category, the It property contains all the individual records that share a common value in the Category property.

You use the OrderGroupsBy property to specify the properties to use for sorting the grouped data. When you group data, the OrderBy property specifies how the individual records within the grouped data are sorted.

By default, the LinqDataSource control retrieves values for all the properties from a data object. You use the Select property to specify which properties to return if you want to work with a subset of available properties. The Select operation is applied after the Where, Order By, and Group By operations. Therefore, if you create an aliased name in a Select clause, the alias is not available in the other clauses.

You can specify whether data modifications are enabled by using the EnableDelete, EnableInsert, and EnableUpdate properties. The user interface for modifying data from a LinqDataSource control is typically provided through a data-bound control, such as a DetailsView control. In addition to setting EnableDelete, EnableInsert, or EnableUpdate to true, the following conditions are required to enable automatic data modifications:

• The Select property cannot be assigned a value.

• The GroupBy property cannot be assigned a value.

• The class that is assigned to the ContextTypeName property must derive from DataContext.

• The property that is assigned to the TableName property must derive from Table<(Of <(TEntity>)>).

You can restrict which properties are displayed in a data-bound control in two ways. You can either set the Select property to a subset of properties, or you can define the fields for a data-bound control by adding DataControlField controls. However, if you set the Select property, it means that automatic update, insert, and delete operations cannot be enabled. If you want to enable automatic data modifications while you work with a subset of available properties, do not set the Select property. Instead, retrieve all properties from the data object and manage which ones are displayed by using the data-bound control. When you use the DetailsView control or the GridView control, you must also set the AutoGenerateRows or AutoGenerateColumns properties to false. This prevents the data-bound control from automatically including buttons for editing and deleting the data. Any values that are not displayed in the data-bound control are stored in view state. They are passed unchanged to the data source when the data update is performed.

If you have to evaluate values at run time for ordering, filtering, or grouping values, you can add parameters to the WhereParameters, GroupByParameters, OrderGroupsByParameters, or OrderByParameters collections.

If you want to specify default values, you can add parameters to the InsertParameters collection.

If you want to examine or modify values before the data operation is executed, you can handle the Deleting, Inserting, Selecting, or Updating events. You can also handle these events in order to cancel the data operation or to examine validation errors that occurred when you set properties in the data class based on user input.

To examine values after the data operation has finished, handle the Deleted, Inserted, Selected, or Updated events.

You use the LinqDataSource control to retrieve data from a stored procedure by creating an event handler for the Selecting event. In the event handler, you call the method in the data context class that represents the stored procedure and set the result to the Result property of the LinqDataSourceSelectEventArgs object. If you want to enable automatic update, insert, and delete operations for the data, the type that is returned from the method must match the type that is specified in the TableName property. For more information about creating data context methods, see How to: Create DataContext Methods Mapped to Stored Procedures and Functions (O/R Designer).

LINQ (Language-Integrated Query) est une syntaxe de requête qui définit un jeu d'opérateurs de requête permettant d'exprimer de manière déclarative les opérations de parcours, de filtre et de projection dans tous les langages de programmation .NET. L'objet de données peut être une collection de données en mémoire ou un objet qui représente les données d'une base de données. Vous pouvez récupérer ou modifier les données sans écrire de commandes SQL pour chaque opération.

Le contrôle LinqDataSource vous permet d'utiliser la requête LINQ sur une page Web ASP.NET en définissant les propriétés dans le texte de balisage. Le contrôle LinqDataSource utilise la requête LINQ to SQL pour générer automatiquement les commandes de données. Pour plus d'informations sur LINQ to SQL, consultez LINQ to SQL.

Lorsque vous récupérez des données à partir d'une collection de données en mémoire, vous affectez à la propriété ContextTypeName la classe qui contient la collection de données. Vous affectez comme valeur à la propriété TableName la propriété ou le champ qui retourne la collection de données. Par exemple, une classe appelée Person peut contenir une propriété appelée FavoriteCities qui retourne un tableau de valeurs de chaîne. Dans ce cas, vous affectez la valeur Person à la propriété ContextTypeName et la valeur FavoriteCities à la propriété TableName.

Lorsque vous interrogez une base de données, vous devez d'abord créer des classes d'entité qui représentent la base de données et ses tables. Vous pouvez utiliser l'utilitaire Concepteur Objet/Relationnel ou SqlMetal.exe pour générer ces classes. Vous affectez ensuite à la propriété ContextTypeName la classe qui représente la base de données et vous affectez à la propriété TableName la propriété qui représente la table de base de données.

Le contrôle LinqDataSource applique les opérations de données dans l'ordre suivant :

1. Where (spécifie les enregistrements de données à retourner).

2. Order By (trie).

3. Group By (regroupe les enregistrements de données qui partagent des valeurs).

4. Order Groups By (trie les données groupées).

5. Select (spécifie les champs ou propriétés à retourner).

6. Auto-sort (trie les enregistrements de données selon une propriété sélectionnée par l'utilisateur).

7. Auto-page (récupère un sous-ensemble d'enregistrements de données sélectionnés par l'utilisateur).

Vous pouvez ajouter des conditions à la propriété Where pour filtrer les enregistrements de données retournés par une requête. Si la propriété Where n'est pas définie, le contrôle LinqDataSource récupère tous les enregistrements de l'objet de données.

Vous utilisez la propriété OrderBy pour spécifier le nom des propriétés à partir des données retournées à trier.

Remarque

Lorsque vous utilisez le contrôle LinqDataSource avec SQL Server 2000 ou SQL Server Compact 3.5 et que la propriété AutoPage a la valeur true, vous devez fournir une valeur dans la propriété OrderBy. Par défaut, la propriété AutoPage a la valeur true. Si vous assignez une valeur à la propriété Select, vous devez également inclure toutes les colonnes d'identité dans la liste de propriétés retournée dans la requête.

Vous utilisez la propriété GroupBy pour spécifier les propriétés utilisées pour consolider des enregistrements de données ayant les mêmes valeurs. Lorsque vous regroupez des données, vous pouvez inclure les propriétés créées dynamiquement Key et It dans la propriété Select. La propriété Key fait référence aux valeurs de la ou des propriétés utilisées pour regrouper les données. Par exemple, si vous effectuez un regroupement par une propriété appelée Category, la propriété Key contiendra toutes les valeurs uniques de la propriété Category. La propriété It fait référence à une collection d'enregistrements individuels dans un regroupement de données. Vous pouvez itérer sur la propriété It pour récupérer les enregistrements individuels consolidés dans l'opération de regroupement. Par exemple, si vous effectuez un regroupement par une propriété appelée Category, la propriété It contient tous les enregistrements individuels qui partagent une valeur commune dans la propriété Category.

Vous utilisez la propriété OrderGroupsBy pour spécifier les propriétés à utiliser pour le tri des données groupées. Lorsque vous groupez des données, la propriété OrderBy spécifie comment sont triés les enregistrements individuels dans les données groupées.

Par défaut, le contrôle LinqDataSource récupère les valeurs pour toutes les propriétés d'un objet de données. Vous utilisez la propriété Select pour spécifier les propriétés à retourner si vous souhaitez utiliser un sous-ensemble de propriétés disponibles. L'opération Select est appliquée après les opérations Where, Order By et Group By. Par conséquent, si vous créez un nom d'alias dans une clause Select, l'alias n'est pas disponible dans les autres clauses.

Vous pouvez spécifier si les modifications de données sont activées à l'aide des propriétés EnableDelete, EnableInsert et EnableUpdate. En général, l'interface utilisateur pour la modification des données d'un contrôle LinqDataSource est fournie via un contrôle lié aux données, tel qu'un contrôle DetailsView. En plus d'affecter la valeur true à EnableDelete, EnableInsert ou EnableUpdate, les conditions suivantes sont requises pour activer la modification automatique des données :

• Il est impossible d'assigner une valeur à la propriété Select.

• Il est impossible d'assigner une valeur à la propriété GroupBy.

• La classe assignée à la propriété ContextTypeName doit dériver de DataContext.

• La propriété assignée à la propriété TableName doit dériver de Table<(Of <(TEntity>)>).

Il existe deux manières de limiter le nombre de propriétés affichées dans un contrôle lié aux données. Vous pouvez affecter un sous-ensemble de propriétés à la propriété Select ou définir les champs d'un contrôle lié aux données en ajoutant des contrôles DataControlField. Toutefois, si vous définissez la propriété Select, les opérations automatiques de mise à jour, d'insertion et de suppression ne pourront pas être activées. Pour activer la modification automatique des données pendant que vous utilisez un sous-ensemble de propriétés disponibles, ne définissez pas la propriété Select. Récupérez plutôt toutes les propriétés depuis l'objet de données et gérez celles qui sont affichées à l'aide du contrôle lié aux données. Lorsque vous utilisez le contrôle DetailsView ou GridView, vous devez également affecter la valeur false à la propriété AutoGenerateRows ou AutoGenerateColumns. Cela empêche l'ajout automatique de boutons pour la modification et la suppression des données par le contrôle lié aux données. Les valeurs qui ne sont pas affichées dans le contrôle lié aux données sont stockées dans l'état d'affichage. Elles sont passées à la source de données sans être modifiées lors de la mise à jour des données.

Si vous devez évaluer des valeurs de classement, de filtrage ou de regroupement au moment de l'exécution, vous pouvez ajouter des paramètres aux collections WhereParameters, GroupByParameters, OrderGroupsByParameters ou OrderByParameters.

Si vous souhaitez spécifier des valeurs par défaut, vous pouvez ajouter des paramètres à la collection InsertParameters.

Si vous souhaitez examiner ou modifier des valeurs avant d'exécuter l'opération de données, vous pouvez gérer l'événement Deleting, Inserting, Selecting ou Updating. Vous pouvez également traiter ces événements afin d'annuler l'opération de données ou d'examiner les erreurs de validation qui se sont produites lorsque vous avez défini les propriétés de la classe de données sur la base de l'entrée d'utilisateur.

Pour examiner les valeurs une fois l'opération de données terminée, gérez l'événement Deleted, Inserted, Selected ou Updated.

Vous utilisez le contrôle LinqDataSource pour récupérer les données d'une procédure stockée en créant 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 à la propriété Result de l'objet LinqDataSourceSelectEventArgs. Si vous souhaitez activer les opérations de mise à jour, d'insertion et de suppression de données, le type retourné par la méthode doit correspondre au type spécifié dans la propriété TableName. 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).