Entrainement
Module
Combiner plusieurs tables avec des opérations de jointure dans T-SQL - Training
Combiner plusieurs tables avec des opérations de jointure dans T-SQL
Ce navigateur n’est plus pris en charge.
Effectuez une mise à niveau vers Microsoft Edge pour tirer parti des dernières fonctionnalités, des mises à jour de sécurité et du support technique.
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.
Notes
Il est possible que pour certains des éléments de l'interface utilisateur de Visual Studio, votre ordinateur affiche des noms ou des emplacements différents de ceux indiqués dans les instructions suivantes. L'édition de Visual Studio dont vous disposez et les paramètres que vous utilisez déterminent ces éléments. Pour plus d’informations, consultez Personnalisation de l’IDE.
Cette procédure pas à pas a été écrite à l'aide des paramètres de développement Visual C#.
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.
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
.
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
.
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; }
}
}
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.)
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); }
}
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.
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);
}
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;
.
Appuyez sur Entrée dans la fenêtre de console pour arrêter le débogage.
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.
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) { }
}
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();
Appuyez sur F5 pour déboguer l'application.
La sortie de la fenêtre de console est :
ID=WHITC
Appuyez sur Entrée dans la fenêtre de console pour arrêter le débogage.
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.
Entrainement
Module
Combiner plusieurs tables avec des opérations de jointure dans T-SQL - Training
Combiner plusieurs tables avec des opérations de jointure dans T-SQL