实体框架保存了太多子实体

Question

I'm working on a project that consists of multiple objects that I want to save to my database. I'm using a single context and a series of repository classes to access them.

When I try to save an entity, it seems to save all the virtual entities associated with it, even if that entity exists in the database already.

These are my classes:

public class Requirement
{
    public int ID { get; set; }
    public DateTime DateDue { get; set; }
    public DateTime DateCompleted { get; set; }

    public virtual Standard Standard { get; set; }
    public virtual Project Project { get; set; }
}

public class Standard
{
    public int ID { get; set; }
    public int AgencyID { get; set; }
    public string Name { get; set; }

    public virtual Agency Agency { get; set; }
}


public class Project
{
    public int ID { get; set; }
    public bool Active { get; set; }

    public virtual Agency Agency { get; set; }
    public virtual Department Department { get; set; }
}

And this is the method I have for creating some data:

public class RequirementRepository
{
    public static string CreateMockData()
    {
        StandardRepository stdRep = new StandardRepository();
        ProjectRepository projRep = new ProjectRepository();
        RequirementRepository reqRep = new RequirementRepository();
        Project project = projRep.Find(1);
        StringBuilder sb = new StringBuilder()
        foreach (Standard s in stdRep.FindByAgencyID(project.Agency.ID))
        {
            Requirement r = new Requirement();
            r.Project = project;
            r.Standard = s;
            r.DateCompleted = (DateTime)SqlDateTime.MaxValue;
            r.DateDue = DateTime.Now.AddDays(90);

            r = reqRep.Save(r);

            sb.AppendLine(String.Format("Saved Requirement ID {0} with Project ID {1}<br>", r.ID, r.Project.ID));
        }

        return sb.ToString();
    }
}

And here is associated repository code:

public class ProjectRepository
{
    public Project Find(int id)
    {
        using (var db = new MyContext())
        {
            return db.Projects
                .Include(p => p.Agency)
                .Include(p => p.Department)
                .First(p => p.ID.Equals(id));
        }
    }
}


public class StandardRepository
{
    public List<Standard> FindByAgencyID(int agencyID)
    {
        using (var db = new MyContext())
        {
            return db.Standards.Where(r => r.AgencyID == agencyID).ToList();
        }
    }
}



public class RequirementRepository
{
    public Requirement Save(Requirement requirement)
    {
        using (var db = new MyContext())
        {
            Requirement retVal = requirement;
            if (requirement.ID.Equals(0))
            {
                retVal = db.Requirements.Add(requirement);
            }
            else
            {
                db.Entry(requirement).State = EntityState.Modified;
            }

            db.SaveChanges();
            return retVal;
        }
    }
}

When I run this method, I expect it to insert a number of new Requirements into the database with the project ID of 1 and a standard ID of whatever standard it's on. Instead, it creates a whole new project and a whole new standard for every requirement it adds, then assigns those IDs to the requirement.

Answer 1

Each context keeps track of the entities loaded, modified and the entities added.

Your repositories need to look something like this....

public class StandardRepository
{
    MyContext _context;

    public StandardRepository(MyContext context)
    {
        _context = context;
    }

    public List<Standard> FindByAgencyID(int agencyID)
    {
        return _context.Standards.Where(r => r.AgencyID == agencyID).ToList();
    }
}

public class RequirementRepository
{
    MyContext _context;

    public RequirementRepository(MyContext context)
    {
        _context = context;
    }

    public Requirement Save(Requirement requirement)
    {
    Requirement retVal = requirement;
    if (requirement.ID.Equals(0))
    {
        retVal = _context.Requirements.Add(requirement);
    }
    else
    {
        _context.Entry(requirement).State = EntityState.Modified;
    }

    _context.SaveChanges();
    return retVal;
    }
}

public class RequirementRepository
{
    public static string CreateMockData()
    {
        using(MyContext context = new MyContext())
        {
                StandardRepository stdRep = new StandardRepository(context);
                ProjectRepository projRep = new ProjectRepository(context);
                RequirementRepository reqRep = new RequirementRepository(context);
                Project project = projRep.Find(1);
                StringBuilder sb = new StringBuilder()
                foreach (Standard s in stdRep.FindByAgencyID(project.Agency.ID))
                {
                Requirement r = new Requirement();
                r.Project = project;
                r.Standard = s;
                r.DateCompleted = (DateTime)SqlDateTime.MaxValue;
                r.DateDue = DateTime.Now.AddDays(90);

                r = reqRep.Save(r);

                sb.AppendLine(String.Format("Saved Requirement ID {0} with Project ID {1}<br>", r.ID, r.Project.ID));
            }
        }
        return sb.ToString();
    }
}

Answer 2

From my understanding, you shouldn't have to manually set the state of the object you have modified unless you have detached it from its context. EF keeps track of the object state.

I like to use something like this:

    public abstract class EntityRepositoryBase<TEntity> : IDisposable, IEntityRepositoryBase<TEntity> where TEntity : class , IEntityWithId
    {
        protected EntityRepositoryBase()
        {
            Context = new SomeEntities();
        } 

        public abstract ObjectSet<TEntity> EntityCollection { get; }
        public SomeEntities Context { get; set; }

        public TEntity GetById(int id)
        {
            return EntityCollection
                .FirstOrDefault(x => x.Id == id);
        }

    public void Dispose()
    {
        Context.Dispose();
    }
}

Then in the deriving repositories:

public class AnswerRepository : EntityRepositoryBase<AnswerEntity>, IAnswerRepository
{
    public override ObjectSet<AnswerEntity> EntityCollection
    {
        get { return Context.AnswerEntities; }
    }
}

I inject the Repositories into the relevant class using ninject but you should be able to get similar with:

using (var repo = new AnswerRepository()) 
{ 
// modifying via Context
var someEntity = repo.GetById(someId);
someEntity.Value = "1";
repo.Context.SaveChanges();

//modifying via repo
repo.Delete(anotherEntity);
}

and then doing what you need to do. The context is exposed via the interface IEntityRepositoryBase should you need to perform out-of-repository modifications and then SaveChanges() as well as any specific CRUD type methods in your repo. Once out of scope the object and the underlying connection will be closed.