Le proprietà sono simili ai campi di un oggetto. La differenza tra i campi e le
proprietà sta nel fatto che i primi fanno riferimento a delle locazioni di memoria mentre
le seconde possono definire delle azioni per l'accesso in lettura e scrittura del loro
contenuto. La sintassi di dichiarazione di una proprietà è il seguente
Property NomeProprieta[Indici]:
Tipo index CostanteIntera
Specificatori;
NomeProprieta è, neanche a dirlo, un identificatore riconosciuto valido che
identifica la proprietà.
Indici è facoltativo ed è utilizzato nella dichiarazione di proprietà di
tipo array ed indica una sequenza di dichiarazioni di parametri del tipo
identificatore1, identificatore2 : tipo separate da punti e virgola.
Anche Index CostanteIntera è facoltativo e serve definire degli specificatori
di indice utili per condividere gli stessi metodi di accesso durante la rappresentazione
di valori differenti.
Specificatori è una sequenza dei seguenti specificatori: read,
write, stored, default, nodefault,
implements. In ogni dichiarazione di proprietà è necessario indicare
almeno uno specificatore read o write.
N.B. Non è possibile utilizzare nelle proprietà l'operatore @ ne
possono essere passate come parametri var; questo perchè non è detto
che la proprietà esista in memoria, la potrebbe aver un metodo read che
recupera il valore per esempio da un database o da altra struttura di dati.
Per gli specificatori di accesso read e write possiamo dire che questi possono fare
riferimento a metodi o a campi. Nel caso di metodi, questi dovranno essere definiti nella
stessa classe in cui è stata dichiarata la proprietà. Per lo specificatore read nel di
un metodo, questo dovrà essere una funzione senza parametri il cui tipo restituito sia
dello stesso tipo della proprietà. Per i metodi relativi allo specificatore write, questi
dovranno essere procedure che abbiano un solo parametro d'ingresso dello stesso tipo della
proprietà.
Quello che segue è un esempio do dichiarazione di proprietà
Property TimeOut : Cardinal read GetTimeOut write SetTimeOut;
La dichiarazione dei metodi degli specificatori read e write è la seguente
Function GetTimeOut : Cardinal;
Procedure SetTimeOut(Value : Cardinal);
Il codice riportato potrebbe far parte di un controllo che implementi al suo interno un
timer di tipo TTimer che permette di impostare e leggere il valore di intervallo del timer
stesso. Avendo la classe TTimer una sua proprietà Interval i metodi dichiarati sopra
potrebbo essere implementati come segue considerando che l'istanza della classe TTimer si
chiami FTimer
Function TMioControllo.GetTimeOut : Cardinal;
Begin
Result := FTimer.Interval;
End;
Procedure TMioControllo.SetTimeOut(Value : Cardinal);
Begin
If Value <> FTimer.Interval then
FTimer.Interval := Value;
End;
Quando tra gli specificatori in una dichiarazione di proprietà compare solamente lo
specificatore read, la proprietà sarà di sola lettura e di sola
scrittura nel caso compaia solamente lo specificatore write. Un esempio
di dichiarazione di proprietà sola lettura
Property TimeElapsed : Boolean read FTimeElapsed;
Come visto all'inizio della trattazione delle proprietà, queste possono contenere
nella dichiarazione dei parametri aggiuntivi come una sequenza di dichiarazione di
parametri. In questo caso abbiamo a che fare con proprietà indicizzate che possono
rappresentare elementi di un elenco (TStringList.Items), controlli figli o i pixel di una
bitmap.
Ecco alcune dichiarazioni di proprietà array (dal manuale del linguaggio)
Property Objects[Index : Integer] :
TObject read GetObject write SetObject;
Property Pixels[X, Y : Integer] :
TColor read GetPixel write SetPixel;
Property Values[const Name : string] :
string read GetValue write
SetValue;
Il formato dell'elenco di parametri è lostesso di quello utilizzato nella
dichiarazione di procedure e funzioni eccezion fatta per le parentesi quadre al posto
delle tonde. Abbiamo praticamente a che fare con degli array dove però mentre nel vero
tipo array gli indici possono essere di tipo ordinal solamente per quanto riguarda le
proprietà array questi possono essere di qualsiasi tipo.
Le proprietà array non ammettono negli specificatori di accesso dei campi, ma
solamente dei metodi. Questo per via degli indici che vengono automaticamente passati al
metodo che si occuperà di recuperare o di scrivere i dati all'indice richiesto. Un metodo
per lo specificatore read deve necessariamente essere una funzione che
accetta lo stesso numero e tipo di parametri elencati nella lista degli indici della
proprietà, passatigli nello stesso ordine; in oltre il tipo restituito dalla funzione
dovrà essere dello stesso tipo della proprietà. Il metodo dello specificatore write
dovrà essere una procedura che accetti come parametri lo stesso numero e tipo di
parametri elencati nella lista degli indici della proprietà, passatigli nello stesso
ordine ed in più il classico parametro valore contenente il valore da settare nella
proprietà. Ecco alcuni esempi di metodi per proprietà array che fanno riferimento ai
metodi dell'esempio precedente
Function GetObject(Index : Integer) : TObject;
Function GetPixel(X, Y : Integer) : TColor;
Function GetValue(const Name : String) : String;
Procedure SetObject(Index : Integer; Value : TObject);
Procedure SetPixel(X, Y : Integer; Value : TColor);
Procedure SetValue(const Name, Value : String);
Le proprietà array possono essere accedute come classicamente si accede alla locazione
di un array nel seguente modo
Canvas.Pixel[5, 45] := clGreen;
quando si definisce una proprietà array, si ha la possibilità di impostarla come
proprietà predefinita della classe a cui appartiene. Ciò permette di accedere alla
proprietà specificando immediatamente dopo il nome della classe l'elenco di indici. Per
diefinire una proprietà predefinita per un classe occorre specificare dopo la
dichiarazione della proprietà la direttiva default. Ad esempio avendo
una dichiarazione del tipo
Type TStringArray = Class
Public
Property Strings[Index : Integer] : String ...;
default;
...
End;
Supponendo che l'istanza della classe TStringArray si chiami StringArray
potremmo accedere alla proprietà Strings della classe nel seguente modo
StringArray[10] := 'Carlo';
al posto di
StringArray.Strings[10] := 'Carlo';
Per ovvi motivi, una classe può avere solamente una proprietà predefinita.