Question

This is my first experience with EF so I’m probably doing something stupid. Any comments on the architecture are welcome.

So I have the typical class of Users. Users have a username and a list of roles:

 public class User
 {
     public string UserID{ get; set; }
     public List<Role> Roles { get; set; }
     public int Id { get; set; }
     public User()
     {
         Roles = new List<Role>();
     }
}

My domain objects live in their own code library along with the interfaces for their repositories. So in this case there would be an IUserRepository with all the CRUD methods plus any specialized data access methods I might need. What I’m trying to do is implement these repository interfaces with EF4 in another class library. Any problems with this design so far?

Now in the db (sql server) I have the typical tables: Users, Roles, and a many-to-many table mapping users to roles UsersRoles.

I have successfully set up most of the CRUD methods in the EF lib. Here is what Save looks like

public void Save(Drc.Domain.Entities.Staff.User member)
    {
        using (var ctx = new DrcDataContext())
        {
            var efUser = MapFromDomainObject(member);
            if(member.Id < 1)
            {                    
                ctx.Users.AddObject(efUser);                    
            }
            else
            {                             
                ctx.Users.Attach(efUser);
                ctx.ObjectStateManager.ChangeObjectState(efUser, EntityState.Modified);
            }          
            ctx.SaveChanges();
            member.Id = efUser.UserId;                
        }            
    }

Now I’m not sure if this is the proper way of accomplishing this but it works. However, I run into problems when doing a delete. The problem is with the related tables

public void Delete(Drc.Domain.Entities.Staff.User member)
    {
        using (var ctx = new DrcDataContext())
        {
            var efUser = MapFromDomainObject(member);    ctx.Users.Attach(efUser);
            while (efUser.Roles.Count > 0)
            {
                ctx.ObjectStateManager.ChangeObjectState(efUser.Roles.First(), EntityState.Deleted);
            }                        
            ctx.SaveChanges();
            ctx.ObjectStateManager.ChangeObjectState(efUser, EntityState.Deleted);
            ctx.SaveChanges();
        }
    }

If I don’t delete the roles in the while loop I get a DELETE conflict with reference constraint error. If I run the code above it does delete the proper rows in the many-to-many table but it also deletes rows in the Roles table. I’m at a dead end now and considering scraping the ORM idea and writing my repository implementations in good ole reliable ADO.net.

–Edit I’m guessing that this is not the correct way to implement repositories with EF. Is it possible to do without littering your domain with a bunch of EF-centric stuff?

Answer 1

Use simply the standard approach and don’t mess around with the entity state:

public void Delete(Drc.Domain.Entities.Staff.User member)
{
    using (var ctx = new DrcDataContext())
    {
        var efUser = MapFromDomainObject(member);
        ctx.Users.Attach(efUser);
        ctx.Users.DeleteObject(efUser);
        ctx.SaveChanges();
    }
}

There is usually a cascading delete in the database from the User table to the join table (if you didn’t disable it by hand). So deleting the user will delete the corresponding rows in the join table as well (but not the roles of course).

Setting the state of an entity to Deleted is not the same as calling DeleteObject. It will only set the parent to deleted and leave the children in an undeleted state in the context, leading to the constraint violation exception. DeleteObject will also mark the children in the context as Deleted and therefore avoid the exception.