Introduction à LINQ dans Visual BasicIntroduction to LINQ in Visual Basic

Language-Integrated Query (LINQ) ajoute des capacités de requête à Visual Basic et fournit des fonctionnalités puissantes et simples lorsque vous travaillez avec tous les types de données.Language-Integrated Query (LINQ) adds query capabilities to Visual Basic and provides simple and powerful capabilities when you work with all kinds of data. Au lieu d’envoyer une requête à une base de données à traiter ou utilisation de la syntaxe de requête différente pour chaque type de données que vous recherchez, LINQ introduit des requêtes en tant que partie du langage Visual Basic.Rather than sending a query to a database to be processed, or working with different query syntax for each type of data that you are searching, LINQ introduces queries as part of the Visual Basic language. Il utilise une syntaxe unifiée indépendamment du type de données.It uses a unified syntax regardless of the type of data.

LINQ vous permet d’interroger des données à partir d’une base de données SQL Server, XML, tableaux en mémoire et collections, les jeux de données ADO.NET ou toute autre source de données distante ou locale qui prend en charge LINQ.LINQ enables you to query data from a SQL Server database, XML, in-memory arrays and collections, ADO.NET datasets, or any other remote or local data source that supports LINQ. Vous faire tout cela avec des éléments de langage Visual Basic communs.You can do all this with common Visual Basic language elements. Vos requêtes sont écrites dans le langage Visual Basic, vos résultats de requête sont retournées en tant qu’objets fortement typés.Because your queries are written in the Visual Basic language, your query results are returned as strongly-typed objects. Ces objets prennent en charge IntelliSense, qui vous permet d'écrire du code plus rapidement et d'intercepter les erreurs dans vos requêtes au moment de la compilation plutôt qu'au moment de l'exécution.These objects support IntelliSense, which enables you to write code faster and catch errors in your queries at compile time instead of at run time. Les requêtes LINQ peuvent être utilisées comme source de requêtes supplémentaires pour affiner les résultats.LINQ queries can be used as the source of additional queries to refine results. Elles peuvent également être liées à des contrôles pour que les utilisateurs puissent afficher et modifier facilement vos résultats de requête.They can also be bound to controls so that users can easily view and modify your query results.

Par exemple, l'exemple de code suivant affiche une requête LINQ qui retourne une liste de clients à partir d'une collection et les regroupe en fonction de leur emplacement.For example, the following code example shows a LINQ query that returns a list of customers from a collection and groups them based on their location.

' Obtain a list of customers.
Dim customers As List(Of Customer) = GetCustomers()

' Return customers that are grouped based on country.
Dim countries = From cust In customers
                Order By cust.Country, cust.City
                Group By CountryName = cust.Country
                Into CustomersInCountry = Group, Count()
                Order By CountryName

' Output the results.
For Each country In countries
    Debug.WriteLine(country.CountryName & " count=" & country.Count)

    For Each customer In country.CustomersInCountry
        Debug.WriteLine("   " & customer.CompanyName & "  " & customer.City)
    Next
Next

' Output:
'   Canada count=2
'      Contoso, Ltd  Halifax
'      Fabrikam, Inc.  Vancouver
'   United States count=1
'      Margie's Travel  Redmond

Exécution des exemplesRunning the examples

Pour exécuter les exemples dans l’introduction et dans le Structure d’une requête LINQ section, incluez le code suivant, qui renvoie des listes de clients et commandes.To run the examples in the introduction and in the Structure of a LINQ Query section, include the following code, which returns lists of customers and orders.

' Return a list of customers.
Private Function GetCustomers() As List(Of Customer)
    Return New List(Of Customer) From
        {
            New Customer With {.CustomerID = 1, .CompanyName = "Contoso, Ltd", .City = "Halifax", .Country = "Canada"},
            New Customer With {.CustomerID = 2, .CompanyName = "Margie's Travel", .City = "Redmond", .Country = "United States"},
            New Customer With {.CustomerID = 3, .CompanyName = "Fabrikam, Inc.", .City = "Vancouver", .Country = "Canada"}
        }
End Function

' Return a list of orders.
Private Function GetOrders() As List(Of Order)
    Return New List(Of Order) From
        {
            New Order With {.CustomerID = 1, .Amount = "200.00"},
            New Order With {.CustomerID = 3, .Amount = "600.00"},
            New Order With {.CustomerID = 1, .Amount = "300.00"},
            New Order With {.CustomerID = 2, .Amount = "100.00"},
            New Order With {.CustomerID = 3, .Amount = "800.00"}
        }
End Function

' Customer Class.
Private Class Customer
    Public Property CustomerID As Integer
    Public Property CompanyName As String
    Public Property City As String
    Public Property Country As String
End Class

' Order Class.
Private Class Order
    Public Property CustomerID As Integer
    Public Property Amount As Decimal
