Entity Framework "un à plusieurs" de la relation du premier code

Je vais avoir mes premiers pas en EF 4.1. Parce que j'ai été en utilisant NHibenate, le code de la première approche me semble que le meilleur. J'ai un problème avec une bonne cartographie de l'un-à-plusieurs ou plusieurs-à-une) relation. Disons que j'ai 2 entités: 

class ClientModel
{
    int ClientID;
    string Name;
    virtual IList<OrderModel> Orders;
}

class OrderModel
{
    int OrderID;
    string Details;
    virtual ClienModel Client;
}

Quand je le laisse comme ça, il y a une erreur lors de la génération de la base de données - clés dans les tableaux sont manquants. J'ai compris, je peux le résoudre en changeant les noms des clés d'identification (mais ce n'est pas OK avec mon naming convention) ou par l'ajout de [Key] annotation. Même si j'ajoute cette annotation, toujours les noms de tables sont mal - tout comme les classes de noms, mais avec un "s".
J'ai donc essayé d'utiliser l'API fluent - j'ai fait des mappages. Mais si j'ai mis les mappages comme ici:

class ClientMapping
{
    ClientMapping()
    {
        this.HasKey(e => e.ClientID).Property(e => e.ID).HasColumnName("ClientID");
        this.Property(e => e.Name).HasColumnName("Name");
        this.HasMany(e => e.Orders).WithOptional().Map(p => p.MapKey("OrderID")).WillCascadeOnDelete();
        this.ToTable("Clients");
    }
}

class OrderMapping
{
    OrderMapping()
    {
        this.HasKey(e => e.OrderID).Property(e => e.OrderID).HasColumnName("OrderID");
        this.Property(e => e.Details).HasColumnName("Details");
        this.HasRequired(e => e.Client).WithMany().Map(p=>p.MapKey("Client")).WillCascadeOnDelete(false);
        this.ToTable("Orders");
    }
}

la relation betweene tables dans la base de données est doublé.
Quelle est la bonne façon de le faire un-à-plusieurs relations à l'aide de code-première approche? Suis-je la pensée dans la bonne direction ou est-ce un mal?

MODIFIER

OK, je l'ai fait à la manière @Eranga a montré, mais il y a encore un problème. Quand je suis Client de base de données, de ses Commandes, la propriété est null (mais dans la base de données qu'il a certaines Commandes avec la Commande.ClientID == Client.ClientID).

J'ai testé la configuration donnée dans ma réponse et il fonctionne très bien. Assurez-vous que Orders est une propriété qui n'est pas un champ.
Essayez virtual List<OrderModel> Orders; au lieu de virtual IList<OrderModel> Orders;

OriginalL'auteur rideronthestorm | 2011-09-21

  1. 6

    Vous devez mapper les deux propriétés qui participent à la relation. Vous devez ajouter ClientID colonne à la table Commandes.

    class ClientMapping
{
    ClientMapping()
    {
        this.HasKey(e => e.ClientID).Property(e => e.ID).HasColumnName("ClientID");
        this.Property(e => e.Name).HasColumnName("Name");

        this.HasMany(e => e.Orders).WithRequired(o => o.Client)
           .Map(p => p.MapKey("ClientID")).WillCascadeOnDelete();

        this.ToTable("Clients");
    }
}

class OrderMapping
{
    OrderMapping()
    {
        this.HasKey(e => e.OrderID).Property(e => e.OrderID).HasColumnName("OrderID");
        this.Property(e => e.Details).HasColumnName("Details");
        this.ToTable("Orders");
    }
}

    La configuration de la relation d'une entité est suffisant.

    "Vous devez mapper les deux propriétés qui participent à la relation. Vous devez ajouter ClientID colonne à la table Commandes." Que voulez-vous dire exactement par là?
    propriété dans ClientModel et Client propriété dans OrderModel que les deux participants de la relation.
    Je ne comprends toujours pas. N'étais-je pas la cartographie à la fois d'eux? Peut être pourrais tu poster le code complet? Et pourquoi ai-je besoin ClientID dans les Ordres (OrderModel?)?
    J'ai posté le code complet pour la cartographie. La façon dont vous avez mappé sera interprété par EF comme deux relations différentes. Depuis un Order nécessite un Client vous avez besoin d'ajout de la colonne de clé étrangère ClientID à Order table
    N'est-ce pas ClienModel Client; assez comme une clé étrangère?

    OriginalL'auteur Eranga

  2. 0

    Cela peut aider (il m'a aidé, quand je ne pouvais pas comprendre comment cela fonctionne):

    Si vous avez les classes comme ceci:

    class ClientModel
{
    int ClientId;
    string Name;
}

class OrderModel
{
    int OrderId;
    string Details;
    int ClientId;
}

    Puis, cela représenterait 2 tables dans votre base de données qui "ne serait pas" être connectés les uns avec les autres par l'intermédiaire d'une clé étrangère (ils seraient connectés via le ClientId dans le OrderModel) et vous pourriez obtenir des données comme des "GetAllOrdersWithSomeClientId" et "GetTheClientNameForSomeClientId" à partir de la base de données. MAIS les problèmes surviennent lorsque vous supprimez une Client à partir de la base de données. Parce qu'alors il y aurait encore Orders qui contiendrait une ClientId qui n'existe pas dans la Client tableau plus et qui aurait conduit à des anomalies dans votre base de données.

    La virtual List<OrderModel> Orders; (dans le ClientModel) et virtual ClienModel Client; (dans le OrderModel) sont nécessaires pour créer la relation aka. la clé étrangère entre les tables ClientModel et OrderModel.

    Il y a une chose sur laquelle je ne suis toujours pas sûr à ce sujet. Qui est le int ClientId; dans le OrderModel. Je suppose qu'il doit avoir le même nom que le ClientId dans le ClientModel de sorte que le cadre de l'entité sait qui 2 les attributs de la clé étrangère doit se connecter. Ce serait bien si quelqu'un pouvait expliquer cela en détail.

    Aussi, mettre ceci dans votre constructeur DbContext si quelque chose souldn pas:

    this.Configuration.ProxyCreationEnabled = false;
this.Configuration.LazyLoadingEnabled = false;

    OriginalL'auteur Jo Smo