Présentation de LINQ en Visual Basic

2025-06-19

Language-Integrated Query (LINQ) ajoute des fonctionnalités de requête à Visual Basic et fournit des fonctionnalités simples et puissantes lorsque vous travaillez avec tous les types de données. Au lieu d’envoyer une requête à une base de données à traiter ou d’utiliser une syntaxe de requête différente pour chaque type de données que vous recherchez, LINQ introduit des requêtes dans le cadre du langage Visual Basic. Il utilise une syntaxe unifiée quel que soit le type de données.

LINQ vous permet d’interroger des données à partir d’une base de données SQL Server, d’un xml, d’un tableau en mémoire et de collections, d’ADO.NET jeux de données ou d’une autre source de données distante ou locale prenant en charge LINQ. Pour ce faire, vous pouvez utiliser des éléments de langage Visual Basic courants. Étant donné que vos requêtes sont écrites dans le langage Visual Basic, vos résultats de requête sont retournés en tant qu’objets fortement typés. Ces objets prennent en charge IntelliSense, ce qui vous permet d’écrire du code plus rapidement et d’intercepter des erreurs dans vos requêtes au moment de la compilation au lieu du moment de l’exécution. Les requêtes LINQ peuvent être utilisées comme source de requêtes supplémentaires pour affiner les résultats. Ils peuvent également être liés aux contrôles afin que les utilisateurs puissent facilement afficher et modifier vos résultats de requête.

Par exemple, l’exemple de code suivant montre une requête LINQ qui retourne une liste de clients à partir d’une collection et les regroupe en fonction de leur emplacement.

' 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 exemples

Pour exécuter les exemples dans l’introduction et dans la structure d’une section requête LINQ , incluez le code suivant, qui retourne des listes de clients et de commandes.

' 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 LINQ

Un fournisseur LINQ mappe vos requêtes LINQ Visual Basic à la source de données interrogée. Lorsque vous écrivez une requête LINQ, le fournisseur accepte cette requête et le convertit en commandes que la source de données sera en mesure d’exécuter. Le fournisseur convertit également les données de la source en objets qui composent votre résultat de requête. Enfin, il convertit les objets en données lorsque vous envoyez des mises à jour à la source de données.

Visual Basic inclut les fournisseurs LINQ suivants.

Fournisseur	Descriptif
LINQ to Objects	Le fournisseur LINQ to Objects vous permet d’interroger des collections et des tableaux en mémoire. Si un objet prend en charge soit l'interface IEnumerable soit l'interface IEnumerable<T>, le fournisseur LINQ to Objects vous permet de l’interroger. Vous pouvez activer le fournisseur LINQ to Objects en important l’espace de noms System.Linq, qui est importé par défaut pour tous les projets Visual Basic. Pour plus d’informations sur le fournisseur LINQ to Objects, consultez LINQ to Objects.
LINQ 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. Cela permet de mapper facilement le modèle objet d’une application aux tables et objets d’une base de données. Visual Basic facilite l’utilisation de LINQ to SQL en incluant le Concepteur relationnel objet (Concepteur O/R). Ce concepteur est utilisé pour créer un modèle objet dans une application qui correspond aux objets d’une base de données. Le Concepteur O/R fournit également des fonctionnalités permettant de mapper des procédures stockées et des fonctions à l’objet DataContext qui gère la communication avec la base de données et stocke l’état pour les contrôles d’accès concurrentiel optimiste. Pour plus d’informations sur le fournisseur LINQ to SQL, consultez LINQ to SQL. Pour plus d’informations sur le Concepteur relationnel d’objet, consultez LINQ to SQL Tools dans Visual Studio.
LINQ to XML	Le fournisseur LINQ to XML vous permet d’interroger et de modifier du code XML. Vous pouvez modifier le code XML en mémoire, ou vous pouvez charger du code XML à partir d’un fichier et l’enregistrer dans un fichier. En outre, le fournisseur LINQ to XML active les 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. Pour plus d’informations, consultez XML.
LINQ to DataSet	Le fournisseur LINQ to DataSet vous permet d’interroger et de mettre à jour des données dans un jeu de données ADO.NET. Vous pouvez ajouter la puissance de LINQ aux applications qui utilisent des jeux de données afin de simplifier et d’étendre vos fonctionnalités d’interrogation, d’agrégation et de mise à jour des données dans votre jeu de données. Pour plus d’informations, consultez LINQ to DataSet.

