Entity Framework Code First 5 Effacer en Cascade sur de nombreux de nombreux tableaux d'erreur

J'ai ce modèle

public class State
{
public State()
{
this.Promotions = new List<Promotion>();
this.Branches = new List<Branch>();
this.Stores = new List<Store>();
}
public int Id { get; set; }
public string Description { get; set; }
public virtual ICollection<Promotion> Promotions { get; set; }
public virtual ICollection<Store> Stores { get; set; }
public virtual ICollection<Branch> Branches { get; set; }
}
public class Store
{
public Store()
{
this.Promotions = new List<Promotion>();
this.Branches = new List<Branch>();
}
public int Id { get; set; }
public string Name { get; set; }
public virtual ICollection<Promotion> Promotions { get; set; }
public virtual ICollection<Branch> Branches { get; set; }
public int StateId { get; set; } //Foreign key
public virtual State State { get; set; } //Navigation Property
}
public class Branch
{
public Branch()
{
this.Promotions = new List<Promotion>();
}
public int Id { get; set; }
public string Name { get; set; }
public int StoreId { get; set; } //Foreign key
public int StateId { get; set; } //Foreign key
public virtual Store Store { get; set; } //Navigation Property
public virtual State State { get; set; } //Navigation Property
public virtual ICollection<Promotion> Promotions { get; set; }
}
public class Promotion
{
public Promotion()
{
this.Stores = new List<Store>();
this.Branches = new List<Branch>();
this.Productos = new List<Producto>();
}
public int Id { get; set; }
public string Name { get; set; }
public int StateId { get; set; }
public virtual ICollection<Store> Stores { get; set; }
public virtual ICollection<Branch> Branches { get; set; }
public virtual ICollection<Product> Products { get; set; }
public virtual State State { get; set; }
}

Et ceci dans mon contexte:

//State
modelBuilder.Entity<State>()
.HasMany(p => p.Promotions)
.WithRequired(e => e.State)
.WillCascadeOnDelete(false);
modelBuilder.Entity<State>()
.HasMany(s => s.Branches)
.WithRequired(e => e.State)
.WillCascadeOnDelete(false);
modelBuilder.Entity<State>()
.HasMany(e => e.Stores)
.WithRequired(e => e.State)
.WillCascadeOnDelete(true);
//Store
modelBuilder.Entity<Store>()
.HasMany(b => b.Branches)
.WithRequired(s => s.Store)
.WillCascadeOnDelete(true);
//Many to many
modelBuilder.Entity<Store>().
HasMany(p => p.Promotions).
WithMany(s => s.Stores).
Map(
m =>
{
m.MapLeftKey("StoreId");
m.MapRightKey("PromotionId");
m.ToTable("Store_Promotion");
});
modelBuilder.Entity<Promotion>().
HasMany(e => e.Products).
WithMany(p => p.Promotiones).
Map(
m =>
{
m.MapLeftKey("PromotionId");
m.MapRightKey("ProductoId");
m.ToTable("Promotion_Producto");
});
modelBuilder.Entity<Branch>().
HasMany(p => p.Promotiones).
WithMany(b => b.Branches).
Map(
m =>
{
m.MapLeftKey("BranchId");
m.MapRightKey("PromotionId");
m.ToTable("Branch_Promotion");
});

Maintenant, si je tourne sur plus d'un WillCascadeOnDelete de l'État (les trois premiers dans la courant de la cartographie), je reçois l'erreur

Méthode d'essai Proj.Les données.Les Tests.UnitTest1.TestPromotion jeté exception:
Système.Les données.SqlClient.SqlException: Introduction d'une contrainte de CLÉ ÉTRANGÈRE 'FK_dbo.Branch_dbo.Store_StoreId' sur la table 'Branche' peut provoquer des cycles ou en cascade de plusieurs chemins. Spécifier on DELETE NO ACTION ou de la mise À JOUR, AUCUNE ACTION, ou modifier d'autres contraintes de CLÉ ÉTRANGÈRE.
N'a pas pu créer de contrainte. Voir les erreurs précédentes.

Je le sais, et j'ai lu à partir de Julie Lerman livre:

Certaines bases de données (SQL Server) ne prennent pas en charge les relations multiples qui spécifient
effacer en cascade pointant vers la même table

Comme cela arrive depuis la de nombreux de nombreux de la relation tableau a effacer en cascade provenant de deux tables liées.

Donc, ma question est: La seule solution ici est d'éteindre effacer en cascade sur les tables parent et de gérer la suppression sur la table de relation manuellement? N'est-il pas une solution de contournement de l'Entity Framework 5 pour cela?

OriginalL'auteur polonskyg | 2012-11-15

  1. 6

    Ok, j'ai compris le problème. Il n'est pas d'avoir beaucoup de relation, le problème est le

    State -> Promotion -> PromotionStore
State -> Branch -> BranchPromotion
State -> Store -> StorePromotion

    puis de Stocker, de Direction et de Magasin ont FK à l'État. Donc, si je supprime un État PromotionStore peut être atteint par les 1er et 3ème possibilités.

    Ce que j'ai à faire est de désactiver effacer en cascade de l'Etat et de supprimer les enregistrements associés manuellement comme ceci:

    public override void Delete(State state)
{
DbContext.Entry(state).Collection(x => x.Promotions).Load();
DbContext.Entry(state).Collection(x => x.Stores).Load();
DbContext.Entry(state).Collection(x => x.Branches).Load();
var associatedPromotions = state.Promotions.Where(p => p.StateId == state.Id);
associatedPromotions.ToList().ForEach(r => DbContext.Set<Promotion>().Remove(r));
var associatedStores = state.Stores.Where(e => e.StateId == state.Id);
associatedStores.ToList().ForEach(e => DbContext.Set<Store>().Remove(e));
var associatedBranches = state.Branches.Where(s => s.StateId == state.Id);
associatedBranches.ToList().ForEach(s => DbContext.Set<Branch>().Remove(s));
base.Delete(state);
}

    OriginalL'auteur polonskyg