|
Scopo delle Interfacce
Le interfacce sono un'entità davvero singolare all'interno del .NET Framework. La loro funzione è assimilabile a quella delle
classi astratte, ma il modo con cui esse la svolgono è molto diverso da ciò che abbiamo visto nel capitolo precedente.
Il principale scopo di un'interfaccia è definire lo scheletro di una classe; potrebbe essere scherzosamente assimilata alla ricetta
con cui si prepara un dolce. Quello che l'interfaccia X fa, ad esempio, consiste nel dire che per costruire una classe Y che rispetti
"la ricetta" descritta in X servono una proprietà Id di tipo Integer, una funzione GetSomething senza parametri che restituisce
una stringa e una procedura DoSomething con un singolo parametro Double. Tutte le classi che
avranno intenzione di seguire i precetti di X (in gergo implementare X) dovranno definire, allo stesso modo, quella proprietà
di quel tipo e quei metodi con quelle specifiche signature (il nome ha importanza relativa).
Faccio subito un esempio. Fino ad ora, abbiamo visto essenzialmente due tipi di collezione: gli Array e gli ArrayList. Sia per l'uno che
per l'altro, ho detto che è possibile eseguire un'iterazione con il costrutto For Each:
Dim Ar() As Int32 = {1, 2, 3, 4, 5, 6}
Dim Al As New ArrayList
For I As Int32 = 1 To 40
Al.Add(I)
Next
'Stampa i valori di Ar:
For Each K As Int32 In Ar
Console.WriteLine(K)
Next
'Stampa i valori di Al
For Each K As Int32 In Al
Console.WriteLine(K)
Next
Ma il sistema come fa a sapere che Ar e Al sono degli insiemi di valori? Dopotutto, il loro nome è significativo solo per noi programmatori,
mentre per il calcolatore non è altro che una sequenza di caratteri. Allo stesso modo, il codice di Array e ArrayList, definito dai
programmatori che hanno scritto il Framework, è intelligibile solo agli uomini, perchè al computer non comunica nulla sullo
scopo per il quale è stato scritto. Allora, siamo al punto di partenza: nelle classi Array e ArrayList non c'è nulla che possa
far "capire" al programma che quelli sono a tutti gli effetti delle collezioni e che, quindi, sono iterabili; e, anche se in qualche strano
modo l'elaboratore lo potesse capire, non "saprebbe" (in quanto entità non senziente) come far per estrarre singoli dati e darceli
uno in fila all'altro. Ecco che entrano in scena le interfacce: tutte le classi che rappresentano un insieme o una collezione di elementi
implementano l'interfaccia IEnumerable, la quale, se potesse parlare, direbbe "Guarda che questa classe è una collezione,
trattala di conseguenza!". Questa interfaccia obbliga le classi dalle quali è implementata a definire alcuni metodi che servono
per l'enumerazione (Current, MoveNext e Reset) e che vedremo nei prossimi capitoli.
In conclusione, quindi, il For Each prima di tutto controlla che l'oggetto posto
dopo la clausola "In" implementi l'interfaccia IEnumerable. Quindi richiama il metodo Reset per porsi sul primo elemento, poi deposita
in K il valore esposto dalla proprietà Current, esegue il codice contenuto nel proprio corpo e, una volta arrivato a Next, esegue
il metodo MoveNext per avanzare al prossimo elemento. Il For Each "è sicuro" dell'esistenza di questi membri perchè l'interfaccia
IEnumerable ne impone la definizione.
Riassumendo, le interfacce hanno il compito di informare il sistema su quali siano le caratteristiche e i compiti di una classe. Per questo
motivo, il loro nomi terminano spesso in "-able", come ad esempio IEnumerable, IEquatable, IComprable, che ci dicono "- è enumerabile",
"- è eguagliabile", "- è comparabile", "è ... qualcosa".
Dichiarazione e implementazione
La sintassi usata per dichiarare un'interfaccia è la seguente:
Interface [Nome]
'Membri
End Interface
I membri delle interfacce, tuttavia, sono un po' diversi dai membri di una classe, e nello scriverli bisogna rispettare queste regole:
- Nel caso di metodi, proprietà od eventi, il corpo non va specificato;
- Non si possono mai usare gli specificatori di accesso;
- Si possono comunque usare dei modificatori come Shared, ReadOnly e WriteOnly.
Il primo ed il secondo punto saranno ben compresi se ci si sofferma a pensare che l'interfaccia ha il solo scopo di definire quali membri
una classe debba implementare: per questo motivo, non se ne può scrivere il corpo, dato che spetta espressamente alle
classi implementanti, e non ci si preoccupa dello specificatore di accesso, dato che si sta specificando solo il "cosa" e non il "come".
Ecco alcuni semplici esempi di dichiarazioni:
'Questa interfaccia dal nome improbabile indica che
'la classe che la implementa rappresenta qualcosa di
'"identificabile" e per questo espone una proprietà Integer Id
'e una funzione ToString. Id e ToString, infatti, sono gli
'elementi più utili per identificare qualcosa, prima in
'base a un codice univoco e poi grazie ad una rappresentazione
'comprensibile dall'uomo
Interface IIdentifiable
ReadOnly Property Id() As Int32
Function ToString() As String
End Interface
'La prossima interfaccia, invece, indica qualcosa di resettabile
'e obbliga le classi implementanti a esporre il metodo Reset
'e la proprietà DefaultValue, che dovrebbe rappresentare
'il valore di default dell'oggetto. Dato che non sappiamo ora
'quali classi implementeranno questa interfaccia, dobbiamo
'per forza usare un tipo generico come Object per rappresentare
'un valore reference. Vedremo come aggirare questo ostacolo
'fra un po', con i Generics
Interface IResettable
Property DefaultValue() As Object
Sub Reset()
End Interface
'Come avete visto, i nomi di interfaccia iniziano per convenzione
'con la lettera I maiuscola
Ora che sappiamo come dichiarare un'interfaccia, dobbiamo scoprire come usarla. Per implementare un'interfaccia in una classe, si usa
questa sintassi:
Class Example
Implements [Nome Interfaccia]
[Membro] Implements [Nome Interfaccia].[Membro]
End Class
Si capisce meglio con un esempio:
Module Module1
Interface IIdentifiable
ReadOnly Property Id() As Int32
Function ToString() As String
End Interface
'Rappresenta un pacco da spedire
Class Pack
'Implementa l'interfaccia IIdentifiable, in quanto un pacco
'dovrebbe poter essere ben identificato
Implements IIdentifiable
'Notate bene che l'interfaccia ci obbliga a definire una
'proprietà, ma non ci obbliga a definire un campo
'ad essa associato
Private _Id As Int32
Private _Destination As String
Private _Dimensions(2) As Single
'La classe definisce una proprietà id di tipo Integer
'e la associa all'omonima presente nell'interfaccia in
'questione. Il legame tra questa proprietà Id e quella
'presenta nell'interfaccia è dato solamente dalla
'clausola (si chiama così in gergo) "Implements",
'la quale avvisa il sistema che il vincolo imposto
'è stato soddisfatto.
'N.B.: il fatto che il nome di questa proprietà sia uguale
'a quella definita in IIdentifiable non significa nulla.
'Avremmo potuto benissimo chiamarla "Pippo" e associarla
'a Id tramite il codice "Implements IIdentifiable.Id", ma
'ovviamente sarebbe stata una palese idiozia XD
Public ReadOnly Property Id() As Integer Implements IIdentifiable.Id
Get
Return _Id
End Get
End Property
'Destinazione del pacco.
'Il fatto che l'interfaccia ci obblighi a definire quei due
'membri non significa che non possiamo definirne altri
Public Property Destination() As String
Get
Return _Destination
End Get
Set(ByVal value As String)
_Destination = value
End Set
End Property
'Piccolo ripasso delle proprietà indicizzate e
'della gestione degli errori
Public Property Dimensions(ByVal Index As Int32) As Single
Get
If (Index >= 0) And (Index < 3) Then
Return _Dimensions(Index)
Else
Throw New IndexOutOfRangeException()
End If
End Get
Set(ByVal value As Single)
If (Index >= 0) And (Index < 3) Then
_Dimensions(Index) = value
Else
Throw New IndexOutOfRangeException()
End If
End Set
End Property
Public Overrides Function ToString() As String Implements IIdentifiable.ToString
Return String.Format("{0}: Pacco {1}x{2}x{3}, Destinazione: {4}", _
Me.Id, Me.Dimensions(0), Me.Dimensions(1), _
Me.Dimensions(2), Me.Destination)
End Function
End Class
Sub Main()
'...
End Sub
End Module
Ora che abbiamo implementato l'interfaccia nella classe Pack, tuttavia, non sappiamo che farcene. Siamo a conoscenza del fatto che gli oggetti
Pack saranno sicuramente identificabili, ma nulla di più. Ritorniamo, allora, all'esempio del primo paragrafo: cos'è che
rende veramente utile IEnumerable, al di là del fatto di rendere funzionante il For Each? Si applica a qualsiasi collezione o insieme,
non importa di quale natura o per quali scopi, non importa nemmeno il codice che sottende all'enumerazione: l'importante è che
una vastissima gamma di oggetti possano essere ricondotti ad un solo archetipo (io ne ho nominati solo due, ma ce ne sono a iosa). Allo
stesso modo, potremo usare IIdentifiable per manipolare una gran quantità di dati di natura differente. Ad esempio, il codice di sopra
potrebbe essere sviluppato per creare un sistema di gestione di un ufficio postale. Eccone un esempio:
Module Module1
Interface IIdentifiable
ReadOnly Property Id() As Int32
Function ToString() As String
End Interface
Class Pack
Implements IIdentifiable
Private _Id As Int32
Private _Destination As String
Private _Dimensions(2) As Single
Public ReadOnly Property Id() As Integer Implements IIdentifiable.Id
Get
Return _Id
End Get
End Property
Public Property Destination() As String
Get
Return _Destination
End Get
Set(ByVal value As String)
_Destination = value
End Set
End Property
Public Property Dimensions(ByVal Index As Int32) As Single
Get
If (Index >= 0) And (Index < 3) Then
Return _Dimensions(Index)
Else
Throw New IndexOutOfRangeException()
End If
End Get
Set(ByVal value As Single)
If (Index >= 0) And (Index < 3) Then
_Dimensions(Index) = value
Else
Throw New IndexOutOfRangeException()
End If
End Set
End Property
Sub New(ByVal Id As Int32)
_Id = Id
End Sub
Public Overrides Function ToString() As String Implements IIdentifiable.ToString
Return String.Format("{0:0000}: Pacco {1}x{2}x{3}, Destinazione: {4}", _
Me.Id, Me.Dimensions(0), Me.Dimensions(1), _
Me.Dimensions(2), Me.Destination)
End Function
End Class
Class Telegram
Implements IIdentifiable
Private _Id As Int32
Private _Recipient As String
Private _Message As String
Public ReadOnly Property Id() As Integer Implements IIdentifiable.Id
Get
Return _Id
End Get
End Property
Public Property Recipient() As String
Get
Return _Recipient
End Get
Set(ByVal value As String)
_Recipient = value
End Set
End Property
Public Property Message() As String
Get
Return _Message
End Get
Set(ByVal value As String)
_Message = value
End Set
End Property
Sub New(ByVal Id As Int32)
_Id = Id
End Sub
Public Overrides Function ToString() As String Implements IIdentifiable.ToString
Return String.Format("{0:0000}: Telegramma per {1} ; Messaggio = {2}", _
Me.Id, Me.Recipient, Me.Message)
End Function
End Class
Class MoneyOrder
Implements IIdentifiable
Private _Id As Int32
Private _Recipient As String
Private _Money As Single
Public ReadOnly Property Id() As Integer Implements IIdentifiable.Id
Get
Return _Id
End Get
End Property
Public Property Recipient() As String
Get
Return _Recipient
End Get
Set(ByVal value As String)
_Recipient = value
End Set
End Property
Public Property Money() As Single
Get
Return _Money
End Get
Set(ByVal value As Single)
_Money = value
End Set
End Property
Sub New(ByVal Id As Int32)
_Id = Id
End Sub
Public Overrides Function ToString() As String Implements IIdentifiable.ToString
Return String.Format("{0:0000}: Vaglia postale per {1} ; Ammontare = {2}?", _
Me.Id, Me.Recipient, Me.Money)
End Function
End Class
'Classe che elabora dati di tipo IIdentifiable, ossia qualsiasi
'oggetto che implementi tale interfaccia
Class PostalProcessor
'Tanto per tenersi allenati coi delegate, ecco una
'funzione delegate che funge da filtro per i vari id
Public Delegate Function IdSelector(ByVal Id As Int32) As Boolean
Private _StorageCapacity As Int32
Private _NextId As Int32 = 0
'Un array di interfacce. Quando una variabile viene
'dichiarata come di tipo interfaccia, ciò
'che può contenere è qualsiasi oggetto
'che implementi quell'interfaccia. Per lo stesso
'discorso fatto nel capitolo precedente, noi
'possiamo vedere attraverso l'interfaccia
'solo quei membri che essa espone direttamente, anche
'se il contenuto vero e proprio è qualcosa
'di più
Private Storage() As IIdentifiable
'Capacità del magazzino. Assumeremo che tutti
'gli oggetti rappresentati dalle classi Pack, Telegram
'e MoneyOrder vadano in un magazzino immaginario che,
'improbabilmente, riserva un solo posto per ogni
'singolo elemento
Public Property StorageCapacity() As Int32
Get
Return _StorageCapacity
End Get
Set(ByVal value As Int32)
_StorageCapacity = value
ReDim Preserve Storage(value)
End Set
End Property
'Modifica od ottiene un riferimento all'Index-esimo
'oggetto nell'array Storage
Public Property Item(ByVal Index As Int32) As IIdentifiable
Get
If (Index >= 0) And (Index < Storage.Length) Then
Return Me.Storage(Index)
Else
Throw New IndexOutOfRangeException()
End If
End Get
Set(ByVal value As IIdentifiable)
If (Index >= 0) And (Index < Storage.Length) Then
Me.Storage(Index) = value
Else
Throw New IndexOutOfRangeException()
End If
End Set
End Property
'Restituisce la prima posizione libera nell'array
'Storage. Anche se in questo esempio non l'abbiamo
'contemplato, gli elementi possono anche essere rimossi
'e quindi lasciare un posto libero nell'array
Public ReadOnly Property FirstPlaceAvailable() As Int32
Get
For I As Int32 = 0 To Me.Storage.Length - 1
If Me.Storage(I) Is Nothing Then
Return I
End If
Next
Return (-1)
End Get
End Property
'Tutti gli oggetti che inizializzeremo avranno bisogno
'di un id: ce lo fornisce la stessa classe Processor
'tramite questa proprietà che si autoincrementa
Public ReadOnly Property NextId() As Int32
Get
_NextId += 1
Return _NextId
End Get
End Property
'Due possibili costruttori: uno che accetta un insieme
'già formato di elementi...
Public Sub New(ByVal Items() As IIdentifiable)
Me.Storage = Items
_SorageCapacity = Items.Length
End Sub
'... e uno che accetta solo la capacità del magazzino
Public Sub New(ByVal Capacity As Int32)
Me.StorageCapacity = Capacity
End Sub
'Stampa a schermo tutti gli elementi che la funzione
'contenuta nel parametro Selector di tipo delegate
'considera validi (ossia tutti quelli per cui
'Selector.Invoke restituisce True)
Public Sub PrintByFilter(ByVal Selector As IdSelector)
For Each K As IIdentifiable In Storage
If K Is Nothing Then
Continue For
End If
If Selector.Invoke(K.Id) Then
Console.WriteLine(K.ToString())
End If
Next
End Sub
'Stampa l'oggetto con Id specificato
Public Sub PrintById(ByVal Id As Int32)
For Each K As IIdentifiable In Storage
If K Is Nothing Then
Continue For
End If
If K.Id = Id Then
Console.WriteLine(K.ToString())
Exit For
End If
Next
End Sub
'Cerca tutti gli elementi che contemplano all'interno
'della propria descrizione la stringa Str e li
'restituisce come array di Id
Public Function SearchItems(ByVal Str As String) As Int32()
Dim Temp As New ArrayList
For Each K As IIdentifiable In Storage
If K Is Nothing Then
Continue For
End If
If K.ToString().Contains(Str) Then
Temp.Add(K.Id)
End If
Next
Dim Result(Temp.Count - 1) As Int32
For I As Int32 = 0 To Temp.Count - 1
Result(I) = Temp(I)
Next
Temp.Clear()
Temp = Nothing
Return Result
End Function
End Class
Private Processor As New PostalProcessor(10)
Private Cmd As Char
Private IdFrom, IdTo As Int32
Function SelectId(ByVal Id As Int32) As Boolean
Return (Id >= IdFrom) And (Id <= IdTo)
End Function
Sub InsertItems(ByVal Place As Int32)
Console.WriteLine("Scegliere la tipologia di oggetto:")
Console.WriteLine(" p - pacco;")
Console.WriteLine(" t - telegramma;")
Console.WriteLine(" v - vaglia postale;")
Cmd = Console.ReadKey().KeyChar
Console.Clear()
Select Case Cmd
Case "p"
Dim P As New Pack(Processor.NextId)
Console.WriteLine("Pacco - Id:{0:0000}", P.Id)
Console.Write("Destinazione: ")
P.Destination = Console.ReadLine
Console.Write("Larghezza: ")
P.Dimensions(0) = Console.ReadLine
Console.Write("Lunghezza: ")
P.Dimensions(1) = Console.ReadLine
Console.Write("Altezza: ")
P.Dimensions(2) = Console.ReadLine
Processor.Item(Place) = P
Case "t"
Dim T As New Telegram(Processor.NextId)
Console.WriteLine("Telegramma - Id:{0:0000}", T.Id)
Console.Write("Destinatario: ")
T.Recipient = Console.ReadLine
Console.Write("Messaggio: ")
T.Message = Console.ReadLine
Processor.Item(Place) = T
Case "v"
Dim M As New MoneyOrder(Processor.NextId)
Console.WriteLine("Vaglia - Id:{0:0000}", M.Id)
Console.Write("Beneficiario: ")
M.Recipient = Console.ReadLine
Console.Write("Somma: ")
M.Money = Console.ReadLine
Processor.Item(Place) = M
Case Else
Console.WriteLine("Comando non riconosciuto.")
Console.ReadKey()
Exit Sub
End Select
Console.WriteLine("Inserimento eseguito!")
Console.ReadKey()
End Sub
Sub ProcessData()
Console.WriteLine("Selezionare l'operazione:")
Console.WriteLine(" c - cerca;")
Console.WriteLine(" v - visualizza;")
Cmd = Console.ReadKey().KeyChar
Console.Clear()
Select Case Cmd
Case "c"
Dim Str As String
Console.WriteLine("Inserire la parola da cercare:")
Str = Console.ReadLine
Dim Ids() As Int32 = Processor.SearchItems(Str)
Console.WriteLine("Trovati {0} elementi. Visualizzare? (y/n)", Ids.Length)
Cmd = Console.ReadKey().KeyChar
Console.WriteLine()
If Cmd = "y" Then
For Each Id As Int32 In Ids
Processor.PrintById(Id)
Next
End If
Case "v"
Console.WriteLine("Visualizzare gli elementi")
Console.Write("Da Id: ")
IdFrom = Console.ReadLine
Console.Write("A Id: ")
IdTo = Console.ReadLine
Processor.PrintByFilter(AddressOf SelectId)
Case Else
Console.WriteLine("Comando sconosciuto.")
End Select
Console.ReadKey()
End Sub
Sub Main()
Do
Console.WriteLine("Gestione ufficio")
Console.WriteLine()
Console.WriteLine("Selezionare l'operazione da effettuare:")
Console.WriteLine(" i - inserimento oggetti;")
Console.WriteLine(" m - modifica capacità magazzino;")
Console.WriteLine(" p - processa i dati;")
Console.WriteLine(" e - esci.")
Cmd = Console.ReadKey().KeyChar
Console.Clear()
Select Case Cmd
Case "i"
Dim Index As Int32 = Processor.FirstPlaceAvailable
Console.WriteLine("Inserimento oggetti in magazzino")
Console.WriteLine()
If Index > -1 Then
InsertItems(Index)
Else
Console.WriteLine("Non c'è più spazio in magazzino!")
Console.ReadKey()
End If
Case "m"
Console.WriteLine("Attuale capacità: " & Processor.StorageCapacity)
Console.WriteLine("Inserire una nuova dimensione: ")
Processor.StorageCapacity = Console.ReadLine
Console.WriteLine("Operazione effettuata.")
Console.ReadKey()
Case "p"
ProcessData()
End Select
Console.Clear()
Loop Until Cmd = "e"
End Sub
End Module
Avevo in mente di definire anche un'altra interfaccia, IPayable, per calcolare anche il costo di spedizione di ogni pezzo: volevo far notare
come, sebbene il costo vada calcolato in maniera diversa per i tre tipi di oggetto (in base alle dimensioni per il pacco, in base al numero
di parole per il telegramma e in base all'ammontare inviato per il vaglia), bastasse richiamare una funzione attraverso l'interfaccia
per ottenere il risultato. Poi ho considerato che un esempio di 400 righe era già abbastanza. Ad ogni modo, userò adesso
quel'idea in uno spezzone tratto dal programma appena scritto per mostrare l'uso di interfacce multiple:
Module Module1
'...
Interface IPayable
Function CalculateSendCost() As Single
End Interface
Class Telegram
'Nel caso di più interfacce, le si separa con la virgola
Implements IIdentifiable, IPayable
'...
Public Function CalculateSendCost() As Single Implements IPayable.CalculateSendCost
'Come vedremo nel capitolo dedicato alle stringhe,
'la funzione Split(c) spezza la stringa in tante
'parti, divise dal carattere c, e le restituisce
'sottoforma di array. In questo caso, tutte le sottostringhe
'separate da uno spazio sono all'incirca tante
'quanto il numero di parole nella frase
Select Case Me.Message.Split(" ").Length
Case Is <= 20
Return 4.39
Case Is <= 50
Return 6.7
Case Is <= 100
Return 10.3
Case Is <= 200
Return 19.6
Case Is <= 500
Return 39.75
End Select
End Function
End Class
'...
End Class
Definizione di tipi in un'interfaccia
Così come è possibile dichiarare una nuova classe all'interno di un'altra, o una struttura in una classe, o un'interfaccia
in una classe, o una struttura in una struttura, o tutte le altre possibili combinazioni, è anche possibile dichiarare un nuovo
tipo in un'interfaccia. In questo caso, solo le classi che implementeranno quell'interfaccia saranno in grado di usare quel tipo.
Ad esempio:
Interface ISaveable
Structure FileInfo
'Assumiamo per brevità che queste variabili Public
'siano in realtà proprietà
Public Path As String
'FileAttribues è un enumeratore su bit che contiene
'informazioni sugli attributi di un file (nascosto, a sola
'lettura, archivio, compresso, eccetera...)
Public Attributes As FileAttributes
End Structure
Property SaveInfo() As FileInfo
Sub Save()
End Interface
Class A
Private _SaveInfo As ISaveable.FileInfo 'SBAGLIATO!
'...
End Class
Class B
Implements ISaveable
Private _SaveInfo As ISaveable.FileInfo 'GIUSTO
'...
End Class
Ereditarietà, polimorfismo e overloading per le interfacce
Anche le interfacce possono ereditare da un'altra interfaccia base. In questo caso, dato che in un'interfaccia non si possono usare specificatori
di accesso, la classe derivata acquisisce tutti i membri di quella base:
Interface A
Property PropA() As Int32
End Interface
Interface B
Inherits A
Sub SubB()
End Interface
Non si può usare il polimorfismo perchè non c'è nulla da ridefinire, in quanto i metodi non hanno un corpo.
Si può, invece, usare l'overloading come si fa di consueto: non ci sono differenze significative in questo ambito.
Perchè preferire un'interfaccia a una classe astratta
Ci sono casi e casi. In genere, un'interfaccia va preferita quando si dovranno abbracciare grandi quantità di classi diverse: con
grandi mi riferisco a numeri abbastanza grandi da rendere difficile l'uso di una sola classe astratta. È bene usare le interfacce
anche quando si progetta di usarne più di una: una classe, infatti, può implementare quante interfacce vuole, ma può
ereditare da una sola classe base.
Proprio per questi motivi, è ideale usare un'interfaccia quando si vuole delineare una caratteristica o un particolare comportamento
che può essere comune a più tipi, mentre è meglio puntare a una classe astratta quando si vuole sottolineare
l'appartenenza di molti tipi ad un unico archetipo base.
|
|
Feeds
Sondaggio
Condividi
Numeri
