Il capitolo 6 introduce le proprietà in Python e l’uso di Visual Studio per estendere una applicazione IronPython creando una class library.
I post precedenti sono: first class functions e xml, applicazioni e design pattern, oggetti .NET e IronPython, introduzione a Python, introduzione al libro e il preambolo.
L’idea dell’autore è quella di usare parzialmente l’observer pattern per mantenere sincronizzate le parti dell’applicazione. Per scatenare i vari side effect durante l’accesso degli attributi usa le proprietà.
In Python, come ho detto nell’introduzione, esistono vari protocolli che definiscono alcune key feature del linguaggio. Le proprietà non sono altro che una implementazione del descriptor protocol, un protocollo diffusissimo che permette il totale controllo sull’accesso agli attributi di un oggetto. Altre implementazioni sono i class method e gli static method.
Un solo meccanismo e varie implementazioni… Python è piuttosto chiaro come linguaggio.
La signature completa di una property è:
>>> name = property(fget=None, fset=None, fdel=None, doc=None)
dove fget è la funzione getter, fset è la funzione setter, fdel è la funzione che intercetta la cancellazione dell’attributo e doc è la docstring della proprietà. Esempio:
>>> class Foo(object):
... def __init__(self, x):
... self._x = x # _x is private
... def _getX(self):
... print "getting x"
... return self._x
... def _setX(self, value):
... print "setting x"
... self._x = value
... def _delX(self):
... print "Attempting to delete x"
... x = property(_getX, _setX, _delX)
...
>>> foo = Foo('foo')
>>> foo.x
getting x
'foo'
>>> foo.x = 'bar'
setting x
>>> del foo.x
Attempting to delete x
Apro una parentesi: le property in Python non sono usate estensivamente come in C# per via del fatto che l’ambiente non lo richiede. Solitamente si procede così: si espone un attributo pubblico e lo si usa tranquillamente, se poi questo ha bisogno di una logica dietro allora lo si incapsula in una property. Questo permette una totale trasparenza verso l’utilizzatore dell’oggetto che non si accorgerà neanche che l’attributo pubblico è diventato una property senza dunque rompere alcuna interfaccia.
Dopo aver implementato i document observer il libro passa ad introdurre l’uso di Visual Studio per sviluppare una dialog da inglobare in una class library, oltre ad una serie di comandi per completare l’applicazione.
Io ho provato personalmente a creare la libreria seguendo le istruzioni del libro ed usando Visual Studio Express 2008 ed importarla in Python e tutto ha funzionato perfettamente. IronPython è davvero facilmente estensibile:
>>> import clr
>>> clr.AddReference('RenameTabDialog')
>>> import RenameTabDialog
>>> dir(RenameTabDialoglog)
>>> dir(RenameTabDialog)
['Class1', 'RenameTabDialogBase']
>>> # RenameTabDialogBase is the dialog
RenameTabDialog è la dll contenente la form RenameTabDialogBase che poi gli esempi usano estendendola.
Il capitolo finisce introducendo anche la classe BinaryFormatter per serializzare una serie di risorse bitmap.