Génération d'applications multicouches (Entity Framework)
Entity Framework prend en charge la sérialisation d'objets entité dans des formats qui permettent l'échange à distance et par message d'objets entité, tels que ceux utilisés avec les services Web et WCF (Windows Communication Foundation). Les objets peuvent être sérialisés selon la méthode de la sérialisation binaire, de la sérialisation XML et de la sérialisation de contrat WCF pour en assurer le transport au moyen de protocoles basés sur les flux binaires ou les messages. Pour plus d'informations, consultez Sérialisation d'objets (Entity Framework). Les objets peuvent également être reçus au moyen d'un message ou d'un flux, désérialisés et attachés à un contexte d'objet. Pour plus d'informations, consultez Attachement et détachement d'objets (Entity Framework).
ADO.NET Data Services permet également de fournir un accès dynamique aux données d'entité dans un format XML exploitable par les applications. Accédez à ces données d'entité via des actions HTTP REST (Representational State Transfer) standard, telles que GET, PUT et POST. Pour plus d'informations, consultez ADO.NET Data Services.
Les considérations suivantes s'appliquent aux services Web ou aux services WCF qui utilisent Entity Framework :
Avec la sérialisation binaire et la sérialisation de contrat de données, les objets connexes sont sérialisés en même temps que l'objet primaire. La sérialisation XML ne sérialise pas les objets connexes. Lors de la sérialisation d'entités, désactivez le chargement différé. Le chargement différé exécute une requête à chaque fois qu'une propriété de navigation de relation fait l'objet d'un accès, et les sérialiseurs binaire et de contrat de données WCF accèdent à toutes les propriétés de navigation de relation. Cela peut donner lieu à l'exécution de nombreuses requêtes inattendues au cours de la sérialisation. Pour plus d'informations, consultez Sérialisation d'objets (Entity Framework).
Les services sans état sont recommandés. Les services doivent être conçus de telle sorte qu'un contexte d'objet ne soit conservé que le temps d'une demande ou d'une réponse. Le modèle d'échange de messages doit inclure suffisamment d'informations afin que les modifications puissent être appliquées sans qu'il soit nécessaire de rendre les objets persistants ou de réinterroger la source de données de façon à extraire l'objet d'origine. Par exemple, un service qui permet à un client de mettre à jour les objets doit exiger qu'un objet mis à jour soit retourné avec l'objet d'origine. Les modifications peuvent ainsi être appliquées à l'objet d'origine par le service Web sans qu'il soit nécessaire d'extraire l'objet d'origine de la base de données ou de le conserver en mémoire. Pour plus d'informations, consultez Procédure : appliquer des modifications apportées à un objet détaché (Entity Framework).
Les objets sont toujours désérialisés à l'état Detached. Vous pouvez être amené à attacher ou ajouter l'objet à un ObjectContext, ou vous pouvez souhaiter simplement appliquer des modifications de propriété à l'objet d'origine. Pour plus d'informations, consultez Attachement et détachement d'objets (Entity Framework).
Une fois les objets et les relations ajoutés au contexte, vous pouvez définir le nouvel état à l'aide de ChangeObjectState (tel que Added ou Modified).
Vous devez gérer manuellement la concurrence et la validation.
Pour plus d'informations, consultez les articles suivants sur le développement multicouche :
Modèles d'application multicouche
Suivi automatique d'entités
Dans une application Entity Framework , le suivi des modifications dans vos objets est assuré par un contexte d'objet. Toutefois, lorsque vous devez manipuler des objets dans une autre couche, où le contexte d'objet n'est pas disponible, vous devez indiquer comment le suivi des modifications sera effectué et comment le rapport de ces modifications sera retransmis au contexte d'objet. À partir de la version 4 du .NET Framework, les entités de suivi automatique peuvent vous aider à effectuer le suivi des modifications dans toutes les couches. Une entité de suivi automatique est une entité constituée à partir d'un modèle Text Template Transformation Toolkit (T4) qui génère des types d'entité qui ont la capacité d'enregistrer les modifications dans les propriétés scalaires, complexes et de navigation. Pour plus d'informations, consultez Utilisation des entités de suivi automatique.
Pour suivre des modifications sur une couche où les objets ne sont pas joints à un contexte d'objet sans utiliser des entités de suivi automatique, vous pouvez utiliser les méthodes décrites dans la section suivante pour vous aider à mettre à jour votre contexte et rendre persistantes les modifications pertinentes apportées à la base de données.
Utilisation d'API pertinentes au développement d'applications multicouche
Les méthodes suivantes vous permettent d'ajouter un graphique entier d'objets, puis de parcourir le graphique, appliquer les valeurs appropriées aux propriétés de l'objet et définir l'état correct sur les objets entité et les relations.
Pour ajouter et joindre des entités, utilisez les méthodes suivantes :
| Membre | Description |
|---|---|
System.Data.Objects.ObjectSet.AddObject( ou System.Data.Objects.ObjectContext.AddObject(System.String,System.Object) |
Ajoute un objet et ses objets connexes à ObjectContext et définit les objets entité sur l'état Added. Dans cet état, les objets entité n'ont pas besoin d'avoir des valeurs de clé uniques. Les valeurs de clé temporaires sont affectées aux propriétés de clé et sont mises à jour avec les valeurs générées par la source de données après avoir enregistré les objets. Après avoir ajouté les objets, modifiez convenablement l'état des objets entité. |
System.Data.Objects.ObjectSet.Attach( ou System.Data.Objects.ObjectContext.Attach(System.Data.Objects.DataClasses.IEntityWithKey) et |
Ajoute un objet à ObjectContext et attribue à l'objet l'état Unchanged. Dans l'état Unchanged, Entity Framework traite les valeurs de clé d'entité comme étant finales. Si plusieurs entités d'un type particulier ont la même valeur de clé, Entity Framework lèvera une exception. Pour éviter d'obtenir l'exception, utilisez la méthode AddObject pour joindre les objets détachés et modifier convenablement l'état. |
Pour modifier les valeurs scalaires, procédez comme suit :
| Membre | Description |
|---|---|
System.Data.Objects.ObjectSet.ApplyCurrentValues( ou System.Data.Objects.ObjectContext.ApplyCurrentValues.String, |
Copie les valeurs scalaires de l'objet fourni dans l'objet, dans le ObjectContext qui a la même clé. Aucune valeur différente des valeurs d'origine ne sera marquée comme modifiée. Si vous avez un graphique avec les valeurs actuelles et souhaitez appliquer les valeurs d'origine, appelez la méthode ApplyOriginalValues. Vous pouvez également utiliser la méthode ApplyCurrentValues de ObjectStateEntry. |
System.Data.Objects.ObjectSet.ApplyOriginalValues( ou System.Data.Objects.ObjectContext.ApplyOriginalValues.String, |
Copie les valeurs scalaires de l'objet fourni dans le jeu de valeurs d'origine de l'objet dans le ObjectContext qui a la même clé. Aucune valeur différente des valeurs actuelles ne sera marquée comme modifiée. Vous pouvez également utiliser la méthode ApplyOriginalValues de ObjectStateEntry. |
Définit des propriétés individuelles sur l'état Modified. Utilisez cette propriété lorsque vous connaissez les propriétés qui ont été modifiées au lieu de définir l'entité entière à modifier. |
|
Obtient l'instance OriginalValueRecord qui représente la version pouvant être mise à jour des valeurs d'origine de l'objet associé à ce ObjectStateEntry. Utilisez l'instance OriginalValueRecord retournée pour lire ou mettre à jour individuellement les propriétés d'origine de l'objet. |
|
Obtient l'instance CurrentValueRecord qui représente la version pouvant être mise à jour des valeurs actuelles de l'objet associé à ce ObjectStateEntry. Utilisez l'instance CurrentValueRecord retournée pour lire ou mettre à jour individuellement les propriétés actuelles de l'objet. |
Pour modifier l'état d'une entité et d'une relation, utilisez les méthodes suivantes :
| Membre | Description |
|---|---|
ChangeObjectState |
Modifie l'état d'une entité ou d'une relation (tel que Added ou Modified). Cette modification peut avoir un impact sur les relations auxquelles l'entité participe. Par exemple, le passage d'une entité à l'état Added aura également pour effet d'attribuer à toutes les relations non modifiées l'état Added. De la même façon, marquer une entité comme Modified marquera toutes les valeurs scalaires comme Modified. Vous pouvez également utiliser la méthode ChangeState de ObjectStateEntry. |
Attribue l'état spécifié à la relation qui existe entre deux entités. S'il n'existe aucune relation entre les entités, cette méthode en crée une avec l'état spécifié. Cette méthode n'est pas prise en charge pour les relations basées sur une association de clé étrangère. Pour plus d'informations, consultez Définition et gestion des relations (Entity Framework). Vous pouvez également utiliser la méthode ChangeState de ObjectStateEntry. |
|
ChangeState |
Cette méthode se comporte de la même façon que ChangeObjectState ou ChangeRelationshipState selon que ObjectStateEntry est un objet ou une relation. |
SetModifiedProperty |
Définit des propriétés individuelles sur l'état Modified. Utilisez cette méthode lorsque vous connaissez les propriétés qui ont été modifiées au lieu de définir l'entité entière à modifier. |
Pour enregistrer les modifications apportées à la source de données, utilisez les méthodes suivantes :
| Membre | Description |
|---|---|
Rend persistantes toutes les modifications apportées à la source de données. |
Utilisez l'événement ObjectMaterialized si vous souhaitez obtenir ou définir des informations, ou vous abonner à des événements, pendant la matérialisation de l'objet.
| Membre | Description |
|---|---|
ObjectMaterialized |
Se produit lorsqu'un nouvel objet entité est créé à partir des données de la source de données dans le cadre d'une requête ou d'une opération de chargement. L'événement est déclenché après le chargement des objets de référence, mais avant le chargement des collections. Si un objet qui a la même valeur de clé existe dans le contexte, Entity Framework ne recrée pas l'objet et cet événement n'est pas déclenché. |