Utilisation d'images dans Delphi pour plus d'informations GUI cacher

Question

J'ai appris Delphi pour les 3 dernières années, sur un passe-temps / niveau professionnel. Je suis heureux de dire que je l'ai maintenant progressé au point que je peux regarder en arrière sur mon code de bonne heure avec horreur et d'embarras. Je vais donc maintenant à travers certaines de mes premières applications et réécriture / les refactoring.

L'une des mauvaises habitudes que je suis en train de sortir de l'accès aux composants est sur une forme d'une autre unité. Dans un effort pour appliquer, je l'ai expérimenté avec l'aide de cadres comme méthode de dissimulation de l'information. Ainsi, au lieu d'avoir une forme avec des composants sur, je suis en train de créer un cadre pour contenir tous les éléments de formulaire, puis en plaçant le cadre sur une forme, le déplacement de la déclaration de cadre dans les déclarations privées,

type
  TMyForm = class(TForm)
   private
    MyFrame: TMyFrame;
    procedure SetTimeDate(const Value: TMyItem);
    function ReadTimeDate:TMyItem ;

puis l'enregistrement de la trame dans la section d'initialisation de la forme

initialization 
begin
RegisterClasses([TMyFrame])

Je suis alors les propriétés que je déclarais besoin dans la partie publique de l'unité de forme, qui a accès au châssis et ses composants.

  public
    property TimeDate: TOverlayItem  read ReadTimeDate  write SetTimeDate;

Je suis également utilise des cadres pour consolider les groupes de composants souvent répétés.

Cela semble fonctionner pour les besoins que je veux (cacher MyFrame et ses composants), mais que quelqu'un d'autre ont une expérience de cette méthode?

Y a-t-il des inconvénients à utiliser des cadres? Est-ce que je gagnais en fait un avantage de faire cela? Y a-t-il des problèmes avec l'utilisation des cadres imbriqués dans des cadres? Y a-t-il des guides de bonnes pratiques à l'aide de cadres en Delphi? Y at-il des moyens plus faciles de mieux / obtenir le même effet en ce qui concerne l'interface graphique cacher des informations dans Delphi?

HMCG

Answer 1

On dirait que vous avez encore beaucoup de logique dans votre couche d'interface utilisateur. Formulaires / panneaux ne doivent pas avoir des propriétés que beaucoup de valeur (sauf peut-être pour Dialogs).

Si vous voulez plus de structure que lire sur le modèle MVC.

Ceci étant dit, les cadres peuvent être un bon moyen d'organiser l'interface graphique. Comme avec tout, ne pas abuser.

Answer 2

Je veux cadre généralement pour créer des bits réutilisables complexes. Pour la plupart, je pense qu'ils peuvent être un moyen très propre pour construire des écrans. Cependant, comme mentionné par Henk Holterman vos écrans et les cadres ne doit contenir que la logique ayant trait au fonctionnement de l'interface utilisateur et être aussi ignorant que possible sur la logique métier.

Un couple de points re cadres et des informations qui se cachent dans l'interface utilisateur:

1. Comme on l'a dans une autre question sur StackOverflow vous devez être prudent lorsque vous utilisez des gestionnaires d'événements en votre cadre.
2. Les cadres ont encore beaucoup de propriétés publiées et ne résolvent pas vraiment la question des formes pouvant jouer du violon avec une façon inappropriée les bits de l'autre. Même si vous ne le faites pas, si le code le permet quelqu'un finira par écrire du code qui falsifie où il ne devrait pas. Je retire toujours la forme variable globale Delphi souille le code avec et écrire souvent des objets wrapper ou implémentent des interfaces qui fournissent un accès contrôlé à l'interface utilisateur.

Ainsi, au lieu d'avoir le code comme ceci:

ClientForm := TClientViewForm.Create(Self);
try
  ClientForm.Client := MyClient;
  ClientForm.ShowModal;
finally
  ClientForm.Free;
end;

Je force généralement les gens à écrire quelque chose du genre:

ClientViewer := TClientViewer.Create(MyClient);
try
  ClientViewer.Show;
finally
  ClientViewer.Free;
end;

ou même

TClientViewer.ShowClient(MyClient);

et ont la méthode de classe ShowClient gérer le bit indiqué dans la première liste. De cette façon, le code appelant ne reçoit jamais le pointeur de la forme et ne peut pas toucher les bits qui ne sont pas fournis spécifiquement par la classe wrapper.