Structure d’une requête LINQ

Une requête LINQ, souvent appelée 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. Une expression de requête peut également inclure des instructions pour le tri, le filtrage, le regroupement et la jointure, ou les calculs à appliquer aux données sources. La syntaxe d’expression de requête ressemble à la syntaxe de SQL ; par conséquent, vous pouvez trouver une grande partie de la syntaxe familière.

Une expression de requête commence par une From clause. Cette clause identifie les données sources d’une requête et les variables utilisées pour faire référence à chaque élément des données sources individuellement. Ces variables sont appelées variables de plage ou variables d’itération. La From clause est requise pour une requête, à l’exception des Aggregate requêtes, où la From clause est facultative. Une fois l’étendue et la source de la requête identifiées dans les clauses From ou Aggregate, vous pouvez inclure n’importe quelle combinaison de clauses de requête pour affiner la requête. Pour plus d’informations sur les clauses de requête, consultez Les opérateurs de requête LINQ Visual Basic plus loin dans cette rubrique. Par exemple, la requête suivante identifie une collection source de données client comme customers variable et une variable d’itération nommée 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 est une requête valide par elle-même ; Toutefois, la requête devient beaucoup plus puissante lorsque vous ajoutez d’autres clauses de requête pour affiner le résultat. Par exemple, vous pouvez ajouter une Where clause pour filtrer le résultat par une ou plusieurs valeurs. Les expressions de requête sont une seule ligne de code ; vous pouvez simplement ajouter des clauses de requête supplémentaires à la fin de la requête. Vous pouvez diviser une requête sur plusieurs lignes de texte pour améliorer la lisibilité à l’aide du caractère de trait de soulignement (_) de continuation de ligne. L’exemple de code suivant montre un exemple de requête qui inclut une Where clause.

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

Une autre clause de requête puissante est la Select clause, qui vous permet de retourner uniquement les champs sélectionnés à partir de la source de données. Les requêtes LINQ retournent des collections énumérables d’objets fortement typés. Une requête peut retourner une collection de types anonymes ou de types nommés. Vous pouvez utiliser la Select clause pour renvoyer un seul champ à partir de la source de données. Lorsque vous effectuez cette opération, le type de la collection retournée est le type de ce champ unique. Vous pouvez également utiliser la Select clause pour renvoyer plusieurs champs à partir de la source de données. Lorsque vous effectuez cette opération, le type de la collection retournée est un nouveau type anonyme. Vous pouvez également faire correspondre les champs retournés par la requête aux champs d’un type nommé spécifié. L'exemple de code suivant montre une expression de requête qui retourne une collection de types anonymes dont les membres sont remplis avec des données provenant des champs sélectionnés de la source de données.

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. Cette opération peut être effectuée avec une ou plusieurs clauses From, ou en utilisant les clauses de requête Join ou Group Join. L’exemple de code suivant montre une expression de requête qui combine les données client et commande et retourne une collection de types anonymes contenant des données client et commande.

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 Group Join clause pour créer un résultat de requête hiérarchique qui contient une collection d’objets clients. Chaque objet client a une propriété qui contient une collection de toutes les commandes pour ce client. L’exemple de code suivant montre une expression de requête qui combine les données client et commande en tant que résultat hiérarchique et retourne une collection de types anonymes. La requête retourne un type qui inclut une CustomerOrders propriété qui contient une collection de données de commande pour le client. Il inclut également une OrderTotal propriété qui contient la somme des totaux pour toutes les commandes de ce client. (Cette requête est équivalente à une JOINTURE EXTERNE GAUCHE.)

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 que vous pouvez utiliser pour créer des expressions de requête puissantes. La section suivante de cette rubrique décrit les différentes clauses de requête que vous pouvez inclure dans une expression de requête. Pour plus d’informations sur les clauses de requête Visual Basic, consultez Requêtes.

Opérateurs de requête LINQ Visual Basic

