Newsgroup: it.comp.lang.delphi
Titolo: Esistono le "/COPY" in Delphi?

 
          In Delphi esiste qualcosa che funzioni come le "/COPY" utilizzate nei
linguaggi di programmazione tipo RPG o altri linguaggi dell'AS400?
Grazie, Mario
--------------------------------
Inviato via 
http://arianna.libero.it/usenet/

 dell'AS400?
Che cosa fanno le "/COPY"?
-- 
I am what I am, I do what I can
Do. Or do not. There is not try.


Faccio un esempio stupido per capirne la logica, anche se a me servirebbe
per un qualcosa di piů complesso:
Supponiamo di dover gestire in 3 programmi diversi la lettura del file PIPPO
che contiene le anagrafiche cliente.
Il primo programma deve emettere a video il Nome e il cognome del cliente
facenti parte di una certa casistica
Il secondo programma deve emettere a video i codici fiscali facenti parte di
una certa casistica
Il terzo programma deve emettere a video gli indirizzi facenti parte di una
certa casistica
con la gestione delle copy creo 2 sorgenti di copy che contengono le
seguenti specifiche:
************************* Inizio primo sorgente copy ********************
      AssignFile(f,NomeFile);
      FileMode:=0;
      Reset(f);
        Trovato:=False;
        while (not eof(f)) and (not Trovato) do begin
          ReadLn(f,St);
          if (St<>'') then begin
              St:=LowerCase(St);
************************* Fine primo sorgente copy ********************
************************* Inizio secondo sorgente copy ********************
          end;
        end;
      CloseFile(f);
************************* Fine secondo sorgente copy ********************
A questo punto i 3 programmi sarebbero fatti cosě:
- Richiamo alla 1^ copy
- Istruzioni filtro
- Richiamo alla seconda copy
in fase di compilazione, il compilatore ingloba nel sorgente i 2 sorgenti
delle copy creando cosě il sorgente reale da compilare


Delphi non è cobol o rpg...
Delphi è un rad object oriented.
questa in delphi lo fai con le classi.
hai una classe genitrice che espone un metodo virtuale che è quello
che nelle classi discendenti cambia e corrisponde alle tue istruzioni
di filtro.
La domanda "nel linguaggio x faccio 'sta cosa in delphi come la faccio"
è un pessimo modo di iniziare ad usare un linguaggio in quanto tenti
di usare il nuovo allo stesso modo del vecchio, cosa che, qualora fosse
possibile, è quasi sicuramente errata.
AS

MBulu ha scritto:
[cut]
Come consigliato da Alberto, trattandosi di un linguaggio OOP, prima di 
usare uno strumento tipo /COPY, conviene fermarsi un attimo a riflettere 
  e capire come stutturare la gerarchia di classi.
Se proprio non puoi farne a meno, puoi utilizzare la direttiva
{$I nome_file}
che ti permette di "copiare" codice pascal esattamente nel punto dove 
fai l'inclusione. Questo prima della compilazione, quindi attenzione 
alla dichiarazione di varibili, all'inizio ed alla fine dei blocchi ecc.
Io ne faccio uso in soli due casi:
1. dove la richiesta di prestazioni non mi permette di usare classi e 
chiamate a metodi: dal mio punto di vista un file inc alla fine potrebbe 
essere considerata una forma di procedura o funzione "primitiva";
2. dove devo inserire delle istruzioni di debug che mi "distraggono" 
dall'algoritmo.
In tutte le situazioni piu ad "alto livello", è abbastanza sconsigliato
Ciao,
Gianluca.

 per un qualcosa di più complesso:
Perché non dici direttamente *COSA* devi fare, così ti
possiamo suggerire come farla?
Ciao,
Andrea


 
Devo fare in più programmi la lettura di 2 file, ma in ogni programma devo
emettere dei dati differenti, volevo solo evitare di riscrivere le
istruzioni della lettura tutte le volte.
Alla fine mi andava bene la risposta di "Gianluca Plevani", anche se sono
ancora indeciso tra usare quella tecnica o fare una procedura a cui passo un
parametro in più e, in base a questo parametro scelgo quali dati emettere


prima di tutto usare procedure in un contesto OO non è elegante: si
usano le classi, ribadisco.
Inoltre, avere  una procedura il cui funzionamento cambia drasticamente
in base ad un parametro è concettualmente errato.
AS

MBulu ha scritto:
 > Devo fare in più programmi la lettura di 2 file, ma in ogni programma 
devo
 > emettere dei dati differenti, volevo solo evitare di riscrivere le
 > istruzioni della lettura tutte le volte.
 > Alla fine mi andava bene la risposta di "Gianluca Plevani", anche se sono
 > ancora indeciso tra usare quella tecnica o fare una procedura a cui 
passo un
 > parametro in più e, in base a questo parametro scelgo quali dati emettere
Ho citato $I solo per conoscenza e perchè, obiettivamente esistono delle 
situazioni dove questa viene utile. Questo, a mio avviso, non è il caso. 
  Ho giust'appunto quei due minuti di esperienza di programmazione in 
Cobol ed il comando COPY l'ho sempre visto ottimo per poter importare le 
dichiarazioni dei file, delle maschere ecc.. Non ho praticamente mai 
visto nessuno importarsi pezzi di codice, preferendo sempre la chiamata 
a sottoprogrammi.
Vedile come procedure, vedile come classi, concettualmente tu hai 
bisogno di una funzionalità generalizzata che estragga i dati e di n 
funzioni per la rappresentazione. In ogni programma assemblare lo strato 
di data retrieving con quello più opportuno di emissione.
Ciao,
Gianluca.


 
Hai perfettamente ragione, ma purtroppo, dopo anni di RPG e Cobol cambiare
mentalità è un po' faticoso :-(((
Spero, col tempo, di abituarmi a ragionare per OO