End Class

Fournisseurs LINQLINQ providers

Un fournisseur LINQ mappe vos requêtes LINQ de Visual Basic à la source de données en cours d’interrogation.A LINQ provider maps your Visual Basic LINQ queries to the data source being queried. Quand vous écrivez une requête LINQ, le fournisseur prend cette requête et la traduit en commandes que la source de données sera en mesure d'exécuter.When you write a LINQ query, the provider takes that query and translates it into commands that the data source will be able to execute. Le fournisseur convertit également des données de la source en objets qui composent votre résultat de la requête.The provider also converts data from the source to the objects that make up your query result. Enfin, il convertit des objets en données quand vous envoyez des mises à jour à la source de données.Finally, it converts objects to data when you send updates to the data source.

Visual Basic inclut les fournisseurs LINQ suivants.Visual Basic includes the following LINQ providers.

FournisseurProvider DescriptionDescription
LINQ to ObjectsLINQ to Objects Le fournisseur LINQ to Objects vous permet d'interroger des collections et des tableaux en mémoire.The LINQ to Objects provider enables you to query in-memory collections and arrays. Si un objet prend en charge l'interface IEnumerable ou IEnumerable<T>, le fournisseur LINQ to Objects vous permet de l'interroger.If an object supports either the IEnumerable or IEnumerable<T> interface, the LINQ to Objects provider enables you to query it.

Vous pouvez activer le fournisseur LINQ to Objects en important le System.Linq espace de noms, qui est importé par défaut pour tous les projets Visual Basic.You can enable the LINQ to Objects provider by importing the System.Linq namespace, which is imported by default for all Visual Basic projects.

Pour plus d’informations sur le fournisseur LINQ to Objects, consultez LINQ to Objects.For more information about the LINQ to Objects provider, see LINQ to Objects.
LINQ to SQLLINQ to SQL Le fournisseur LINQ to SQL vous permet d'interroger et de modifier des données dans une base de données SQL Server.The LINQ to SQL provider enables you to query and modify data in a SQL Server database. Cela facilite le mappage du modèle objet d'une application aux tables et objets d'une base de données.This makes it easy to map the object model for an application to the tables and objects in a database.

Visual Basic facilite l’utilisation de LINQ to SQL en incluant le Concepteur Objet/Relationnel (Concepteur O/R).Visual Basic makes it easier to work with LINQ to SQL by including the Object Relational Designer (O/R Designer). Ce concepteur est utilisé pour créer un modèle objet dans une application qui effectue un mappage aux objets d'une base de données.This designer is used to create an object model in an application that maps to objects in a database. Le Concepteur O/R également fournit des fonctionnalités permettant de mapper des procédures stockées et des fonctions à la DataContext objet, qui gère la communication avec la base de données et stocke l’état de contrôles d’accès concurrentiel optimiste.The O/R Designer also provides functionality to map stored procedures and functions to the DataContext object, which manages communication with the database and stores state for optimistic concurrency checks.

Pour plus d’informations sur le fournisseur LINQ to SQL, consultez LINQ to SQL.For more information about the LINQ to SQL provider, see LINQ to SQL. Pour plus d’informations sur le concepteur objet/relationnel, consultez outils LINQ to SQL dans Visual Studio.For more information about the Object Relational Designer, see LINQ to SQL Tools in Visual Studio.
LINQ to XMLLINQ to XML Le fournisseur LINQ to XML vous permet d'interroger et de modifier du code XML.The LINQ to XML provider enables you to query and modify XML. Vous pouvez modifier du code XML en mémoire ou le charger à partir d'un fichier, mais également l'enregistrer dans un fichier.You can modify in-memory XML, or you can load XML from and save XML to a file.

En outre, le fournisseur LINQ to XML active des littéraux XML et les propriétés d’axe XML qui vous permettent d’écrire du code XML directement dans votre code Visual Basic.Additionally, the LINQ to XML provider enables XML literals and XML axis properties that enable you to write XML directly in your Visual Basic code. Pour plus d’informations, consultez XML.For more information, see XML.
LINQ to DataSetLINQ to DataSet Le fournisseur LINQ to DataSet vous permet d’interroger et mettre à jour des données dans un dataset ADO.NET.The LINQ to DataSet provider enables you to query and update data in an ADO.NET dataset. Vous pouvez ajouter la puissance de LINQ aux applications qui utilisent des groupes de données afin de simplifier et d'étendre vos capacités de requête, d'agrégation et de mise à jour des données dans votre dataset.You can add the power of LINQ to applications that use datasets in order to simplify and extend your capabilities for querying, aggregating, and updating the data in your dataset.

Pour plus d’informations, consultez LINQ to DataSet.For more information, see LINQ to DataSet.