Les classes de l’espace System.Linq de noms 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 des requêtes en fonction des besoins de votre application. Visual Basic inclut des mots clés pour les clauses de requête courantes suivantes. Pour plus d’informations sur les clauses de requête Visual Basic, consultez Requêtes.

Clause From

Une From clause ou une Aggregate clause est requise pour commencer une requête. Une From clause spécifie une collection source et une variable d’itération pour une requête. Par exemple:

' 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

Sélectionner une clause

Optionnel. Une Select clause déclare un ensemble de variables d’itération pour une requête. Par exemple:

' 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 Select clause 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.

Clause Where

Optionnel. Une Where clause spécifie une condition de filtrage pour une requête. Par exemple:

' 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

Optionnel. Une Order By clause spécifie l’ordre de tri des colonnes dans une requête. Par exemple:

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

Join (clause)

Optionnel. Une Join clause Combine deux collections en une collection unique. Par exemple:

' 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)

Optionnel. Une Group By clause regroupe les éléments d’un résultat de requête. Il peut être utilisé pour appliquer des fonctions d’agrégation à chaque groupe. Par exemple:

' 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)

Optionnel. Une Group Join clause combine deux collections en une seule collection hiérarchique. Par exemple:

' 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

Clause d’agrégation

Une Aggregate clause ou une From clause est requise pour commencer une requête. Une Aggregate clause applique une ou plusieurs fonctions d’agrégation à une collection. Par exemple, vous pouvez utiliser la Aggregate clause pour calculer une somme pour tous les éléments retournés par une requête, comme l’illustre l’exemple suivant.

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

Vous pouvez également utiliser la Aggregate clause pour modifier une requête. Par exemple, vous pouvez utiliser la Aggregate clause pour effectuer un calcul sur une collection de requêtes associée. Par exemple:

' 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)

Optionnel. Une Let clause calcule une valeur et l’affecte à une nouvelle variable dans la requête. Par exemple:

' 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

Clause distincte

Optionnel. Une Distinct clause limite les valeurs de la variable d’itération actuelle pour éliminer les valeurs en double dans les résultats de la requête. Par exemple:

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

Skip (clause)

Optionnel. Une Skip clause contourne un nombre spécifié d’éléments dans une collection, puis retourne les éléments restants. Par exemple:

' 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)

Optionnel. Une Skip While clause contourne les éléments d’une collection tant qu’une condition spécifiée est true , puis retourne les éléments restants. Par exemple:

' 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)

Optionnel. Une Take clause retourne un nombre spécifié d’éléments contigus à partir du début d’une collection. Par exemple:

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

Take While (clause)

Optionnel. Une Take While clause inclut des éléments dans une collection tant qu’une condition spécifiée est true et contourne les éléments restants. Par exemple:

' 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 d’autres fonctionnalités de requête LINQ

Vous pouvez utiliser des fonctionnalités de requête LINQ supplémentaires en appelant les membres des types énumérables et interrogeables fournis par LINQ. Vous pouvez utiliser ces fonctionnalités supplémentaires en appelant un opérateur de requête particulier sur le résultat d’une expression de requête. Par exemple, l’exemple suivant utilise la Enumerable.Union méthode pour combiner les résultats de deux requêtes en un seul résultat de requête. Elle utilise la Enumerable.ToList méthode pour retourner le résultat de la requête sous la forme d’une liste générique.

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 fonctionnalités LINQ supplémentaires, consultez Vue d’ensemble des opérateurs de requête standard.

Se connecter à une base de données à l’aide de LINQ to SQL

Dans Visual Basic, vous identifiez les objets de base de données SQL Server, tels que les tables, les vues et les procédures stockées, auxquels vous souhaitez accéder à l’aide d’un fichier LINQ to SQL. Un fichier LINQ to SQL a une extension de .dbml.

Lorsque vous disposez d’une connexion valide à une base de données SQL Server, vous pouvez ajouter un modèle d’élément LINQ to SQL Classes à votre projet. Cela affiche le concepteur relationnel objet (concepteur O/R). Le Concepteur O/R vous permet de faire glisser les éléments auxquels vous souhaitez accéder dans votre code à partir de l’Explorateur de serveurs/ et de l’Explorateur de bases de données sur l’aire du concepteur. Le fichier LINQ to SQL ajoute un DataContext objet à votre projet. 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. Une fois que vous avez 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. L’objet DataContext de votre projet est nommé en fonction du nom de votre fichier LINQ to SQL. Par exemple, un fichier LINQ to SQL nommé Northwind.dbml crée un DataContext objet nommé NorthwindDataContext.

