Partager via

Exemples de syntaxe de requête fondée sur une méthode : filtrage (LINQ to Entities)

  • Article

Les exemples de cette rubrique montrent comment utiliser les méthodes Where et Where…Contains pour interroger le modèle de vente AdventureWorks Sales Model à l'aide de la syntaxe de requête fondée sur une méthode. Notez que Where…Contains ne peut pas être utilisé dans le cadre d'une requête compilée.

Le modèle de vente AdventureWorks Sales Model utilisé dans ces exemples est construit à partir des tables Contact, Address, Product, SalesOrderHeader et SalesOrderDetail de l'exemple de base de données AdventureWorks.

Les exemples fournis dans cette rubrique utilisent les instructions using/Imports suivantes :

Option Explicit On
Option Strict On
Imports System.Data.Objects
Imports System.Globalization

using System;
using System.Data;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data.Objects;
using System.Globalization;
using System.Data.EntityClient;
using System.Data.SqlClient;
using System.Data.Common;

Where

Exemple

L'exemple suivant retourne toutes les commandes en ligne.

Using context As New AdventureWorksEntities
    Dim onlineOrders = context.SalesOrderHeaders _
        .Where(Function(order) order.OnlineOrderFlag = True) _
        .Select(Function(order) New With { _
           .SalesOrderID = order.SalesOrderID, _
           .OrderDate = order.OrderDate, _
           .SalesOrderNumber = order.SalesOrderNumber _
        })

    For Each onlineOrder In onlineOrders
        Console.WriteLine("Order ID: {0} Order date: {1:d} Order number: {2}", _
                onlineOrder.SalesOrderID, _
                onlineOrder.OrderDate, _
                onlineOrder.SalesOrderNumber)
    Next
End Using

using (AdventureWorksEntities context = new AdventureWorksEntities())
{
    var onlineOrders = context.SalesOrderHeaders
        .Where(order => order.OnlineOrderFlag == true)
        .Select(s => new { s.SalesOrderID, s.OrderDate, s.SalesOrderNumber });

    foreach (var onlineOrder in onlineOrders)
    {
        Console.WriteLine("Order ID: {0} Order date: {1:d} Order number: {2}",
            onlineOrder.SalesOrderID,
            onlineOrder.OrderDate,
            onlineOrder.SalesOrderNumber);
    }
}

Exemple

L'exemple suivant retourne les commandes où la quantité commandée est supérieure à 2 et inférieure à 6.

Dim orderQtyMin = 2
Dim orderQtyMax = 6
Using context As New AdventureWorksEntities
    Dim query = context.SalesOrderDetails _
        .Where(Function(order) order.OrderQty > orderQtyMin And order.OrderQty < orderQtyMax) _
        .Select(Function(order) New With { _
            .SalesOrderID = order.SalesOrderID, _
            .OrderQty = order.OrderQty _
        })

    For Each order In query
        Console.WriteLine("Order ID: {0} Order quantity: {1}", _
                order.SalesOrderID, order.OrderQty)
    Next
End Using

int orderQtyMin = 2;
int orderQtyMax = 6;
using (AdventureWorksEntities context = new AdventureWorksEntities())
{
    var query = context.SalesOrderDetails
        .Where(order => order.OrderQty > orderQtyMin && order.OrderQty < orderQtyMax)
        .Select(s => new { s.SalesOrderID, s.OrderQty });

    foreach (var order in query)
    {
        Console.WriteLine("Order ID: {0} Order quantity: {1}",
            order.SalesOrderID, order.OrderQty);
    }
}

Exemple

L'exemple suivant retourne tous les produits de couleur rouge.

Dim color = "Red"
Using context As New AdventureWorksEntities
    Dim query = context.Products _
        .Where(Function(product) product.Color = color) _
        .Select(Function(product) New With { _
            .Name = product.Name, _
            .ProductNumber = product.ProductNumber, _
            .ListPrice = product.ListPrice _
        })

    For Each product In query
        Console.WriteLine("Name: {0}", product.Name)
        Console.WriteLine("Product number: {0}", product.ProductNumber)
        Console.WriteLine("List price: ${0}", product.ListPrice)
        Console.WriteLine("")
    Next
End Using

String color = "Red";
using (AdventureWorksEntities context = new AdventureWorksEntities())
{
    var query = context.Products
        .Where(product => product.Color == color)
        .Select(p => new { p.Name, p.ProductNumber, p.ListPrice });

    foreach (var product in query)
    {
        Console.WriteLine("Name: {0}", product.Name);
        Console.WriteLine("Product number: {0}", product.ProductNumber);
        Console.WriteLine("List price: ${0}", product.ListPrice);
        Console.WriteLine("");
    }
}

