多对多关系-实体框架

Question

I'm working with a many to many relation, basically:

+-------------+ +-----------------+ +---------------------------+
|    Redes    | |    Objetivos    | |       RedesObjetivos      |
+-------------+ +-----------------+ +---------------------------+
|   | RedesID | |   | ObjetivosID | |   | RedesID | ObjetivosID |
+---+---------+ +-----------------+ +---------------------------+
| 1 |         | | 1 |             | | 1 |         |             |
+---+---------+ +-----------------+ +---------------------------+

Table Objetivos is a set of previously registered options. When my user tries to register a new Redes, he chooses among a list of Objetivos and save.

At this moment Objetivos table has 8 options

+------------------+
|     Objetivos    |
+------------------+
|    | ObjetivosID |
+----+-------------+
| 1  |      1      |
+----+-------------+
| 2  |      2      |
+----+-------------+
| 3  |      3      |
+----+-------------+
| 4  |      4      |
+----+-------------+
| 5  |      5      |
+----+-------------+
| 6  |      6      |
+----+-------------+
| 7  |      7      |
+----+-------------+
| 8  |      8      |
+----+-------------+

Lets suppose I include a new Redes and select Objetivos 5 to 8 The final result currently is:

+-------------+ +-------------------+ +---------------------------+
|    Redes    | |     Objetivos     | |       RedesObjetivos      |
+-------------+ +-------------------+ +---------------------------+
|   | RedesID | |   | ObjetivosID   | |   | RedesID | ObjetivosID |
+---+---------+ +---+---------------+ +---------------------------+
| 1 |    1    | | 1 |      1        | | 1 |    1    |      9      |
+---+---------+ +---+---------------+ +---------------------------+
                | 2 |      2        | | 2 |    1    |      10     |
                +---+---------------+ +---------------------------+
                | 3 |      3        | | 3 |    1    |      11     |
                +---+---------------+ +---------------------------+
                | 4 |      4        | | 4 |    1    |      12     |
                +---+---------------+ +---------------------------+
                | 5 |      5        |
                +---+---------------+
                | 6 |      6        |
                +---+---------------+
                | 7 |      7        |
                +---+---------------+
                | 8 |      8        |
                +---+---------------+
                | 9 |      9        |
                +---+---------------+
                | 10|      10       |
                +---+---------------+
                | 11|      11       |
                +---+---------------+
                | 12|      12       |
                +---+---------------+

The result I want is:

+-------------+ +-------------------+ +---------------------------+
|    Redes    | |     Objetivos     | |       RedesObjetivos      |
+-------------+ +-------------------+ +---------------------------+
|   | RedesID | |   |  ObjetivosID  | |   | RedesID | ObjetivosID |
+---+---------+ +---+---------------+ +---------------------------+
| 1 |    1    | | 1 |       1       | | 1 |    1    |      5      |
+---+---------+ +---+---------------+ +---------------------------+
                | 2 |       2       | | 2 |    1    |      6      |
                +---+---------------+ +---------------------------+
                | 3 |       3       | | 3 |    1    |      7      |
                +---+---------------+ +---------------------------+
                | 4 |       4       | | 4 |    1    |      8      |
                +---+---------------+ +---------------------------+
                | 5 |       5       |
                +---+---------------+
                | 6 |       6       |
                +---+---------------+
                | 7 |       7       |
                +---+---------------+
                | 8 |       8       |
                +---+---------------+   

Basically, EF is not identifying that Objetivos already exists in the database and is creating new rows. How can I correctly indicate to EF that those Objetivos are already there ?

I went through a lot of search on how to work with many to many with EF and I know that there are questions that are similar to mine, but since I could not solve my problem with them, I decided to post my whole scenario in order to get help.

This is what I have at the moment:

//DAL Layer

//Interface where a set the basic database methods
public interface IDao<T> where T : class
{
    //Save
    int Salva(T Modelo);
    //Update
    int Atualiza(T model);
    //Delete
    void Exclui(T model);
    //GetAll
    IEnumerable<T> ObtemTodos();
    //GetByID
    T ObtemPorId(object id);
    IEnumerable<T> Where(Expression<Func<T, bool>> expression);
    IEnumerable<T> OrderBy(Expression<System.Func<T, bool>> expression);
}