Pour obtenir des exemples avec des instructions pas à pas, consultez Comment : interroger une base de données et comment : appeler une procédure stockée.

Fonctionnalités Visual Basic qui prennent en charge LINQ

Visual Basic inclut d’autres fonctionnalités notables qui utilisent LINQ simple et réduisent la quantité de code que vous devez écrire pour effectuer des requêtes LINQ. Ces options en question sont les suivantes :

Types anonymes, qui vous permettent de créer un nouveau type en fonction d’un résultat de requête.
Variables implicitement typées, qui vous permettent de différer la spécification d’un type et de laisser le compilateur déduire le type en fonction du résultat de la requête.
Méthodes d’extension, qui vous permettent d’étendre un type existant avec vos propres méthodes sans modifier le type lui-même.

Pour plus d’informations, consultez Les fonctionnalités Visual Basic qui prennent en charge LINQ.

Exécution différée et immédiate des requêtes

L’exécution de requête est distincte de la création d’une requête. Une fois qu’une requête est créée, son exécution est déclenchée par un mécanisme distinct. Une requête peut être exécutée dès qu’elle est définie (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).

Par défaut, lorsque vous créez une requête, la requête elle-même ne s’exécute pas immédiatement. Au lieu de cela, la définition de requête est stockée dans la variable utilisée pour référencer le résultat de la requête. Lorsque la variable de résultat de la requête est accessible ultérieurement dans le code, par exemple dans une For…Next boucle, la requête est exécutée. Ce processus est appelé exécution différée.

Les requêtes peuvent également être exécutées lorsqu’elles sont définies, ce qui est appelé exécution immédiate. Vous pouvez déclencher l’exécution immédiate en appliquant une méthode qui nécessite l’accès à des éléments individuels du résultat de la requête. Cela peut être le résultat de l’inclusion d’une fonction d’agrégation, telle que Count, , Sum, AverageMinou Max. Pour plus d’informations sur les fonctions d’agrégation, consultez Clause d’agrégation.

L'utilisation des méthodes ToList ou ToArray forcera également l'exécution immédiate. Cela peut être utile lorsque vous souhaitez exécuter la requête immédiatement et mettre en cache les résultats. Pour plus d’informations sur ces méthodes, consultez Conversion de types de données.

Pour plus d’informations sur l’exécution des requêtes, consultez Écriture de votre première requête LINQ.

XML en Visual Basic

Les fonctionnalités XML de Visual Basic incluent des littéraux XML et des propriétés d’axe XML, ce qui vous permet de créer, d’accéder, d’interroger et de modifier facilement des données XML dans votre code. Les littéraux XML vous permettent d’écrire du code XML directement dans votre code. Le compilateur Visual Basic traite le code XML comme un objet de données de première classe.

L’exemple de code suivant montre comment créer un élément XML, accéder à ses sous-éléments et attributs et interroger le contenu de l’élément à l’aide de 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.

Sujet	Descriptif
XML	Décrit les fonctionnalités XML de Visual Basic qui peuvent être interrogées et qui vous permettent d’inclure du code XML en tant qu’objets de données de première classe dans votre code Visual Basic.
Requêtes	Fournit des informations de référence sur les clauses de requête disponibles dans Visual Basic.
LINQ ( requêteLanguage-Integrated)	Inclut des informations générales, des conseils de programmation et des exemples pour LINQ.
LINQ to SQL	Inclut des informations générales, des conseils de programmation et des exemples pour LINQ to SQL.
LINQ to Objects	Inclut des informations générales, des conseils de programmation et des exemples pour LINQ to Objects.
LINQ to ADO.NET (Page du Portail)	Inclut des liens vers des informations générales, des conseils de programmation et des exemples pour LINQ to ADO.NET.
LINQ to XML	Inclut des informations générales, des conseils de programmation et des exemples pour LINQ to XML.