Exemple

L'exemple ci-dessous utilise la méthode Where pour rechercher des commandes qui ont été passées après le 1er décembre 2003, puis utilise la propriété de navigation order.SalesOrderDetail pour obtenir les détails de chaque commande.

Using context As New AdventureWorksEntities
    Dim query = context.SalesOrderHeaders _
        .Where(Function(order) order.OrderDate >= New DateTime(2003, 12, 1)) _
        .Select(Function(order) order)

    Console.WriteLine("Orders that were made after December 1, 2003:")
    For Each order In query
        Console.WriteLine("OrderID {0} Order date: {1:d} ", _
                order.SalesOrderID, order.OrderDate)
        For Each orderDetail In order.SalesOrderDetails
            Console.WriteLine("  Product ID: {0} Unit Price {1}", _
                orderDetail.ProductID, orderDetail.UnitPrice)
        Next
    Next
End Using

using (AdventureWorksEntities context = new AdventureWorksEntities())
{
    IQueryable<SalesOrderHeader> query = context.SalesOrderHeaders
        .Where(order => order.OrderDate >= new DateTime(2003, 12, 1));

    Console.WriteLine("Orders that were made after December 1, 2003:");
    foreach (SalesOrderHeader order in query)
    {
        Console.WriteLine("OrderID {0} Order date: {1:d} ",
            order.SalesOrderID, order.OrderDate);
        foreach (SalesOrderDetail orderDetail in order.SalesOrderDetails)
        {
            Console.WriteLine("  Product ID: {0} Unit Price {1}",
                orderDetail.ProductID, orderDetail.UnitPrice);
        }
    }
}

Where…Contains

Exemple

L'exemple ci-dessous utilise un tableau dans le cadre d'une clause Where…Contains pour rechercher tous les produits qui ont un ProductModelID qui correspond à une valeur dans le tableau.

Using AWEntities As New AdventureWorksEntities()
    Dim productModelIds As System.Nullable(Of Integer)() = {19, 26, 118}
    Dim products = AWEntities.Products. _
        Where(Function(p) productModelIds.Contains(p.ProductModelID))
    For Each product In products
        Console.WriteLine("{0}: {1}", product.ProductModelID, product.ProductID)
    Next
End Using

using (AdventureWorksEntities AWEntities = new AdventureWorksEntities())
{
    int?[] productModelIds = { 19, 26, 118 };
    var products = AWEntities.Products.
        Where(p => productModelIds.Contains(p.ProductModelID));
   
    foreach (var product in products)
    {
        Console.WriteLine("{0}: {1}", product.ProductModelID, product.ProductID);
    }
}
Bb896342.note(fr-fr,VS.100).gifRemarque :
Dans le cadre du prédicat dans une clause Where…Contains, vous pouvez utiliser un Array, un List ou une collection de type quelconque qui implémente l'interface IEnumerable.Vous pouvez également déclarer et initialiser une collection dans une requête LINQ to Entities.Pour plus d'informations, consultez l'exemple suivant.

Exemple

L'exemple ci-dessous déclare et initialise des tableaux dans une clause Where…Contains pour rechercher tous les produits qui ont un ProductModelID ou un Size correspondant à une valeur dans les tableaux.

Using AWEntities As New AdventureWorksEntities()
    Dim products = AWEntities.Products. _
        Where(Function(p) (New System.Nullable(Of Integer)() {19, 26, 18}). _
                           Contains(p.ProductModelID) _
              OrElse _
                          (New String() {"L", "XL"}).Contains(p.Size))

    For Each product In products
        Console.WriteLine("{0}: {1}, {2}", product.ProductID, _
                                           product.ProductModelID, _
                                           product.Size)
    Next
End Using

using (AdventureWorksEntities AWEntities = new AdventureWorksEntities())
{
    var products = AWEntities.Products.
        Where(p => (new int?[] { 19, 26, 18 }).Contains(p.ProductModelID) || 
                   (new string[] { "L", "XL" }).Contains(p.Size));
          
    foreach (var product in products)
    {
        Console.WriteLine("{0}: {1}, {2}", product.ProductID, 
                                           product.ProductModelID, 
                                           product.Size);
    }
}

Voir aussi

Concepts

Requêtes dans LINQ to Entities