Patrón de Repositorio y Mapeador de datos

Después de leer mucho sobre el Repositorio y el Mapeador de datos, decidí implementar esos patrones en un proyecto de prueba. Ya que soy nuevo en estos, me gustaría obtener sus puntos de vista sobre cómo implementarlos en un proyecto simple.

Jeremy Miller dice:

Haga algún tipo de proyecto de codificación personal no trivial donde pueda experimentar libremente con patrones de diseño.

Pero no se que hice todas estas cosas bien o no.

Aquí está la estructura de mi proyecto :

Como puede ver, hay muchas carpetas que voy a describir en detalle a continuación.

• Domain : Project Domain Entities ir aquí Tengo una clase Personnel simple que se hereda de la clase EntityBase, la clase EntityBase tiene una sola propiedad llamada Id.

  public int Id { get; set; }
  

• Infrustructure : Aquí hay una capa de acceso a datos simple con dos clases. SqlDataLayer es una clase simple que se hereda de una clase abstracta llamada dataLayer. Aquí proporciono algunas funcionalidades como el siguiente código:

  public SQLDataLayer() {
      const string connString = "ConnectionString goes here";
      _connection = new SqlConnection(connString);
      _command = _connection.CreateCommand();
  }
  

Agregar parámetro a la colección de parámetros de comandos:

    public override void AddParameter(string key, string value) {
        var parameter = _command.CreateParameter();
        parameter.Value = value;
        parameter.ParameterName = key;

        _command.Parameters.Add(parameter);
    }

Ejecutando DataReader:

    public override IDataReader ExecuteReader() {
        if (_connection.State == ConnectionState.Closed)
            _connection.Open();

        return _command.ExecuteReader();
    }

Y así sucesivamente.

• Repositorio : Aquí intenté implementar el patrón de repositorio. IRepository es una interfaz genérica

IRepository.cs:

public interface IRepository<TEntity> where TEntity : EntityBase
{
    DataLayer Context { get; }

    TEntity FindOne(int id);
    ICollection<TEntity> FindAll();

    void Delete(TEntity entity);
    void Insert(TEntity entity);
    void Update(TEntity entity);
}

Repositorio.cs:

public class Repository<TEntity> : IRepository<TEntity> where TEntity : EntityBase, new() {
    private readonly DataLayer _domainContext;
    private readonly DataMapper<TEntity> _dataMapper;
    public Repository(DataLayer domainContext, DataMapper<TEntity> dataMapper) {
        _domainContext = domainContext;
        _dataMapper = dataMapper;
    }
    public DataLayer Context {
        get { return _domainContext; }
    }
    public TEntity FindOne(int id)
    {
        var commandText = AutoCommand.CommandTextBuilder<TEntity>(CommandType.StoredProcedure, MethodType.FindOne);

        // Initialize parameter and their types
        Context.AddParameter("Id", id.ToString(CultureInfo.InvariantCulture));
        Context.SetCommandType(CommandType.StoredProcedure);
        Context.SetCommandText(commandText);

        var dbReader = Context.ExecuteReader();
        return dbReader.Read() ? _dataMapper.Map(dbReader) : null;
    }

No expuse los métodos no implementados de IRepository.

Aquí en la clase Generic Repository espero que dos parámetros en constructor primero es una referencia a mi clase SqlDataLayer y segundo es una referencia a Entity DataMapper. Los parámetros enviados por cada clase de Repositorio de Entidades que heredó de la clase de repositorio. por ejemplo :

public class PersonnelRepository : Repository<Personnel>, IPersonnelRepository {
    public PersonnelRepository(DataLayer domainContext, PersonnelDataMapper dataMapper)
        : base(domainContext, dataMapper) {

    }
}

Como se puede ver aquí en el método findOne traté de automatizar algunas operaciones como la creación de CommandText, luego tomé la ventaja de mi clase dataLayer para configurar comando y finalmente ejecute el comando para obtener IDataReader. Paso IDataReader a mi clase DataMapper para asignar a la Entidad.

• DomainMapper: Finalmente aquí mapeo el resultado de IDataReader a Entidades, a continuación se muestra una muestra de cómo mapeo la entidad Personal :

  public class PersonnelDataMapper : DataMapper<Personnel> {
  public override Personnel Map(IDataRecord record) {
      return new Personnel {
          FirstName = record["FirstName"].ToString(),
          LastName = record["LastName"].ToString(),
          Address = record["Address"].ToString(),
          Id = Convert.ToInt32(record["Id"])
      };
  }}
  

Uso :

    using (var context = new SQLDataLayer()) {
        _personnelRepository = new PersonnelRepository(context, new PersonnelDataMapper());
            var personnel  = _personnelRepository.FindOne(1);
    }

Sé que cometí muchos errores aquí, por eso estoy aquí. Necesito tu consejo para saber qué hice mal o cuáles son los puntos buenos en este simple proyecto de prueba.

Gracias previamente.