EF6 le Premier Code: à l'Aide d'API Fluent pour déclarer une Clé Étrangère

Je suis en train de travailler sur un secteur de l'assurance liée app avec EF 6 et le Premier Code. Pour cette application, chaque Compte peut avoir plusieurs Stratégies et chaque Politique peut avoir plusieurs Transactions. De plus, chaque Compte doit avoir une relation à l'Identité (Nom, Adresse, Ville, etc.). La Politique a aussi une relation à une Identité, mais il est facultatif.

Parce que de Compte -> l'Identité et le Compte ->> Politique -> Identité, j'ai trouvé que j'ai besoin d'utiliser l'API Fluent pour définir la WillCascadeDelete à Faux pour au moins l'un de ces chemins.

Ma question est comment puis-je configurer le Compte.IdentityId et de la Politique.InsuredIdentityId des propriétés de clés étrangères? J'ai évité d'ajouter tout de la navigation et des champs de clé étrangère à l'identité de classe, car il ne devrait jamais être une raison pour passer d'une identité à une autre classe. C'est pourquoi je vais avoir un moment difficile de trouver cela?

public class Account
{
    public long Id { get; set; }
    public long IdentityId { get; set; }
    public virtual Identity Identity { get; set; }

    public ICollection<Policy> Policies { get; set; }
}

public class Policy
{
    public long Id { get; set; }

    public long AccountId { get; set; }
    public virtual Account Account { get; set; }

    public bool UseAccountIdentity { get; set; }
    public long InsuredIdentityId { get; set; }
    public virtual Identity InsuredIdentity { get; set; }
}

 public class Identity 
{        
    public long Id { get; set; }

    public string Name { get; set; }
    public string Address1 { get; set; }
    public string Address2 { get; set; }
    public string City { get; set; }
    public string State { get; set; }
    public string Zip { get; set; }
}

public class AccountConfiguration : EntityTypeConfiguration<Account>
{
    public AccountConfiguration()
    {
        HasRequired(a => a.Identity).WithOptional(x => x.Account).WillCascadeOnDelete(false);
        HasMany(a => a.Policies).WithRequired(p => p.Account).HasForeignKey(p => p.AccountId);
    }
}

public class PolicyConfiguration : EntityTypeConfiguration<Policy>
{
    public PolicyConfiguration()
    {
        HasOptional(p => p.InsuredIdentity).WithOptionalPrincipal().WillCascadeOnDelete(false);
    }
}

Que d'un côté de la question, existe-il des bons livres ou d'autres sources de référence pour EF Premier Code? J'ai Julia Lerman Programmation Entity Framework: le Premier Code, ce qui est bien pour les exemples qu'il couvre, mais il ne couvre pas assez les affaires.

