Patrón de repositorio con Entity Framework 4.1 y Relaciones Padre / Hijo

Todavía tengo cierta confusión con el Patrón del Repositorio. La razón principal por la que quiero usar este patrón es evitar llamar a operaciones de acceso a datos específicos de EF 4.1 desde el dominio. Prefiero llamar operaciones CRUD genéricas desde una interfaz IRepository. Esto hará que las pruebas sean más fáciles y si alguna vez tengo que cambiar el marco de acceso a datos en el futuro, podré hacerlo sin refactorizar mucho código.

He Aquí un ejemplo de mi situación:

Tengo 3 tablas en la base de datos: Group, Person, y GroupPersonMap. GroupPersonMap es una tabla de enlaces y solo consiste en las claves primarias Group y Person. Creé un modelo EF de las 3 tablas con VS 2010 designer. EF fue lo suficientemente inteligente como para asumir que GroupPersonMap es una tabla de enlaces para que no se muestre en el diseñador. Quiero usar mis objetos de dominio existentes en lugar de las clases generadas por EF, por lo que desactivo la generación de código para el modelo.

Mis clases existentes que coinciden con el modelo EF son las siguientes:

public class Group
{
   public int GroupId { get; set; }
   public string Name { get; set; }

   public virtual ICollection<Person> People { get; set; }
}

public class Person
{
   public int PersonId {get; set; }
   public string FirstName { get; set; }

   public virtual ICollection<Group> Groups { get; set; }
}

I tener una interfaz de repositorio genérica como esta:

public interface IRepository<T> where T: class
{
    IQueryable<T> GetAll();
    T Add(T entity);
    T Update(T entity);
    void Delete(T entity);
    void Save()
}

Y un repositorio genérico EF:

public class EF4Repository<T> : IRepository<T> where T: class
{
    public DbContext Context { get; private set; }
    private DbSet<T> _dbSet;

    public EF4Repository(string connectionString)
    {
        Context = new DbContext(connectionString);
        _dbSet = Context.Set<T>();
    }

    public EF4Repository(DbContext context)
    {
        Context = context;
        _dbSet = Context.Set<T>();
    }

    public IQueryable<T> GetAll()
    {
        // code
    }

    public T Insert(T entity)
    {
        // code
    }

    public T Update(T entity)
    {
        Context.Entry(entity).State = System.Data.EntityState.Modified;
        Context.SaveChanges();
    }

    public void Delete(T entity)
    {
        // code
    }

    public void Save()
    {
        // code
    }
}

Ahora supongamos que solo quiero mapear un Group existente a un Person existente. Tendría que hacer algo como lo siguiente:

        EFRepository<Group> groupRepository = new EFRepository<Group>("name=connString");
        EFRepository<Person> personRepository = new EFRepository<Person>("name=connString");

        var group = groupRepository.GetAll().Where(g => g.GroupId == 5).First();
        var person = personRepository.GetAll().Where(p => p.PersonId == 2).First();

        group.People.Add(person);
        groupRepository.Update(group);

Pero esto no funciona porque EF piensa que Person es nuevo, e intentará re-INSERT el Person en la base de datos, lo que causará un error de restricción de clave primaria. Debo usar DbSet ' s Attach método para decirle a EF que el Person ya existe en el base de datos así que simplemente cree un mapa entre Group y Person en la tabla GroupPersonMap.

Así que para adjuntar Person al contexto ahora debo agregar un método Attach a mi IRepository:

public interface IRepository<T> where T: class
{
    // existing methods
    T Attach(T entity);
}

Para corregir el error de restricción de clave primaria:

EFRepository<Group> groupRepository = new EFRepository<Group>("name=connString");
EFRepository<Person> personRepository = new EFRepository<Person>(groupRepository.Context);

var group = groupRepository.GetAll().Where(g => g.GroupId == 5).First();
var person = personRepository.GetAll().Where(p => p.PersonId == 2).First();

personRepository.Attach(person);
group.People.Add(person);
groupRepository.Update(group);

Arreglado. Ahora tengo que lidiar con otro problema donde Group se actualiza en la base de datos cada vez que creo un mapa de Grupo/Persona. Esto se debe a que en mi método EFRepository.Update(), el estado de la entidad se establece explícitamente en Modified'. I must set the Group's state to Sin cambiosso theGrupo` la tabla no se modifica.

Para arreglar esto debo agregar algún tipo de Update sobrecarga a mi IRepository que no actualiza la entidad raíz, o Group, en este caso:

public interface IRepository<T> where T: class
{
    // existing methods
    T Update(T entity, bool updateRootEntity);
}

La implementación EF4 del método Update se vería algo como esto:

T Update(T entity, bool updateRootEntity)
{
   if (updateRootEntity)
      Context.Entry(entity).State = System.Data.EntityState.Modified;
   else
      Context.Entry(entity).State = System.Data.EntityState.Unchanged;

    Context.SaveChanges();
}

Mi pregunta es: ¿Estoy abordando esto de la manera correcta? Mi repositorio está empezando a verse centrado en EF a medida que empiezo a trabajar con EF y el patrón de repositorio. Gracias por leer este largo post