Comparaison entre le chargement différé et le chargement immédiat (LINQ to SQL)
Lorsque vous recherchez un objet, vous récupérez en réalité uniquement l'objet que vous avez demandé. Les objets connexes ne sont pas automatiquement extraits en même temps. (Pour plus d'informations, consultez Interrogation de relations (LINQ to SQL)). Vous ne pouvez pas voir que les objets connexes ne sont pas déjà chargés car une tentative d'accès à ceux-ci génère une demande qui les récupère.
Par exemple, vous pouvez rechercher un ensemble particulier de commandes, puis envoyer uniquement de temps en temps une notification par courrier électronique à des clients particuliers. Vous n'auriez pas nécessairement besoin de récupérer au début toutes les données des clients pour chaque commande. Vous pouvez utiliser le chargement différé pour différer la récupération d'informations supplémentaires jusqu'au moment où cela devient indispensable. Prenons l'exemple suivant :
Dim db As New Northwnd("c:\northwnd.mdf")
Dim notificationQuery = _
From ord In db.Orders _
Where ord.ShipVia = 3 _
Select ord
For Each ordObj As Order In notificationQuery
If ordObj.Freight > 200 Then
SendCustomerNotification(ordObj.Customer)
ProcessOrder(ordObj)
End If
Next
Northwnd db = new Northwnd(@"northwnd.mdf");
IQueryable<Order> notificationQuery =
from ord in db.Orders
where ord.ShipVia == 3
select ord;
foreach (Order ordObj in notificationQuery)
{
if (ordObj.Freight > 200)
SendCustomerNotification(ordObj.Customer);
ProcessOrder(ordObj);
}
}
Le contraire peut être également vrai. Supposons que vous avez une application qui nécessite d'afficher en même temps les données sur les clients et les commandes. Vous savez que vous avez besoin de ces deux groupes de données. Vous savez également que votre application a besoin des informations relatives aux commandes pour chaque client dès que vous obtenez les résultats. Vous ne voulez pas exécuter des requêtes individuelles pour les commandes de chaque client et vous souhaitez principalement récupérer les données sur les commandes avec les clients.
Dim db As New Northwnd("c:\northwnd.mdf")
db.DeferredLoadingEnabled = False
Dim custQuery = _
From cust In db.Customers _
Where cust.City = "London" _
Select cust
For Each custObj As Customer In custQuery
For Each ordObj As Order In custObj.Orders
ProcessCustomerOrder(ordObj)
Next
Next
Northwnd db = new Northwnd(@"c:\northwnd.mdf");
db.DeferredLoadingEnabled = false;
IQueryable<Customer> custQuery =
from cust in db.Customers
where cust.City == "London"
select cust;
foreach (Customer custObj in custQuery)
{
foreach (Order ordObj in custObj.Orders)
{
ProcessCustomerOrder(ordObj);
}
}
Vous pouvez également associer les clients et les commandes dans une requête à l'aide du produit croisé et en récupérant tous les bits relatifs des données sous forme d'une grande projection. Toutefois, ces résultats ne sont pas des entités. Pour plus d'informations, consultez Modèle objet LINQ to SQL. Les entités sont des objets qui ont une identité et que vous pouvez modifier, alors que ces résultats seraient des projections qui ne peuvent pas être modifiées et rendues persistantes. Dans le pire des cas, vous récupéreriez beaucoup de données redondantes, étant donné que chaque client est répété pour chaque commande dans les résultats de la jointure à deux dimensions.
Vous avez principalement besoin d'une méthode pour récupérer simultanément un ensemble d'objets connexes. Cet ensemble est une section délimitée d'un graphique pour que vous ne récupériez jamais plus ou moins de données nécessaires que prévu pour votre utilisation. À cette fin, LINQ to SQL fournit DataLoadOptions pour le chargement immédiat d'une région de votre modèle objet. Méthodes incluses :
Méthode LoadWith pour charger immédiatement des données en rapport avec la cible principale.
Méthode AssociateWith pour filtrer des objets récupérés pour une relation particulière.