OriginalL'auteur Steve Wash | 2014-01-16

  1. 5

    Tout d'abord, public ICollection<Policy> Policies { get; set; } devrait être public virtual ICollection<Policy> Policies { get; set; }.

    Vous ne pouvez carte EF propriétés de clés étrangères lorsqu'un côté de la relation est un, et l'autre est une de nombreuses. Chaque fois que vous avez un rapport de 1:1 ou 1:0..1 relation, la charge de l'entité prendra la même clé primaire que le principal. Dans ces cas, il ne peut y avoir une clé étrangère, car dépendante de la clé étrangère EST sa clé primaire.

    Donc, pour cela:

    HasRequired(a => a.Identity).WithOptional(x => x.Account)

    ... compte de l'Id sera la même valeur que l'identité de l'Id. Ce qui signifie, vous pouvez supprimer complètement le IdentityId bien de la Account entité. Cependant, je ne comprends pas comment ce code compile, parce que Identity ne dispose pas d'un Account propriété de navigation..?

    Quand il s'agit de votre Politique de cartographie, est-ce vraiment la façon dont vous voulez le faire? Vous dites qu'un Politique peut disposer en option d'une relation à une Identité, mais la façon dont vous le faites:

    HasOptional(p => p.InsuredIdentity).WithOptionalPrincipal()

    ...signifie qu'une Identity ne peuvent être liées (directement) faire une Policy. Quel est le problème avec le fait de faire la cartographie ressembler à ceci?

    HasOptional(p => p.InsuredIdentity).WithMany()
    .HasForeignKey(x => x.InsuredIdentityId)
    .WillCascadeOnDelete(false);

    Ci-dessus, vous n'avez toujours pas toutes les propriétés de navigation de Identity à Policy. Vous n'en avez pas besoin, vous pouvez simplement appeler .WithMany() comme un no-arg. Cependant, cette raconte la base de données pour configurer Identity que le principal, et Policy que la personne à charge, de sorte que vous aurez un fk relation dans la db, et vous ne pouvez toujours pas accéder à un Policy à partir d'un Identity dans le code.

    Autres commentaires:

    La Politique a aussi une relation à une Identité, mais il est facultatif.

    Cela signifie que Policy.InsuredIdentityId devrait être un System.Nullable<long>.

    Pas tout à fait ce que je suis en train de réaliser, mais je pense que c'est moi sur le droit chemin.
    Je suis sûr que c'est un domaine complexe, et il ya probablement quelques différentes façons de modèle. Remarque vous pouvez toujours faire les choses à zéro-ou-un-à-plusieurs dans le modèle EF pour permettre fk propriétés, et omettez simplement les propriétés de navigation sur le côté unidirectionnel relations. Tout moment, vous avez un vrai 1:1 ou 1:0..1 bien que, vous n'avez vraiment envie de partager la même clé primaire, auquel cas les clés étrangères ne faites pas de sens.

    OriginalL'auteur danludwig

  2. 1

    Mon problème était de nature conceptuelle. Alors que généralement une Identité ne s'appliquerait qu'à un seul Compte (ce qui m'a le visualiser dans un rapport de 1:1), théorie de l'Identité peut être utilisé plus d'une fois et, par conséquent, sur plus d'un Compte. Si j'utilise la configuration suivante, j'obtiens ce que je cherchais. Son moi, ensuite, de faire appliquer les règles comme une Identité ne peut être utilisée qu'avec un seul Compte (mais comme beaucoup de Politiques sont nécessaires)

    public class IdentityConfiguration : EntityTypeConfiguration<Identity>
{
    public IdentityConfiguration()
    {
        HasMany(i => i.Accounts).WithRequired(i => i.Identity).HasForeignKey(a => a.IdentityId);            
    }
}

    Sinon, j'aurais pu l'Identité de l'entité Principale et le Compte de l'option dépend. ce serait le travail, parce que tous les Comptes ont une Identité, mais pas toutes les Identités sont liées à un Compte. Compte aurait plus sa propre clé.

    Ce n'est pas intuitive, qui est un peu inquiétant.

    Rien au sujet de l'assurance est intuitive.
    Ne peut pas argumenter avec ça. Sa me prend quelques minutes pour me faire une idée à ce sujet, mais en se penchant vers Identité de l'entité principale 1:1 avec Compte. Merci.
    Rappelez-vous qu'un 1:1, vous aurez à créer et à supprimer les deux dans la même transaction. Vous ne pouvez pas en créer un, l'enregistrer, puis le lien de l'autre.
    N'est-ce pas seulement le cas si requis sur les deux extrémités? Dans mon cas, un Compte ne peut pas être créé sans une Identité, mais une Identité peut être créé sans un Compte, c'est à dire à être utilisé pour une Politique.
    Ok, alors, nous sommes juste ici dans la sémantique. Je dirais que un 1:0..1 (un à zéro ou un). Vous êtes de droite, vous pouvez le rendre facultatif sur une extrémité et de retarder la création de l'requis côté.

    OriginalL'auteur Steve Wash