Structure d’une requête LINQStructure of a LINQ query

Une requête LINQ, souvent appelé un expression de requête, se compose d’une combinaison de clauses de requête qui identifient les sources de données et les variables d’itération pour la requête.A LINQ query, often referred to as a query expression, consists of a combination of query clauses that identify the data sources and iteration variables for the query. Une expression de requête peut également inclure des instructions de tri, de filtrage, de regroupement et de jonction ou des calculs applicables aux données sources.A query expression can also include instructions for sorting, filtering, grouping, and joining, or calculations to apply to the source data. La syntaxe de l'expression de requête ressemble à la syntaxe de SQL ; par conséquent, une grande partie de cette syntaxe vous semblera familière.Query expression syntax resembles the syntax of SQL; therefore, you may find much of the syntax familiar.

Une expression de requête commence par une clause From.A query expression starts with a From clause. Cette clause identifie les données sources d'une requête et les variables utilisées pour faire individuellement référence à chaque élément des données sources.This clause identifies the source data for a query and the variables that are used to refer to each element of the source data individually. Ces variables sont appelées variables de plage ou variables d’itération.These variables are named range variables or iteration variables. La clause From est nécessaire pour une requête, à l'exception des requêtes Aggregate, où la clause From est facultative.The From clause is required for a query, except for Aggregate queries, where the From clause is optional. Après avoir identifié la portée et la source de la requête dans les clauses From ou Aggregate, vous pouvez inclure toute combinaison de clauses de requête pour affiner la requête.After the scope and source of the query are identified in the From or Aggregate clauses, you can include any combination of query clauses to refine the query. Pour plus d’informations sur les clauses de requête, consultez les opérateurs de requête LINQ de Visual Basic plus loin dans cette rubrique.For details about query clauses, see Visual Basic LINQ Query Operators later in this topic. Par exemple, la requête suivante identifie une collection de sources de données client comme variable customers et une variable d’itération appelée cust.For example, the following query identifies a source collection of customer data as the customers variable, and an iteration variable named cust.

Dim customers = GetCustomers()

Dim queryResults = From cust In customers

For Each result In queryResults
    Debug.WriteLine(result.CompanyName & "  " & result.Country)
Next

' Output:
'   Contoso, Ltd  Canada
'   Margie's Travel  United States
'   Fabrikam, Inc.  Canada

Cet exemple représente une requête valide en elle-même ; toutefois, la requête gagne en puissance quand vous ajoutez davantage de clauses de requête pour affiner le résultat.This example is a valid query by itself; however, the query becomes far more powerful when you add more query clauses to refine the result. Par exemple, vous pouvez ajouter une clause Where pour filtrer le résultat en fonction d'une ou plusieurs valeurs.For example, you can add a Where clause to filter the result by one or more values. Les expressions de requête forment une ligne unique de code ; il vous suffit d'ajouter des clauses de requête supplémentaires à la fin de la requête.Query expressions are a single line of code; you can just append additional query clauses to the end of the query. Vous pouvez décomposer une requête sur plusieurs lignes de texte pour améliorer la lisibilité à l’aide d’un trait de soulignement (_) caractère de continuation de ligne.You can break up a query across multiple lines of text to improve readability by using the underscore (_) line-continuation character. L'exemple de code suivant illustre une requête qui inclut une clause Where.The following code example shows an example of a query that includes a Where clause.

Dim queryResults = From cust In customers
                   Where cust.Country = "Canada"

Autre clause de requête performante, la clause Select vous permet de retourner uniquement des champs sélectionnés de la source de données.Another powerful query clause is the Select clause, which enables you to return only selected fields from the data source. Les requêtes LINQ retournent des collections énumérables d'objets fortement typés.LINQ queries return enumerable collections of strongly typed objects. Une requête peut retourner une collection de types anonymes ou nommés.A query can return a collection of anonymous types or named types. Vous pouvez utiliser la clause Select pour retourner uniquement un champ de la source de données.You can use the Select clause to return only a single field from the data source. Dans ce cas, le type de la collection retournée est le type de ce champ unique.When you do this, the type of the collection returned is the type of that single field. Vous pouvez également utiliser la clause Select pour retourner plusieurs champs de la source de données.You can also use the Select clause to return multiple fields from the data source. Dans ce cas, le type de la collection retournée est un nouveau type anonyme.When you do this, the type of the collection returned is a new anonymous type. Vous pouvez également faire correspondre les champs retournés par la requête aux champs d'un type nommé spécifié.You can also match the fields returned by the query to the fields of a specified named type. L’exemple de code suivant affiche une expression de requête qui retourne une collection de types anonymes dont les membres sont remplis des données des champs sélectionnés de la source de données.The following code example shows a query expression that returns a collection of anonymous types that have members populated with data from the selected fields from the data source.

