1 pièce(s) jointe(s)
Demande de conseil sur la conception POO d'un projet c#
Bonjour,
J'ai besoin de conseils pour vérifier que nous avons fait les bons choix de POO.
Contexte :
J'ai 10 ans d'expérience en vb5-vb6 et j'ai écrit un programme en c# en "pair programming" avec un collègue qui a 10 ans d'expérience en VBA.
Nous voulions apprendre un langage POO. Nous avons appris le java puis le C++ et finalement nous avons choisi le c#.
Nous utilisons les conventions de codage d'Aviva : https://csharpguidelines.codeplex.com/
Nous n'avions pas d'expérience en POO avant ce projet.
Nous avons déjà programmé plusieurs heures et avant d'aller plus loin, nous souhaiterions vérifier que notre projet est bien conçu.
Objet du projet :
Le projet simule une expérience de physique ou n(t)= f(criticality(t))
- l'utilisateur défini graphiquement une courbe de criticality en fonction du temps
- le programme calcule la valeur n(t) et affiche le résultat
Contraintes de l'UI
la courbe de criticality(t) est une succession de fonctions linéaires (donc de segment). L'utilisateur peut déplacer les extrémités, ajouter ou supprimer des segments. Pour cela, nous utilisons une collection de segments (dt, dcriticality) qui sont tracés dans un panel.
Classes
- une classe Experiment héritée de form : une feuille (ou un formulaire) représente une expérience (une succession de variations de criticality(t), son calcul, son résultat)
- une classe Reactor, membre de Experiment, qui calcule n=f(criticality)
- une classe CriticalityPanel1 héritée de Panel.
- une classe CriticalityVariation (dt, dcriticality) et sa collection CriticalityVariations qui est un membre de Experiment
- une classe criticalityVariationPoint (dt, dcriticality, dx, dy) et sa collection qui est un membre de CriticalityPanel
Fonctionnement :
Experiment crée une instance de CriticalityVariations
puis une instance de CriticalityPanel qui fabrique CriticalityVariationPoints
Code:
1
2
3
4
5
6
7
8
|
private void Experiment_Load(object sender, EventArgs e)
{
reactor = new Reactor(criticalityVariations, precursors);
criticalityPanel1.LoadCriticality(criticalityVariations);
criticalityPanel1.OnCriticalityChange += criticalityPanel1_OnCriticalityChange;
Display();
} |
Quand l'utilisateur modifie le graphique criticality(t) dans criticalityPanel1, ce dernier envoie un évènement à Experiment avec la nouvelle collection CriticalityVariations :
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
protected override void OnMouseUp(MouseEventArgs e)
{
base.OnMouseUp(e);
if (draging)
{
draging = false;
criticalityVariationsPoints.updateVariations(selectedPoint);
this.Refresh();
CriticalityVariationsEventArgs cve =
new CriticalityVariationsEventArgs((CriticalityVariations)(criticalityVariationsPoints));
OnCriticalityChange(this, cve);
}
} |
Ainsi, Experiment peut recalculer n(t) et afficher le résultat :
Code:
1
2
3
4
5
6
7
8
9
|
void criticalityPanel1_OnCriticalityChange(object sender, CriticalityVariationsEventArgs e)
{
criticalityVariations = e.CriticalityVariationsUpdated;
reactor = new Reactor(criticalityVariations, precursors);
Display();
//throw new NotImplementedException();
} |
Le choix de faire de la collection CriticalityVariations un membre de la classe Experiment est-il bon ?
Le choix de demander à criticalityPanel1 d'envoyer la nouvelle collection modifiée par l'utilisateur à Experiment est-il le bon ?
Avons-nous fait quelque chose de simple, facilement compréhensible et maintenable ou avons-nous tout faux ?
Merci pour vos conseils ...
