¿Cómo usar el patrón de repositorio correctamente?

Una cosa que he comenzado a hacer para abordar esto es desarrollar servicios que envuelvan N repositorios. Esperemos que sus marcos de DI o IoC puedan ayudar a hacerlo más fácil.

public class ServiceImpl {
    public ServiceImpl(IRepo1 repo1, IRepo2 repo2...) { }
}

¿Tiene sentido? Además, entiendo que hablando de servicios en esta mansión puede o no cumplir con los principios DDD, solo lo hago porque parece funcionar.

Lo que estoy haciendo es que tengo una clase base abstracta definida de la siguiente manera:

public abstract class ReadOnlyRepository<T,V>
{
     V Find(T lookupKey);
}

public abstract class InsertRepository<T>
{
     void Add(T entityToSave);
}

public abstract class UpdateRepository<T,V>
{
     V Update(T entityToUpdate);
}

public abstract class DeleteRepository<T>
{
     void Delete(T entityToDelete);
}

Luego puede derivar su repositorio de la clase base abstracta y extender su repositorio único mientras los argumentos genéricos difieran, por ejemplo;

public class RegistrationRepository: ReadOnlyRepository<int, IRegistrationItem>,
                                     ReadOnlyRepository<string, IRegistrationItem> 

Etc....

Necesito los repositorios separados porque tenemos restricciones en algunos de nuestros repositorios y esto nos da la máxima flexibilidad. Espero que esto ayude.

Tengo esto como mi clase de repositorio y sí me extiendo en el repositorio de tabla / área, pero aún así a veces tengo que romper SECO.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace MvcRepository
{
    public class Repository<T> : IRepository<T> where T : class
    {
        protected System.Data.Linq.DataContext _dataContextFactory;

        public IQueryable<T> All()
        {
            return GetTable.AsQueryable();
        }

        public IQueryable<T> FindAll(Func<T, bool> exp)
        {
            return GetTable.Where<T>(exp).AsQueryable();
        }

        public T Single(Func<T, bool> exp)
        {
            return GetTable.Single(exp);
        }

        public virtual void MarkForDeletion(T entity)
        {
            _dataContextFactory.GetTable<T>().DeleteOnSubmit(entity);
        }

        public virtual T CreateInstance()
        {
            T entity = Activator.CreateInstance<T>();
            GetTable.InsertOnSubmit(entity);
            return entity;
        }

        public void SaveAll()
        {
            _dataContextFactory.SubmitChanges();
        }

        public Repository(System.Data.Linq.DataContext dataContextFactory)
        {
            _dataContextFactory = dataContextFactory;
        }

        public System.Data.Linq.Table<T> GetTable
        {
            get { return _dataContextFactory.GetTable<T>(); }
        }

    }
}

EDITAR

public class AdminRepository<T> : Repository<T> where T: class
{
    static AdminDataContext dc = new AdminDataContext(System.Configuration.ConfigurationManager.ConnectionStrings["MY_ConnectionString"].ConnectionString);

    public AdminRepository()
        : base( dc )
    {
    }

También tengo un datacontext que fue creado usando Linq2Sql.clase dbml.

Así que ahora tengo un repositorio estándar implementando llamadas estándar como All y Find y en mi AdminRepository tengo llamadas específicas.

No responde a la pregunta de SECO aunque no creo.

Aquí hay un ejemplo de una implementación de repositorio genérica usando FluentNHibernate. Es capaz de persistir en cualquier clase para la que haya escrito un mapeador. Incluso es capaz de generar su base de datos basada en las clases mapper.

El patrón del repositorio es un patrón de diseño incorrecto. Trabajo con muchos proyectos. Net antiguos y este patrón generalmente causa errores de" Transacciones distribuidas"," Reversión Parcial "y" Grupo de conexiones agotado " que podrían evitarse. El problema es que el patrón intenta manejar conexiones y transacciones internamente, pero éstas deben ser manejadas en la capa de Controlador. También EntityFramework ya abstrae mucha de la lógica. Yo sugeriría usar el patrón de servicio en lugar de reutilizar código compartido.

Le sugiero que mire Sharp Architecture. Sugieren usar un repositorio por entidad. Lo estoy usando actualmente en mi proyecto y wery satisfecho con los resultados.