Dim queryResults = From cust In customers
               Where cust.Country = "Canada"
               Select cust.CompanyName, cust.Country

Les requêtes LINQ peuvent également être utilisées pour combiner plusieurs sources de données et retourner un résultat unique.LINQ queries can also be used to combine multiple sources of data and return a single result. Cette opération peut être effectuée à l'aide d'une ou plusieurs clauses From ou en utilisant les clauses de requête Join ou Group Join.This can be done with one or more From clauses, or by using the Join or Group Join query clauses. L'exemple de code suivant illustre une expression de requête qui combine des données de client et de commande et retourne une collection de types anonymes contenant ces deux types de données.The following code example shows a query expression that combines customer and order data and returns a collection of anonymous types containing customer and order data.

Dim customers = GetCustomers()
Dim orders = GetOrders()

Dim queryResults = From cust In customers, ord In orders
           Where cust.CustomerID = ord.CustomerID
           Select cust, ord

For Each result In queryResults
    Debug.WriteLine(result.ord.Amount & "  " & result.ord.CustomerID & "  " & result.cust.CompanyName)
Next

' Output:
'   200.00  1  Contoso, Ltd
'   300.00  1  Contoso, Ltd
'   100.00  2  Margie's Travel
'   600.00  3  Fabrikam, Inc.
'   800.00  3  Fabrikam, Inc.

Vous pouvez utiliser la clause Group Join pour créer un résultat de requête hiérarchique contenant une collection d'objets customer.You can use the Group Join clause to create a hierarchical query result that contains a collection of customer objects. Chaque objet customer possède une propriété contenant une collection de toutes les commandes de ce client.Each customer object has a property that contains a collection of all orders for that customer. L'exemple de code suivant affiche une expression de requête qui combine des données client/commande sous forme de résultat hiérarchique et retourne une collection de types anonymes.The following code example shows a query expression that combines customer and order data as a hierarchical result and returns a collection of anonymous types. La requête retourne un type qui inclut une propriété CustomerOrders contenant une collection de données de commande pour le client.The query returns a type that includes a CustomerOrders property that contains a collection of order data for the customer. Il inclut également une propriété OrderTotal qui contient la somme des totaux pour toutes les commandes de ce client.It also includes an OrderTotal property that contains the sum of the totals for all the orders for that customer. (Cette requête est équivalente à une JOINTURE EXTERNE GAUCHE.)(This query is equivalent to a LEFT OUTER JOIN.)

Dim customers = GetCustomers()
Dim orders = GetOrders()

Dim queryResults = From cust In customers
                   Group Join ord In orders On
                     cust.CustomerID Equals ord.CustomerID
                     Into CustomerOrders = Group,
                          OrderTotal = Sum(ord.Amount)
                   Select cust.CompanyName, cust.CustomerID,
                          CustomerOrders, OrderTotal

For Each result In queryResults
    Debug.WriteLine(result.OrderTotal & "  " & result.CustomerID & "  " & result.CompanyName)
    For Each ordResult In result.CustomerOrders
        Debug.WriteLine("   " & ordResult.Amount)
    Next
Next

' Output:
'   500.00  1  Contoso, Ltd
'      200.00
'      300.00
'   100.00  2  Margie's Travel
'      100.00
'   1400.00  3  Fabrikam, Inc.
'      600.00
'      800.00

Il existe plusieurs opérateurs de requête LINQ supplémentaires qui vous permettent de créer des expressions de requête puissantes.There are several additional LINQ query operators that you can use to create powerful query expressions. La section suivante de cette rubrique présente les différentes clauses de requête que vous pouvez inclure dans une expression de requête.The next section of this topic discusses the various query clauses that you can include in a query expression. Pour plus d’informations sur les clauses de requête de Visual Basic, consultez requêtes.For details about Visual Basic query clauses, see Queries.

Opérateurs de requête LINQ de Visual BasicVisual Basic LINQ query operators

Les classes de l'espace de noms System.Linq et des autres espaces de noms qui prennent en charge les requêtes LINQ incluent des méthodes que vous pouvez appeler pour créer et affiner les requêtes en fonction des besoins de votre application.The classes in the System.Linq namespace and the other namespaces that support LINQ queries include methods that you can call to create and refine queries based on the needs of your application. Visual Basic inclut des mots clés pour les clauses de requête courants suivants.Visual Basic includes keywords for the following common query clauses. Pour plus d’informations sur les clauses de requête de Visual Basic, consultez requêtes.For details about Visual Basic query clauses, see Queries.

Clause FromFrom clause

Soit un From clause ou Aggregate clause est requise pour lancer une requête.Either a From clause or an Aggregate clause is required to begin a query. Une clause From spécifie une collection de sources et une variable d'itération pour une requête.A From clause specifies a source collection and an iteration variable for a query. Exemple :For example:

