Procédure pas à pas : Interrogation entre relations (C#)

Cette procédure pas à pas explique comment utiliser des associations LINQ to SQL pour représenter les relations de clé étrangère dans la base de données.

Cette procédure pas à pas a été écrite à l'aide des paramètres de développement Visual C#.

Prérequis

Vous devez avoir terminé Procédure pas à pas : Modèle objet simple et requête (C#). Cette procédure pas à pas est basée sur cette dernière, y compris la présence du fichier northwnd.mdf dans c:\linqtest5.

Vue d’ensemble

Cette procédure pas à pas se compose de trois tâches principales :

• Ajout d'une classe d'entité pour représenter la table Orders dans l'exemple de base de données Northwind.

• Ajout d'annotations à la classe Customer pour améliorer la relation entre les classes Customer et Order.

• Création et exécution d'une requête pour tenter d'obtenir des informations Order en utilisant la classe Customer.

Mappage de relations entre des tables

Une fois la définition de classe Customer terminée, créez la définition de classe d'entité Order qui inclut le code suivant indiquant que Order.Customer est une clé étrangère de Customer.CustomerID.

Pour ajouter la classe d'entité Order

• Tapez ou collez le code suivant après la classe Customer :

  [Table(Name = "Orders")]
  public class Order
  {
      private int _OrderID = 0;
      private string _CustomerID;
      private EntityRef<Customer> _Customer;
      public Order() { this._Customer = new EntityRef<Customer>(); }
  
      [Column(Storage = "_OrderID", DbType = "Int NOT NULL IDENTITY",
      IsPrimaryKey = true, IsDbGenerated = true)]
      public int OrderID
      {
          get { return this._OrderID; }
          // No need to specify a setter because IsDBGenerated is
          // true.
      }
  
      [Column(Storage = "_CustomerID", DbType = "NChar(5)")]
      public string CustomerID
      {
          get { return this._CustomerID; }
          set { this._CustomerID = value; }
      }
  
      [Association(Storage = "_Customer", ThisKey = "CustomerID")]
      public Customer Customer
      {
          get { return this._Customer.Entity; }
          set { this._Customer.Entity = value; }
      }
  }
  

Annotation de la classe Customer

Dans cette étape, annotez la classe Customer pour indiquer sa relation avec la classe Order. (Cet ajout n’est pas strictement nécessaire, car la définition de la relation dans les deux sens est suffisante pour créer le lien. Mais l’ajout de cette annotation vous permet de naviguer facilement dans les deux sens.)

Pour annoter la classe Customer

• Tapez ou collez le code suivant dans la classe Customer :

  private EntitySet<Order> _Orders;
  public Customer()
  {
      this._Orders = new EntitySet<Order>();
  }
  
  [Association(Storage = "_Orders", OtherKey = "CustomerID")]
  public EntitySet<Order> Orders
  {
      get { return this._Orders; }
      set { this._Orders.Assign(value); }
  }
  

Création et exécution d'une requête dans la relation entre les classes Order et Customer

Vous pouvez désormais accéder aux objets Order directement à partir des objets Customer ou inversement. Vous n’avez pas besoin d’une jointure explicite entre les clients et les commandes.

Pour accéder aux objets Order à l'aide d'objets Customer

1. Modifiez la méthode Main en tapant ou en collant le code suivant dans la méthode :

   // Query for customers who have placed orders.
   var custQuery =
       from cust in Customers
       where cust.Orders.Any()
       select cust;
   
   foreach (var custObj in custQuery)
   {
       Console.WriteLine("ID={0}, Qty={1}", custObj.CustomerID,
           custObj.Orders.Count);
   }
   

2. Appuyez sur F5 pour déboguer l'application.

   Notes

   Vous pouvez supprimer le code SQL dans la fenêtre de console en supprimant db.Log = Console.Out;.

3. Appuyez sur Entrée dans la fenêtre de console pour arrêter le débogage.

Création d'une vue fortement typée de votre base de données

Il est beaucoup plus facile de démarrer avec une vue fortement typée de votre base de données. En effectuant un typage fort de l'objet DataContext, vous n'avez pas besoin d'effectuer des appels à GetTable. Vous pouvez utiliser des tables fortement typées dans toutes vos requêtes lorsque vous utilisez l'objet DataContext fortement typé.

Dans les étapes suivantes, vous créerez Customers comme table fortement typée qui mappe à la table Customers dans la base de données.

Pour effectuer un typage fort de l'objet DataContext

1. Ajoutez le code suivant au-dessus de la déclaration de classe Customer.

   public class Northwind : DataContext
   {
       // Table<T> abstracts database details per table/data type.
       public Table<Customer> Customers;
       public Table<Order> Orders;
   
       public Northwind(string connection) : base(connection) { }
   }
   

2. Modifiez la méthode Main pour utiliser le DataContext fortement typé comme suit :

   // Use a connection string.
   Northwind db = new Northwind(@"C:\linqtest5\northwnd.mdf");
   
   // Query for customers from Seattle.
   var custQuery =
       from cust in db.Customers
       where cust.City == "Seattle"
       select cust;
   
   foreach (var custObj in custQuery)
   {
       Console.WriteLine("ID={0}", custObj.CustomerID);
   }
   // Freeze the console window.
   Console.ReadLine();
   

3. Appuyez sur F5 pour déboguer l'application.

   La sortie de la fenêtre de console est :

   ID=WHITC

4. Appuyez sur Entrée dans la fenêtre de console pour arrêter le débogage.

Étapes suivantes

La procédure pas à pas suivante (Procédure pas à pas : Manipulation de données (C#)) montre comment manipuler des données. Cette procédure pas à pas ne requiert pas d'enregistrer les deux procédures pas à pas de cette série que vous avez déjà terminées.

Voir aussi

• Apprentissage par les procédures pas à pas