EntityReference<TEntity> Classe

Définition

Espace de noms:

System.Data.Objects.DataClasses

Assembly:

System.Data.Entity.dll

Représente une terminaison connexe d'une association avec une multiplicité de zéro ou un.

generic <typename TEntity>
 where TEntity : classpublic ref class EntityReference sealed : System::Data::Objects::DataClasses::EntityReference

[System.Runtime.Serialization.DataContract]
[System.Serializable]
public sealed class EntityReference<TEntity> : System.Data.Objects.DataClasses.EntityReference where TEntity : class

[<System.Runtime.Serialization.DataContract>]
[<System.Serializable>]
type EntityReference<'Entity (requires 'Entity : null)> = class
    inherit EntityReference

Public NotInheritable Class EntityReference(Of TEntity)
Inherits EntityReference

Paramètres de type

TEntity

Type d'entité de la référence.

Héritage

Object

RelatedEnd

EntityReference

EntityReference<TEntity>

Attributs

DataContractAttribute SerializableAttribute

Exemples

Cet exemple indique comment utiliser l'objet EntityReference<TEntity> pour modifier une relation entre un objet SalesOrderHeader et un objet Address connexe qui représente l'adresse d'expédition pour la commande.

// Define the order and new address IDs.
int orderId = 43669;
int addressId = 26;

using (AdventureWorksEntities context
    = new AdventureWorksEntities())
{
    // Get the billing address to change to.
    Address address =
        context.Addresses.Single(c => c.AddressID == addressId);

    // Get the order being changed.
    SalesOrderHeader order =
        context.SalesOrderHeaders.Single(o => o.SalesOrderID == orderId);

    // You do not have to call the Load method to load the addresses for the order,
    // because  lazy loading is set to true
    // by the constructor of the AdventureWorksEntities object.
    // With  lazy loading set to true the related objects are loaded when
    // you access the navigation property. In this case Address.

    // Write the current billing street address.
    Console.WriteLine("Current street: "
        + order.Address.AddressLine1);

    // Change the billing address.
    if (!order.Address.Equals(address))
    {
        // Use Address navigation property to change the association.
        order.Address = address;

        // Write the changed billing street address.
        Console.WriteLine("Changed street: "
            + order.Address.AddressLine1);
    }

    // If the address change succeeds, save the changes.
    context.SaveChanges();

    // Write the current billing street address.
    Console.WriteLine("Current street: "
        + order.Address.AddressLine1);
}

Remarques

EntityReference<TEntity> est retourné par une propriété de navigation lorsque la terminaison connexe a une multiplicité de zéro ou un. Pour plus d’informations, consultez Élément NavigationProperty (CSDL).

Un objet EntityReference<TEntity> peut avoir un objet EntityCollection<TEntity> (relation un-à-plusieurs) ou EntityReference<TEntity> (relation un-à-un) correspondant à l'autre terminaison de la relation. Lorsque des objets EntityReference<TEntity> et EntityCollection<TEntity> modèlent des terminaisons opposées de la même relation, l’intégrité de la relation est maintenue au niveau de l’objet.

Cette classe ne peut pas être héritée.

Constructeurs

EntityReference<TEntity>()

Crée une instance de EntityReference<TEntity>.

Propriétés

EntityKey	Retourne la clé de l'objet connexe. (Hérité de EntityReference)
IsLoaded	Obtient une valeur qui indique si tous les objets connexes ont été chargés. (Hérité de RelatedEnd)
RelationshipName	Obtient le nom de la relation à laquelle cette terminaison connexe participe. (Hérité de RelatedEnd)
RelationshipSet	Obtient une référence aux métadonnées de la terminaison connexe. (Hérité de RelatedEnd)
SourceRoleName	Obtient le nom du rôle à la terminaison source de la relation. (Hérité de RelatedEnd)
TargetRoleName	Obtient le nom du rôle à la terminaison cible de la relation. (Hérité de RelatedEnd)
Value	Obtient ou définit l'objet connexe retourné par cet objet EntityReference<TEntity>.

Méthodes

Attach(TEntity)	Crée une relation plusieurs-à-un ou un-à-un entre deux objets dans le contexte de l'objet.
Attach<TEntity>(IEnumerable<TEntity>, Boolean)	Définit une relation entre deux objets attachés. (Hérité de RelatedEnd)
CreateSourceQuery()	Crée une requête d'objet équivalente qui retourne l'objet connexe.
Equals(Object)	Détermine si l'objet spécifié est égal à l'objet actuel. (Hérité de Object)
GetEnumerator()	Retourne un objet IEnumerator qui itère au sein de la collection d'objets connexes. (Hérité de RelatedEnd)
GetHashCode()	Fait office de fonction de hachage par défaut. (Hérité de Object)
GetType()	Obtient le Type de l'instance actuelle. (Hérité de Object)
Load()	En cas de substitution dans une classe dérivée, charge les objets connexes dans la terminaison connexe avec l’option de fusion par défaut. (Hérité de RelatedEnd)
Load(MergeOption)	Charge l'objet connexe pour cet objet EntityReference<TEntity> avec l'option de fusion spécifiée.
MemberwiseClone()	Crée une copie superficielle du Object actuel. (Hérité de Object)
Merge<TEntity>(IEnumerable<TEntity>, MergeOption, Boolean)	Fusionne des entités connexes dans l’objet EntityCollection<TEntity> local. (Hérité de RelatedEnd)
OnDeserialized(StreamingContext)	Utilisé en interne pour désérialiser des objets d'entité avec les instances RelationshipManager. (Hérité de RelatedEnd)
OnRefDeserialized(StreamingContext)	Cette méthode est utilisée en interne pour sérialiser des objets d'entité associée.
OnSerializing(StreamingContext)	Cette méthode est utilisée en interne pour sérialiser des objets d'entité associée.
ToString()	Retourne une chaîne qui représente l'objet actuel. (Hérité de Object)
ValidateEntityForAttach<TEntity>(TEntity, Int32, Boolean)	Détermine si un objet peut être attaché à la référence ou collection locale. (Hérité de RelatedEnd)
ValidateLoad<TEntity>(MergeOption, String)	Garantit que les objets connexes peuvent être chargés avec succès dans la collection ou référence locale. (Hérité de RelatedEnd)
ValidateOwnerForAttach()	Garantit que l’objet auquel la terminaison connexe appartient prend en charge une opération d’attachement. (Hérité de RelatedEnd)

Événements

AssociationChanged

Se produit lorsqu'une modification est apportée à une terminaison connexe. (Hérité de RelatedEnd)

Implémentations d’interfaces explicites

IRelatedEnd.Add(IEntityWithRelationships)	Ajoute un objet à la terminaison connexe. (Hérité de RelatedEnd)
IRelatedEnd.Add(Object)	Ajoute un objet à la terminaison connexe. (Hérité de RelatedEnd)
IRelatedEnd.Attach(IEntityWithRelationships)	Attache un objet à la terminaison connexe. (Hérité de RelatedEnd)
IRelatedEnd.Attach(Object)	Attache un objet à la terminaison connexe. (Hérité de RelatedEnd)
IRelatedEnd.CreateSourceQuery()	Retourne un objet IEnumerable qui représente les objets appartenant à la terminaison connexe. (Hérité de RelatedEnd)
IRelatedEnd.Remove(IEntityWithRelationships)	Supprime un objet de la collection à la terminaison connexe. (Hérité de RelatedEnd)
IRelatedEnd.Remove(Object)	Supprime un objet de la terminaison connexe si l'objet appartient à celle-ci. (Hérité de RelatedEnd)