' Returns the company name for all customers for which
' the Country is equal to "Canada".
Dim names = From cust In customers
            Where cust.Country = "Canada"
            Select cust.CompanyName

Select (clause)Select clause

Facultatif.Optional. Un Select clause déclare un ensemble de variables d’itération pour une requête.A Select clause declares a set of iteration variables for a query. Exemple :For example:

' Returns the company name and ID value for each
' customer as a collection of a new anonymous type.
Dim customerList = From cust In customers
                   Select cust.CompanyName, cust.CustomerID

Si une clause Select n'est pas spécifiée, les variables d'itération de la requête se composent des variables d'itération spécifiées par la clause From ou Aggregate.If a Select clause is not specified, the iteration variables for the query consist of the iteration variables specified by the From or Aggregate clause.

Where (clause)Where clause

Facultatif.Optional. Un Where clause spécifie une condition de filtrage pour une requête.A Where clause specifies a filtering condition for a query. Exemple :For example:

' Returns all product names for which the Category of
' the product is "Beverages".
Dim names = From product In products
            Where product.Category = "Beverages"
            Select product.Name

Clause Order By]Order By clause]

| Facultatif.|Optional. Un Order By clause Spécifie l’ordre de tri pour les colonnes dans une requête.An Order By clause specifies the sort order for columns in a query. Exemple :For example:

' Returns a list of books sorted by price in 
' ascending order.
Dim titlesAscendingPrice = From b In books
                           Order By b.price

Join (clause)Join clause

Facultatif.Optional. Un Join clause combine deux collections en une collection unique.A Join clause combines two collections into a single collection. Exemple :For example:

' Returns a combined collection of all of the 
' processes currently running and a descriptive
' name for the process taken from a list of 
' descriptive names.
Dim processes = From proc In Process.GetProcesses
                Join desc In processDescriptions
                  On proc.ProcessName Equals desc.ProcessName
                Select proc.ProcessName, proc.Id, desc.Description

Group By (clause)Group By clause

Facultatif.Optional. Un Group By clause regroupe les éléments d’un résultat de requête.A Group By clause groups the elements of a query result. Il peut être utilisé pour appliquer des fonctions d’agrégation à chaque groupe.It can be used to apply aggregate functions to each group. Exemple :For example:

' Returns a list of orders grouped by the order date
' and sorted in ascending order by the order date.
Dim orderList = From order In orders
                Order By order.OrderDate
                Group By OrderDate = order.OrderDate
                Into OrdersByDate = Group

Group Join (clause)Group Join clause

Facultatif.Optional. Un Group Join clause combine deux collections en une collection hiérarchique unique.A Group Join clause combines two collections into a single hierarchical collection. Exemple :For example:

' Returns a combined collection of customers and
' customer orders.
Dim customerList = From cust In customers
                   Group Join ord In orders On
                     cust.CustomerID Equals ord.CustomerID
                   Into CustomerOrders = Group,
                        TotalOfOrders = Sum(ord.Amount)
                   Select cust.CompanyName, cust.CustomerID,
                          CustomerOrders, TotalOfOrders

Aggregate (clause)Aggregate clause

Soit un Aggregate clause ou un From clause est requise pour lancer une requête.Either an Aggregate clause or a From clause is required to begin a query. Une clause Aggregate applique une ou plusieurs fonctions d’agrégation à une collection.An Aggregate clause applies one or more aggregate functions to a collection. Par exemple, vous pouvez utiliser le Aggregate clause pour calculer une somme de tous les éléments retournés par une requête, comme dans l’exemple suivant.For example, you can use the Aggregate clause to calculate a sum for all the elements returned by a query, as the following example does.

' Returns the sum of all order amounts.
Dim orderTotal = Aggregate order In orders
                 Into Sum(order.Amount)

Vous pouvez également utiliser la clause Aggregate pour modifier une requête.You can also use the Aggregate clause to modify a query. Par exemple, vous pouvez utiliser la clause Aggregate pour effectuer un calcul sur une collection de requêtes connexe.For example, you can use the Aggregate clause to perform a calculation on a related query collection. Exemple :For example:

' Returns the customer company name and largest 
' order amount for each customer.
Dim customerMax = From cust In customers
                  Aggregate order In cust.Orders
                  Into MaxOrder = Max(order.Amount)
                  Select cust.CompanyName, MaxOrder

Let (clause)Let clause

Facultatif.Optional. Un Let clause calcule une valeur et l’assigne à une nouvelle variable dans la requête.A Let clause computes a value and assigns it to a new variable in the query. Exemple :For example:

' Returns a list of products with a calculation of
' a ten percent discount.
Dim discountedProducts = From prod In products
                         Let Discount = prod.UnitPrice * 0.1
                         Where Discount >= 50
                         Select prod.Name, prod.UnitPrice, Discount

