Architecture N-tier avec tables très dépendantes
Bonjour,
Je suis dans un cas de figure ou j'ai des tables très liées entre elles: par exemple j'ai une table Série(id,Nom) , une table Lieu(id,Nom) et une table Organe(id,nom,...).
Or dans ma modélisation, un Organe peut être sur plusieurs séries et un organe est sur un Lieu, les Lieux dépendent de la série. (j'explique qu'une partie de ma base)
Donc Serie->Lieu->Organe j'ai donc une table SERIE_LIEU_ORGANE(idSerie<pk,fk1>,idLieu<pk,fk2>,idOrgane<pk,fk3>)
Le but de mon projet est d’interroger la base et d'avoir des Datagridview pour faire du CRUD sur les tables de ma base et ensuite faire du CRUD sur les Organes qui sont les éléments les plus complexes à manipuler.
Je débute avec cette architecture et je voudrais savoir si je m'y prends bien:
Voici ma DALOrgane:
Code:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84
| namespace DAL
{
public class OrganeProvider
{
public List<OrganeEntity> LoadData()
{
List<OrganeEntity> list = new List<OrganeEntity>();
using (OleDbConnection cn = new OleDbConnection())
{
string DatabaseName = "Base_Rexx1.accdb";
string pathBase = System.IO.Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.Desktop), @"SNCF\Projet REXX");
string DatabaseNameL = System.IO.Path.Combine(pathBase, DatabaseName);
cn.ConnectionString = cn.ConnectionString = string.Format("Provider=Microsoft.ACE.OLEDB.12.0;Data Source={0};", DatabaseNameL);
cn.Open();
using (OleDbCommand cmd = new OleDbCommand())
{
cmd.CommandText =
" SELECT table_organe.[id] AS idOrgane,table_serie.[Serie] AS serie,table_serie.[id] AS idSerie,table_lieux.[Lieux] As lieu,table_lieux.[id] AS idLieu,table_famille.Famille As famille,table_famille.[ID] AS idFamille,table_organe.[Libelle]," +
" table_organe.[Description], table_Piece.Symbole AS Symbole,table_piece.Nom As piece,table_piece.idPiece AS idPiece" +
" FROM (((((rle_serie_lieu_organe " +
" INNER JOIN [table_organe] ON [rle_serie_lieu_organe].[idOrgane] = [table_organe].[id])" +
" INNER JOIN [table_serie] ON [rle_serie_lieu_organe].[idserie] = [table_serie].[id])" +
" INNER JOIN [table_lieux] ON [rle_serie_lieu_organe].[idLieux] = [table_lieux].[id])" +
" INNER JOIN [table_famille] ON [table_organe].[Famille] = [table_famille].[id])" +
" LEFT JOIN [rle_affectation_organe_piece] ON [rle_serie_lieu_organe].[idSerie] = [rle_affectation_organe_piece].[idSerie]" +
" AND [rle_serie_lieu_organe].[idOrgane] = [rle_affectation_organe_piece].[idOrgane]" +
" AND [rle_serie_lieu_organe].[idLieux] = [rle_affectation_organe_piece].[idLieux])" +
" LEFT JOIN [table_piece] ON [rle_affectation_organe_piece].[idPiece] = [table_piece].[idPiece]";
cmd.Connection = cn; ;
using (OleDbDataReader rdr = cmd.ExecuteReader())
{
while (rdr.Read())
{
OrganeEntity o = new OrganeEntity();
FamilleEntity f = new FamilleEntity();
SerieEntity s = new SerieEntity();
LieuEntity l = new LieuEntity();
f.idFamille = (int)rdr["idFamille"];
f.nom = rdr["famille"] == DBNull.Value ? string.Empty : rdr["famille"].ToString();
s.idSerie = (int)rdr["idSerie"];
s.Nom = rdr["serie"].ToString();
l.idLieu = (int)rdr["idLieu"];
l.Nom = rdr["lieu"].ToString();
if (rdr["idOrgane"] != DBNull.Value)
{
o.idOrgane = (int)rdr["idOrgane"];
}
o.libelle = rdr["Libelle"] == DBNull.Value ? string.Empty : rdr["Libelle"].ToString();
o.description = rdr["Description"] == DBNull.Value ? string.Empty : rdr["Description"].ToString();
o.famille = f;
if(rdr["idPiece"] != DBNull.Value)
{
PieceEntity P = new PieceEntity();
P.idPiece = (int)rdr["idPiece"];
P.nom = rdr["piece"].ToString();
if(rdr["Symbole"]!= DBNull.Value)
{
P.symbole = (int)rdr["Symbole"];
}
o.piece = P;
}
o.famille = f;
o.serie = s;
o.lieu = l;
list.Add(o);
}
}
}
}
return list;
}
}
} |
Comme vous le voyez j'utilise une requête assez lourdes pour avoir mes Organes:
Ma couche DTO :
Code:
1 2 3 4 5 6 7 8 9 10 11 12 13 14
| namespace DTO
{
public class OrganeEntity
{
public int idOrgane { get; set; }
public string libelle { get; set; }
public string description { get; set; }
public int idFamille { get; set; }
public PieceEntity piece { get; set; }
public FamilleEntity famille { get; set; }
public SerieEntity serie { get; set; }
public LieuEntity lieu { get; set; }
}
} |
Ma couche BLL:
Code:
1 2 3 4 5 6 7 8 9 10 11
| namespace BLL
{
public static class OrganeManager
{
public static List<OrganeEntity> LoadData()
{
return new OrganeProvider().LoadData();
}
}
} |
Ce que j'ai du mal à réaliser, c'est que ma base à des règles de gestion qui font que je ne peux pas avoir de doublon dans la table SERIE_LIEU_ORGANE, or dans mon programme si je veux insérer un nouvelle Organe qui est sur une Serie et un Lieu je ne sais pas comment inclure ces vérifications dans le code, est ce ma couche BLL qui gère ça via des appelles de méthodes à ma couches DAL qui renverraient un boléen par exemple ?
De tout ce que j'ai pu lire, la couche DTO contient des objets qui sont juste là pour faire transiter des données, donc on ne peut pas vraiment remodéliser notre base en objet si je comprend bien et même si on peut, cela serait fastidieux et surement bancale ?
Voila je vous remercie d'avance !
Bonne fin de journée.
Je ne sais pas si j'ai été très clair...