Newsgroup: it.comp.lang.delphi
Titolo: Aggiungere Proprietà Runtime

Esiste qualche articolo o tutorial che spieghi bene come aggiungere le
proprietą ad una classe appena creata?
Quindi non intendo le proprietą gestite dall'Object Inspector, ma quelle che
si devono creare se uno vuole creare delle nuove classi .
Sul libro che ho (Delphi 4 Guida Completa) sono spiegate abbastanza bene
quelle della VCL, ma all'atto pratico non saprei come fare per una classe
creata "ex-novo".
Posso trattarle come delle variabili, da un punto di vista della loro
dichiarazione?
E come le implemento?
Mi fate qualche esempio, o mi indicate qualche URL (o libro) ?

proprietà ad una classe appena creata?
Ciao, scusa ma non ho capito bene che cosa intendi dire.
Comunque una volta definita una classe hai già definito tutte le sue
proprietà e non puoi piu' aggiungerne delle altre a runtime. L'unica
cosa che puoi fare è modificare la classe (a design time)
aggiungendone altre e poi ricompilando.
Ciao, Rocco
.

si devono creare se uno vuole creare delle nuove classi .
Se per proprieta' non intendi quelle gestite dall'OI,
suppongo tu ti stia riferendo ai membri di una classe.
In realta' la tua domanda non mi e' molto chiara.
Le classi sono tipi di dato e i tipi di dato devono essere
definiti se li si vuol utilizzare.
Questo significa che anche i membri facenti parte di una
classe devono essere definiti a priori.
Cioe', io non posso avere una classe senza membri e poi
aggiungere membri a run-time, e' illogico.
Invece, e' diverso seu ti stia riferendo ai componenti
visuali.  Per esempio, si puo' avere un form vuoto e poi
aggiungere componenti a run-time.
Spiegati meglio e forse puoi trovare un aiuto migliore. 
--
CyberWalkie - walkietalkie(at)
libero.it

 Spiegati meglio e forse puoi trovare un aiuto migliore.
In effetti era quello che temevo: mi sono spiegato male.
Provo a riformulare la domanda in altro modo.
So che le proprietà di un oggetto si possono modificare a "design-time"
(tramite l'object inspector) oppure a "runtime" (tramite il codice).
(è' logico che le devo comunque definire prima che il programma venga
compilato). Ecco, io mi riferivo proprio a quelle "run-time".
Cioè volevo sapere come SCRIVERE nel codice le proprietà di un oggetto
appartenente ad una classe da me creata.
FORSE, ora che ho dato un'occhiata al capitolo sulla crezione di componenti,
sul libro che ho io, ho trovato la risposta alla mia domanda (anche se mi
separano ancora altri 10 capitoli dalla meta...).
Cioè penso che imparare a scrivere le proprietà di un componente di Delphi,
insegni automaticamente a scrvere anche quelle di un oggetto qualsiasi. Se
non è così spiegatemi voi.
Posso approfittarne per un'altra domandina?
Ma la parola chiave THIS di Java è come la SELF di Delphi? Cioè, sono
entrambi puntatori (anche se in Java li chiama reference) all'oggetto in
questione, vero?
Ciao

questione, vero?
Si', il concetto e' lo stesso.
Anche Delphi lo chiama "reference".
Il modello a oggetti di Delphi presuppone che non esista, in
generale, allocazione statica degli oggetti (come in C++),
ma solo dinamica (e' il motivo per cui bisogna sempre
allocare con Create e deallocare con Free, prima di usare un
nuovo componente).  Ogni identificatore di oggetto, in
realta', e' un reference all'oggetto, ovvero un puntatore a
quell'oggetto.  Questa caratteristica ha influenzato, per
esempio, anche C++ Builder.
In C++ se vuoi allocare un oggetto, puoi farlo in modo
statico o in modo dinamico.  In C++ Builder, implementazione
Borland del C++, se l'oggetto e' istanza di una classe della
VCL, puoi farlo solo in modo dinamico e questo perche' la
VCL e' scritta in Delphi.
Spero di non averti causato troppa confusione...
--
CyberWalkie - walkietalkie(at)
libero.it

 Spero di non averti causato troppa confusione...
No, anzi! Sei stato molto chiaro e quello che hai appena detto
sull'allocazione dinamica non fa altro che consolidare l'idea che mi ero
fatto io della questione.
Ciao

Il capitolo in cui si parla di proprietà dei componenti è il 20°, mi sono
sbagliato!


Allora: una classe deve essere completamente definita a design time
cosi' che, quando compili, il compilatore riesce a generare il codice
per l'allocazione della memoria contenente le varie proprieta, metodi
ecc....
Per quanto riguarda il fatto che non tutte le proprietà sono visibili
nell' Object Insopector, il discorso è un'altro.
Nell' OI infatti si possono vedere sole le proprietà definite nella
sezione Published della classe. Per quelle definite come Public invece
(e forse ti riferisci proprio a questo) devi impostarne i valori via
codice (quindi a run-time, anche se cio' non è del tutto vero in
quanto potresti settarle anche, per esempio, nel Create e questo viene
chiamato anche a Design time....).
Ciao, Rocco.

> Comunque stai dicendo che le proprietà run-time only non si possono
fare? Mi sembrava di aver letto che esistono anche quelle. Mi viene da
chiedere se l'obbligatorietà della definizione designtime delle
proprietà si possa scavalcare rendendole a sola lettura. Cioè, faccio
una proprietà runtime-only e read-only nello stesso tempo (o non c'entra
un bel nulla?). <<
Una cosa per volta ed un po' di codice:
TRobaConAlias = class(TComponent)
private
  FID: integer;
  FNome: string;
  FAlias: string;
  procedure SetNome(const Value: string);
protected
public
  constructor Create(aOwner: TComponent); override;
  constructor CreateWithParams(aOwner: TComponent; anID: integer; aNome:
string);
  function ImpostaNuovaID(const NewID: integer): boolean;
  property Alias: string read FAlias write FAlias;
published
  property ID: integer read FID;
  property Nome: string read FNome write SetNome;
end;
Ha due costruttori: quello std viene usato da Delphi per crearlo a
design-time quando lo metti sulla form; il secondo puo' essere usato a
runtime per creare ed impostare direttamente i campi fID e fNome.
Ha 3 proprieta': quelle published si vedono nell'OI
Alias e' accessibile solo a runtime.
ID e' read-only perche' manca lo specificatore write nella sua
definizione (se derivasse da TComponent e tentassi di scrivere nell'OI
ti tornerebbe un errore o il valore tornerebbe quello precedente, non
ricordo). Puoi modificarlo a runtime con ImpostaNuovaID.
Nome e' una proprieta' _normale_, fatto salvo che potresti, in SetNome,
assegnare a FNome Uppercase(Value) invece di Value.
L'oggetto del thread, cmq, 'Aggiungere prprieta' a runtime' mi pare
quantomeno arduo.
Una proprieta' puo' essere vista come servizio reso disponibile per
altri oggetti: se la lista dei servizi cambia, non e' semplice
notificare che e' cambiata e come.
Saluti
Paolo Arosio

 chiamato anche a Design time....).
Ah, ecco! Ora comincio a capire.
Ciao

 quantomeno arduo.
Sì, capisco cosa vuoi dire. Cmq era ovvio che non avevo per niente le idee
chiare.
Grazie Paolo e grazie anche a Rocco e a CyberWalkie (e magari a chi vorrà
aggiungere un proprio parere)
Ciao