Distinct (clause)Distinct clause

Facultatif.Optional. Un Distinct clause restreint les valeurs de la variable d’itération actuelle pour éliminer les valeurs en double dans les résultats de la requête.A Distinct clause restricts the values of the current iteration variable to eliminate duplicate values in query results. Exemple :For example:

' Returns a list of cities with no duplicate entries.
Dim cities = From item In customers
             Select item.City
             Distinct

Skip (clause)Skip clause

Facultatif.Optional. Un Skip clause ignore un nombre spécifié d’éléments dans une collection, puis retourne les éléments restants.A Skip clause bypasses a specified number of elements in a collection and then returns the remaining elements. Exemple :For example:

' Returns a list of customers. The first 10 customers
' are ignored and the remaining customers are
' returned.
Dim customerList = From cust In customers
                   Skip 10

SkipWhile (clause)Skip While clause

Facultatif.Optional. Un Skip While clause ignore les éléments d’une collection tant qu’une condition spécifiée est true , puis retourne les éléments restants.A Skip While clause bypasses elements in a collection as long as a specified condition is true and then returns the remaining elements. Exemple :For example:

' Returns a list of customers. The query ignores all
' customers until the first customer for whom
' IsSubscriber returns false. That customer and all
' remaining customers are returned.
Dim customerList = From cust In customers
                   Skip While IsSubscriber(cust)

Take (clause)Take clause

Facultatif.Optional. Un Take clause retourne un nombre spécifié d’éléments contigus à partir du début d’une collection.A Take clause returns a specified number of contiguous elements from the start of a collection. Exemple :For example:

' Returns the first 10 customers.
Dim customerList = From cust In customers
                   Take 10

Take While (clause)Take While clause

Facultatif.Optional. Un Take While clause inclut les éléments d’une collection tant qu’une condition spécifiée est true et ignore les éléments restants.A Take While clause includes elements in a collection as long as a specified condition is true and bypasses the remaining elements. Exemple :For example:

' Returns a list of customers. The query returns
' customers until the first customer for whom 
' HasOrders returns false. That customer and all 
' remaining customers are ignored.
Dim customersWithOrders = From cust In customers
                          Order By cust.Orders.Count Descending
                          Take While HasOrders(cust)

Utiliser des fonctionnalités de requête LINQ supplémentairesUse additional LINQ query features

Vous pouvez utiliser des fonctionnalités de requête LINQ supplémentaires en appelant des membres des types énumérables et requêtables fournis par LINQ.You can use additional LINQ query features by calling members of the enumerable and queryable types provided by LINQ. Vous pouvez utiliser ces fonctions supplémentaires en appelant un opérateur de requête particulier sur le résultat d'une expression de requête.You can use these additional capabilities by calling a particular query operator on the result of a query expression. Par exemple, l’exemple suivant utilise la Enumerable.Union méthode pour combiner les résultats de deux requêtes dans le résultat d’une seule requête.For example, the following example uses the Enumerable.Union method to combine the results of two queries into one query result. Il utilise la méthode Enumerable.ToList pour retourner le résultat de la requête sous forme de liste générique.It uses the Enumerable.ToList method to return the query result as a generic list.

Public Function GetAllCustomers() As List(Of Customer)
    Dim customers1 = From cust In domesticCustomers
    Dim customers2 = From cust In internationalCustomers

    Dim customerList = customers1.Union(customers2)

    Return customerList.ToList()
End Function

Pour plus d’informations sur les fonctions LINQ supplémentaires, consultez vue d’ensemble des opérateurs de requête Standard.For details about additional LINQ capabilities, see Standard Query Operators Overview.

Se connecter à une base de données à l’aide de LINQ to SQLConnect to a database by using LINQ to SQL

En Visual Basic, vous identifiez les objets de base de données SQL Server, tels que des tables, vues et procédures stockées, que vous souhaitez accéder au fichier SQL à l’aide de LINQ.In Visual Basic, you identify the SQL Server database objects, such as tables, views, and stored procedures, that you want to access by using a LINQ to SQL file. Un fichier LINQ to SQL possède une extension .dbml.A LINQ to SQL file has an extension of .dbml.