//Generic context, where i implement the methods in the interface
public partial class dbContext<T> : DbContext where T : class
    {
        public DbSet<T> DbSet
        {
            get;
            set;
        }

        public dbContext()
            : base("name=dbContext")
        {
        }

        public virtual void ChangeObjectState(object model, EntityState state)
        {
            ((IObjectContextAdapter)this)
                            .ObjectContext
                            .ObjectStateManager
                            .ChangeObjectState(model, state);
        }

        //Save
        public virtual int Salva(T model)
        {
            this.DbSet.Add(model);
            return this.SaveChanges();
        }
        //Update
        public virtual int Atualiza(T model)
        {
            var entry = this.Entry(model);

            if (entry.State == EntityState.Detached)
                this.DbSet.Attach(model);

            this.ChangeObjectState(model, EntityState.Modified);
            return this.SaveChanges();
        }
        //Delete
        public virtual void Exclui(T model)
        {
            var entry = this.Entry(model);

            if (entry.State == EntityState.Detached)
                this.DbSet.Attach(model);

            this.ChangeObjectState(model, EntityState.Deleted);
            this.SaveChanges();
        }
        //GetAll
        public virtual IEnumerable<T> ObtemTodos()
        {
            return this.DbSet.ToList();
        }
        //GetByID
        public virtual T ObtemPorId(object id)
        {
            return this.DbSet.Find(id);
        }

        public virtual IEnumerable<T> Where(Expression<Func<T, bool>> expression)
        {
            return this.DbSet.Where(expression);
        }

        public IEnumerable<T> OrderBy(Expression<Func<T, bool>> expression)
        {
            return this.DbSet.OrderBy(expression);
        }
    }

//Then the relevant DAO classes where I implement specific database methods if necessary
public class RedesDAO : dbContext<Redes>, IDao<Redes>
    {
        //Save
        public override int Salva(Redes Model)
        {
            ObjetivosDAO ObjetivosDAO = new ObjetivosDAO();
            Model.RedeObjetivos = new List<Objetivos>();

            //ObjetivosSelecionados is a List<int> with Ids that relates to user's selected options on my view
            //each option relates to an especific Objetivos row that already exist in the database
            foreach (int ObjetivoID in Model.ObjetivosSelecionados)
            {
                //So, with each ID I obtain the whole information for that entity
                //by using the ObtemPorId = GetByID method and adding it to models' collection
                Objetivos Objetivo = ObjetivosDAO.ObtemPorId(ObjetivoID);
                Model.RedeObjetivos.Add(Objetivo);                
            }

            this.DbSet.Add(Model);
            return this.SaveChanges();
        }        

        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
            modelBuilder.Entity<Redes>().
              HasMany(c => c.RedeObjetivos).
              WithMany(p => p.Redes).
              Map(
               m =>
               {
                   m.MapLeftKey("RedeID");
                   m.MapRightKey("ObjetivoID");
                   m.ToTable("RedesObjetivos");
               });
        }
    }

public class ObjetivosDAO : dbContext<Objetivos>, IDao<Objetivos>
    {
        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
            modelBuilder.Entity<Objetivos>().
              HasMany(c => c.Redes).
              WithMany(p => p.RedeObjetivos).
              Map(
               m =>
               {
                   m.MapLeftKey("ObjetivoID");
                   m.MapRightKey("RedeID");
                   m.ToTable("RedesObjetivos");
               });
        }
    }   

//And my models/tables
public partial class Redes
    {
        [Key]
        [DatabaseGenerated(DatabaseGeneratedOption.Identity)]
        public int RedeID { get; set; }
        [Required]
        public ICollection<Objetivos> RedeObjetivos { get; set; }
        [NotMapped]
        public List<int> ObjetivosSelecionados { get; set; }        
    }

public partial class Objetivos
    {
        [Key]
        [DatabaseGenerated(DatabaseGeneratedOption.Identity)]
        public int ObjetivoID { get; set; }
        [Required]
        public ICollection<Redes> Redes { get; set; }
    }

Note that the method I execute in order to save a new Redes is the override that is on the RedesDAO class.

//Model = Information that comes from my view
public override int Salva(Redes Model)

Answer 1

You specify 2 different DbContexts, RedesDAO and ObjetivosDAO . The context of the EntityFramework is different for both objects, meaning that your second context cannot see that the object is taken from the database.

To fix, you can replace the following line:

Objetivos Objetivo = ObjetivosDAO.ObtemPorId(ObjetivoID);

with:

Objetivos Objetivo = base.Set<Objetivos>().Find(ObjetivoID);

This should prevent the objects from being mistaken for new.

---

As a sidenote, unless you have a specific reason for separating them, it might be better to use a single DbContext class for communicating with your database.