Newsgroup: it.comp.lang.delphi
Titolo: Consiglio per programmatore alle prime armi

Per un programma che sto realizzando, devo gestire una serie di dati, su cui
è possibile fare operazioni, eseguire metodi, ecc.
L'ho definito, poichè era composto da campi ben specifici e le azioni erano
perfettamente delineate, come un'oggetto:
type TMioOggetto= class(TObject)
          Campo1:string
          Campo2: integer;
          Campo3: array of TUnMioRecord
          .......
          CampoN: variant;
          function   QuantiArrayHa: integer;
          procedure InserisciRecord(UnValore:TUnMiORecord);
          ........
     Private
     Public
     Published
     end;
I campi di questo oggetto devon poter essere visualizzati, inseriti e/o
modificati  tramite una form (es: TFormOggetto), che funge da editor.
Ora il mio dubbio è questo: in quale rapporto conviene che siano TMioOggetto
e TFormOggetto ?
Conviene creare una serie di procedure public che creino un'istanza di uno e
dell'altro
 o conviene che siano subordinati uno alla creazione dell'altro ? (tenendo
però conto che il tutto deve funzionare in modalità MDI ) facendo diventare,
per esempio TMioOggetto un campo di TFormOggetto o viceversa ?
Ringrazio tutti per la pazienza e per i consigli che mi vorrete dare
Saluti a tutti
Andrea

 e TFormOggetto ?
Dipende molto da come vuoi/devi impostare la form di editing...
Hai detto che il tutto è in un contesto MDI:
A) se ogni form MDI è l'editor di un oggetto allora io propenderei per
questo tipo di soluzione: non legare in alcun modo Form e oggetto. Metti
tutto il codice che manipola i dati nell'oggetto (che farei derivare da
Tcomponent per poterlo avere sulla palette ed usarlo a design) e dota
l'oggetto stesso di appositi eventi per interagire con l'interfaccia.
(OnDataChange, OnNuoviDati  ecc ecc...) nei gestori di evento ti
preoccuperai di aggiornare l'interfaccia e ovviamente dovrai dotare
l'oggetto di appositi metodi / proprietà (con metodi di accesso almeno sulla
"write") tramite cui modificare i dati/inserire i dati ecc ecc...
Pro
- ampia libertà di modificare tanto la form quanto l'oggetto in modo
separato (niente vincoli evidentemente);
- maggiore riutilizzabilità dell'oggetto in altri contesti (anche in altri
progetti)
- meno problemi in caso tu abbia situazioni in cui per esempio la form
dovrebbe essere diversa: puoi creare n form diverse in cui modifichi solo i
gestori di evento.
Contro
- hai del codice esterno all' oggetto...
- devi scrivere questo codice (i gestori di evento) ogni volta [NB: ovvio
che se si tratta di MDIChild lo fai una volta sola...]
Nota: a questo punto direi che sarebbe bene che l'oggetto fosse owned dalla
form.
B) se invece hai questi oggetti e "ogni tanto" devi modificare i dati,
inserirei la form di editing direttamente nell'oggetto e richiamerei un
ipotetico metodo "EditData" che visualizzi la form (magari modale). In
questo modo l'oggetto è molto "chiuso" nel senso che hai poche possibilità
di modificare l'interfaccia (la form) senza "toccare" l'oggetto... in favore
hai una maggiore compattezza (nel senso che il codice è tutto unito e l'uso
dell'oggetto "dall'esterno" è di molto semplificato...)
Pro
- piazzi l'oggetto (deriva da TComponent!) da qualche parte e funziona
(niente codice esterno)
- fai una modifica sull'oggetto e _tutti_ i tuoi progetti risentiranno di
quella modifica (occhio perchè questo può essere considerato anche un
contro)
- il codice è molto centralizzato (anche questo può essere un contro in
certi casi)
Contro
- potresti trovarti con le mani legate se tu ti dovessi trovare in una
situazione in cui vuoi gestire in modo diverso l'editing (soluzione: o ti
inventi un sistema di opzioni oppure semplicemente implementi una piccola
gerarchia di oggetti: un TOggettoConDati che abbia un metodo astratto
virtuale "VisualizzaMascheraEditing" e un oggetto
TOggettoConDatiCheVengonoVisualizzati1 che faccia l'override di quel metodo
e che contenga la form necessaria... [NB: i nomi che ho usato sono
fortemente sconsigliabili])
Nota: stavolta io metterei la form owned dall'oggetto.
- una soluzione alternativa potrebbe essere quella di sfruttare l'Object
Repository (selezionando la form di editing [che dovrai preparare a parte])
, la form avrebbe un riferimento pubblico ad un oggetto di tipo
TTuoOggettoCoiDati e agganciargli i dati a run-time...
Pro
- mantieni separati logica di funzionamento ed interfaccia in modo
abbastanza intelligente
- grazie ai tre modi di includere una form dal Object Repository (Use, Copy,
Inherit) hai ampi margini di scelta su come gestire la situazione per poter
scrivere il minor codice possibile con il massimo dei risultati (questo a
fronte di una impostazione adeguata della prima form)
- lasceresti invariato l'oggetto in un maggior numero di situazioni
Contro
- il codice (a fronte di una maggior flessibilità di impiego) è più
sparpagliato nei vari progetti.
Insomma, come vedi hai più possibilità... La scelta dipende da molti fattori
(quanti progetti dovrai impostare su questi oggetti, quante volte avrai
bisogno della form rispetto alle istanze dell'oggetto ecc ecc).
Sta di fatto che la scelta di queste interdipendenze è sempre una parte
delicata dello sviluppo del programma: bisogna stabilire bene le esigenze
(quelle attuali e le possibili future)...
Scusate la lunghezza,
Ciao :-)
--
Andrea Magni
E-Mail: 
ama...@energy.it
SMS: 
ama...@wappi.com
PS per tutti: cerchiamo di usare dei subject più significativi (es. per
questo thread "Che legame fra interfaccia e parte dati?" penso sarebbe stato
meno enigmatico...)


C'entra poco con le tue domende, alle quali ha già risposto Andrea,  però
stai attento che nella tua classe tutte le variabili e le procedure che hai
dichiarato sono PUBBLICHE anche se non sono nella sezione public: per Pascal
tutto quello che sta tra il Type e le dichiarazioni private etc. è come se
fossero nella sezione public.
Probabilmente a tua classe dovrebbe essere così:
type TMioOggetto= class(TObject)
     Private
          Campo1:string
          Campo2: integer;
          Campo3: array of TUnMioRecord
          .......
          CampoN: variant;
     Public
          function   QuantiArrayHa: integer;
          procedure InserisciRecord(UnValore:TUnMiORecord);
          ........
     Published
     end;
Ciao
Ruggero


Effettivamente la mia classe č proprio come suggerisci (e come Pascal
vuole...)
Nella fretta di scrivere il MSG ho incollato le dichiarazioni nel
punto sbagliato!
Grazie a tutti dei preziosi consigli e suggerimenti 
Andrea