Lorsque vous avez une connexion valide à une base de données SQL Server, vous pouvez ajouter un Classes LINQ to SQL modèle d’élément à votre projet.When you have a valid connection to a SQL Server database, you can add a LINQ to SQL Classes item template to your project. Le Concepteur Objet Relationnel (Concepteur O/R) s'affiche alors.This will display the Object Relational Designer (O/R designer). Le Concepteur O/R vous permet de faire glisser les éléments que vous souhaitez accéder dans votre code à partir de la Explorateur de serveurs/Database Explorer sur l’aire du concepteur.The O/R Designer enables you to drag the items that you want to access in your code from the Server Explorer/Database Explorer onto the designer surface. Le fichier LINQ to SQL ajoute un objet DataContext à votre projet.The LINQ to SQL file adds a DataContext object to your project. Cet objet inclut des propriétés et des collections pour les tables et vues auxquelles vous souhaitez accéder, et aux méthodes des procédures stockées que vous souhaitez appeler.This object includes properties and collections for the tables and views that you want access to, and methods for the stored procedures that you want to call. Après avoir enregistré vos modifications dans le fichier LINQ to SQL (.dbml), vous pouvez accéder à ces objets dans votre code en référençant l'objet DataContext défini par le Concepteur O/R.After you have saved your changes to the LINQ to SQL (.dbml) file, you can access these objects in your code by referencing the DataContext object that is defined by the O/R Designer. L'objet DataContext de votre projet est nommé d'après le nom de votre fichier LINQ to SQL.The DataContext object for your project is named based on the name of your LINQ to SQL file. Par exemple, un fichier LINQ to SQL nommé Northwind.dbml créera un objet DataContext nommé NorthwindDataContext.For example, a LINQ to SQL file that is named Northwind.dbml will create a DataContext object named NorthwindDataContext.

Pour obtenir des exemples avec des instructions détaillées, consultez Comment : Interroger une base de données et Comment : Appeler une procédure stockée.For examples with step-by-step instructions, see How to: Query a Database and How to: Call a Stored Procedure.

Fonctionnalités de Visual Basic qui prennent en charge LINQVisual Basic features that support LINQ

Visual Basic inclut d’autres fonctionnalités notables qui facilitent l’utilisation de LINQ et réduisent la quantité de code que vous devez écrire pour effectuer des requêtes LINQ.Visual Basic includes other notable features that make the use of LINQ simple and reduce the amount of code that you must write to perform LINQ queries. Notamment :These include the following:

  • Les types anonymes, qui permettent de créer un nouveau type basé sur un résultat de requête.Anonymous types, which enable you to create a new type based on a query result.

  • Variables implicitement typées, qui permettent de différer la spécification d’un type et laisser le compilateur le déduire le type en fonction du résultat de requête.Implicitly typed variables, which enable you to defer specifying a type and let the compiler infer the type based on the query result.

  • Méthodes d’extension, vous permettent d’étendre un type existant avec vos propres méthodes sans modifier le type lui-même.Extension methods, which enable you to extend an existing type with your own methods without modifying the type itself.

Pour plus d’informations, consultez fonctionnalités Visual Basic que prise en charge LINQ.For details, see Visual Basic Features That Support LINQ.

Exécution de requête différée et immédiateDeferred and immediate query execution

L'exécution d'une requête est distincte de sa création.Query execution is separate from creating a query. Après avoir créé une requête, son exécution est déclenchée par un mécanisme distinct.After a query is created, its execution is triggered by a separate mechanism. Une requête peut être exécutée dès qu’il est défini (l’exécution immédiate), ou la définition peut être stockée et la requête peut être exécutée ultérieurement (exécution différée).A query can be executed as soon as it is defined (immediate execution), or the definition can be stored and the query can be executed later (deferred execution).

Par défaut, quand vous créez une requête, cette dernière ne s'exécute pas immédiatement.By default, when you create a query, the query itself does not execute immediately. À la place, la définition de la requête est stockée dans la variable utilisée pour référencer le résultat de la requête.Instead, the query definition is stored in the variable that is used to reference the query result. Quand vous accédez à la variable de résultat de la requête ultérieurement dans le code, par exemple, dans une boucle For…Next, la requête est exécutée.When the query result variable is accessed later in code, such as in a For…Next loop, the query is executed. Ce processus est appelé exécution différée.This process is referred to as deferred execution.

Les requêtes peuvent également être exécutées quand elles sont définies, ce qui est appelé l’exécution immédiate.Queries can also be executed when they are defined, which is referred to as immediate execution. Vous pouvez déclencher l'exécution immédiate en appliquant une méthode qui requiert l'accès aux éléments individuels du résultat de la requête.You can trigger immediate execution by applying a method that requires access to individual elements of the query result. L'inclusion d'une fonction d'agrégation, telle que Count, Sum, Average, Min ou Max peut engendrer un tel résultat.This can be the result of including an aggregate function, such as Count, Sum, Average, Min, or Max. Pour plus d’informations sur les fonctions d’agrégation, consultez Aggregate, Clause.For more information about aggregate functions, see Aggregate Clause.

L'utilisation de la méthode ToList ou ToArray force également l'exécution immédiate.Using the ToList or ToArray methods will also force immediate execution. Cela peut être utile quand vous souhaitez exécuter immédiatement la requête et mettre en cache les résultats.This can be useful when you want to execute the query immediately and cache the results. Pour plus d’informations sur ces méthodes, consultez conversion des Types de données.For more information about these methods, see Converting Data Types.

