entity-framework - intermediate - entity framework many to many

La introducción de la restricción FOREIGN KEY puede causar ciclos o múltiples rutas en cascada

Question

Estoy recibiendo este error

Al introducir la restricción FOREIGN KEY ''FK_dbo.Regions_dbo.Countries_CountryId'' en la tabla ''Regions'' puede provocar ciclos o múltiples rutas en cascada. Especifique ON DELETE NO ACTION o ON UPDATE NO ACTION, o modifique otras restricciones FOREIGN KEY. No se pudo crear una restricción. Ver errores previos.

Me pregunto, ¿significa esto que el diseño de mi base de datos es malo? Leí que apagabas las cascadas o algo por el estilo, pero no estoy seguro si eso está eliminando el problema de la alfombra.

Solo estoy dejando que EF genere mis tablas a través de mi clase de dominio (no estoy usando ninguna anotación de datos o mapeo fluido en este punto).

       public class Country
        {
            public Country()
            {
                this.Stores = new List<Store>();
                this.Regions = new List<Region>();
                Id = GuidCombGenerator.GenerateComb();
            }

            public Guid Id { get; private set; }

            private string name;

            public string Name
            {
                get { return name; }
                set
                {
                    name = value.Trim();
                }
            }

            private string code;

            public string Code
            {
                get { return code; }
                set
                {
                    code = value.Trim();
                }
            }

            public virtual ICollection<Store> Stores { get; set; }
            public virtual ICollection<Region> Regions { get; set; }
        }


          public class City
        {
            public City()
            {
                this.Stores = new List<Store>();
                Id = GuidCombGenerator.GenerateComb();
            }

            public Guid Id { get; private set; }

            private string name;

            public string Name
            {
                get { return name; }
                set
                {
                    name = value.Trim();
                }
            }


            public Guid RegionId { get; set; }
            public virtual Region Region { get; set; }

            public virtual ICollection<Store> Stores { get; set; }
        }


            public class Region
        {
            public Region()
            {
                this.Cities = new List<City>();
              this.Stores = new List<Store>();


                Id = GuidCombGenerator.GenerateComb();
            }

            public Guid Id { get; private set; }


            private string state;

            public string State
            {
                get { return state; }
                set
                {
                    state = value.Trim();
                }
            }


            public Guid CountryId { get; set; }
            public virtual ICollection<City> Cities { get; set; }
            public virtual Country Country { get; set; }
           public virtual ICollection<Store> Stores { get; set; }
        }


  public class Store
    {
        public Store()
        {
            Id = GuidCombGenerator.GenerateComb();

            Users = new List<User>();
        }

        public Guid Id { get; private set; }

        public Guid CountryId { get; set; }
        public Guid CityId { get; set; }
        public Guid RegionId { get; set; }
        public virtual City City { get; set; }
        public virtual Country Country { get; set; }
        public virtual Region Region { get; set; }

        public virtual ICollection<User> Users { get; set; }

    }

¿Podría ser por las tiendas?

Answer 1

Agregue modelBuilder.Conventions.Remove<OneToManyCascadeDeleteConvention>() en el método OnModelCreating de su archivo DataContext la siguiente manera:

public class YourDataContext : DbContext
{
    public DbSet<Country> Countries{ get; set; }
    ...


    protected override void OnModelCreating(DbModelBuilder modelBuilder)
    {
        modelBuilder.Conventions.Remove<OneToManyCascadeDeleteConvention>();

    }
}

La misma pregunta: entity-framework-how-to-solve-foreign-key-constraint-may-cause-cycles-or-multi

Answer 2

Se requieren todas las relaciones en su modelo porque todas las propiedades de clave foránea ( CountryId , RegionId , CityId ) no son anulables . Para las relaciones de uno a varios requeridas, EF habilitará la eliminación en cascada por convención.

Country y la Region tienen múltiples rutas de eliminación a la tabla Store , por ejemplo, si elimina un Country los Store relacionados se pueden eliminar a través de tres rutas en cascada diferentes (lo cual no está permitido con SQL Server):

• Country -> Store
• Country -> Region -> Store
• Country -> Region -> City -> Store

Debe evitar tales rutas de eliminación ambiguas al deshabilitar la eliminación en cascada mediante la API de Fluent o definiendo algunas de las relaciones como opcionales (¿con una clave externa anulable Guid? ).

O elimine las colecciones de Stores (y las referencias inversas y las propiedades de FK) de todas las entidades, excepto City . Para mí, esas colecciones parecen redundantes porque puedes encontrar todas las tiendas en un Country navegando por las colecciones Regions.Cities.Stores .