Modèle de référentiel et de mappeur de données

Après avoir beaucoup lu sur le référentiel et le Data Mapper, j'ai décidé d'implémenter ces modèles dans un projet de test. Puisque je suis nouveau à ceux-ci, j'aimerais avoir votre point de vue sur la façon dont j'ai implémenté ceux-ci dans un projet simple.

Jeremy Miller dit:

Faites une sorte de projet de codage personnel non trivial où vous pouvez expérimenter librement avec des modèles de conception.

Mais je ne sais pas que j'ai fait toutes ces choses correctement ou pas.

Voici la structure de mon projet :

Comme vous pouvez le voir, il y a beaucoup de dossiers que je vais décrire en détail ci-dessous.

• Domaine: Les entités du domaine du projet vont ici j'ai une classe de Personnel simple qui est héritée de la classe EntityBase, la classe EntityBase a une seule propriété nommée Id.

  public int Id { get; set; }
  

• Infrustructure: Voici une couche D'accès aux données simple avec deux classes. SqlDataLayer est une classe simple héritée d'une classe abstraite nommée DataLayer. Ici, je fournis des fonctionnalités comme le code suivant:

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

Ajout d'un paramètre à la collection de paramètres de commandes:

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

        _command.Parameters.Add(parameter);
    }

Exécution De DataReader:

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

        return _command.ExecuteReader();
    }

Et ainsi de suite.

• Repository: ici, j'ai essayé d'implémenter le modèle de référentiel. IRepository est une interface générique

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);
}

Référentiel.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;
    }

Je n'ai pas exposé les méthodes non implémentées de IRepository.

Ici, dans la classe de référentiel Générique, j'attends deux paramètres dans le constructeur, d'abord une référence à ma classe SqlDataLayer et deuxièmement une référence à Entity DataMapper. Ces paramètres envoyés par chaque classe de référentiel D'entités héritées de la classe de référentiel. par exemple :

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

    }
}

Comme vous pouvez le voir ici dans la méthode FindOne, j'ai essayé d'automatiser certaines opérations telles que la création de CommandText, puis j'ai profité de ma classe DataLayer pour configurer la commande et enfin exécuter la commande pour obtenir IDataReader. Je passe IDataReader à ma classe DataMapper pour mapper à L'entité.

• DomainMapper: enfin ici, je mappe le résultat D'IDataReader aux entités, ci-dessous est un exemple de la façon dont je mappe L'entité du Personnel:

  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"])
      };
  }}
  

Utilisation :

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

Je sais que j'ai fait beaucoup d'erreurs ici, c'est pourquoi je suis ici. J'ai besoin de vos conseils pour savoir ce que j'ai mal fait ou quels sont les bons points dans ce projet de test simple.

Merci préalablement.