Pour plus d’informations sur l’exécution des requêtes, consultez écrire votre première requête LINQ.For more information about query execution, see Writing Your First LINQ Query.

XML en Visual BasicXML in Visual Basic

Les fonctionnalités XML en Visual Basic incluent des littéraux XML et les propriétés d’axe XML, qui vous permettent de facilement créer, accédant, interroger et modifier du code XML dans votre code.The XML features in Visual Basic include XML literals and XML axis properties, which enable you easily to create, access, query, and modify XML in your code. Les littéraux XML vous permettent d'écrire directement en XML dans votre code.XML literals enable you to write XML directly in your code. Le compilateur Visual Basic traite le XML comme un objet de donnée de première classe.The Visual Basic compiler treats the XML as a first-class data object.

L'exemple de code suivant montre comment créer un élément XML, accéder à ses sous-éléments et attributs, et interroger son contenu à l'aide de LINQ.The following code example shows how to create an XML element, access its sub-elements and attributes, and query the contents of the element by using LINQ.

' Place Imports statements at the top of your program.  
Imports <xmlns:ns="http://SomeNamespace">

Module Sample1

    Sub SampleTransform()

        ' Create test by using a global XML namespace prefix. 

        Dim contact = 
            <ns:contact>
                <ns:name>Patrick Hines</ns:name>
                <ns:phone ns:type="home">206-555-0144</ns:phone>
                <ns:phone ns:type="work">425-555-0145</ns:phone>
            </ns:contact>

        Dim phoneTypes = 
          <phoneTypes>
              <%= From phone In contact.<ns:phone> 
                  Select <type><%= phone.@ns:type %></type> 
              %>
          </phoneTypes>

        Console.WriteLine(phoneTypes)
    End Sub

End Module

Pour plus d’informations, consultez XML.For more information, see XML.

RubriqueTopic DescriptionDescription
XMLXML Décrit les fonctionnalités XML dans Visual Basic qui peuvent être interrogées et qui vous permettent d’inclure du XML en tant qu’objets de données de première classe dans votre code Visual Basic.Describes the XML features in Visual Basic that can be queried and that enable you to include XML as first-class data objects in your Visual Basic code.
RequêtesQueries Fournit des informations de référence sur les clauses de requête qui sont disponibles dans Visual Basic.Provides reference information about the query clauses that are available in Visual Basic.
LINQ (Language Integrated Query)LINQ (Language-Integrated Query) Inclut des informations générales, un guide de programmation et des exemples de requêtes LINQ.Includes general information, programming guidance, and samples for LINQ.
LINQ to SQLLINQ to SQL Inclut des informations générales, un guide de programmation et des exemples de LINQ to SQL.Includes general information, programming guidance, and samples for LINQ to SQL.
LINQ to ObjectsLINQ to Objects Inclut des informations générales, un guide de programmation et des exemples de LINQ to Objects.Includes general information, programming guidance, and samples for LINQ to Objects.
LINQ to ADO.NET (page de portail)LINQ to ADO.NET (Portal Page) Inclut des liens vers des informations générales, Guide de programmation et exemples de LINQ to ADO.NET.Includes links to general information, programming guidance, and samples for LINQ to ADO.NET.
LINQ to XMLLINQ to XML Inclut des informations générales, un guide de programmation et des exemples de LINQ to XML.Includes general information, programming guidance, and samples for LINQ to XML.

Comment et les rubriques de procédure pas à pasHow to and walkthrough topics

Guide pratique pour Interroger une base de donnéesHow to: Query a Database

Guide pratique pour Appeler une procédure stockéeHow to: Call a Stored Procedure

Guide pratique pour Modifier des données dans une base de donnéesHow to: Modify Data in a Database

Guide pratique pour Combiner des données avec des jointuresHow to: Combine Data with Joins

Guide pratique pour Trier les résultats de requêteHow to: Sort Query Results

Guide pratique pour Filtrer les résultats de la requêteHow to: Filter Query Results

Guide pratique pour Nombre, somme ou moyenne des donnéesHow to: Count, Sum, or Average Data

Guide pratique pour Rechercher la valeur minimale ou maximale dans un résultat de requêteHow to: Find the Minimum or Maximum Value in a Query Result

Guide pratique pour affecter des procédures stockées pour effectuer des mises à jour, des insertions et des suppressions (Concepteur O/R)How to: Assign stored procedures to perform updates, inserts, and deletes (O/R Designer)

Chapitre 17 : LINQ dans de programmation Visual Basic 2008Chapter 17: LINQ in Programming Visual Basic 2008

Voir aussiSee also