Totem's Lair: Guida al Vb.Net, Membri Shared

A25. Membri Shared

La keyword Shared indica che il membro ad essa associato è considerato statico o condiviso. In questo modo si specifica che il membro in questione non appartiene ad ogni singola istanza della classe, ma alla classe stessa. Forse potrebbe sembrare un concetto un pò astratto, ma non è così: i normali membri sono detti di istanza perchè non è possibile richiamarli se non facendo riferimento a un nuovo oggetto creato sulla base della classe, esempio:

Module Module1
    Class Esempio
        Public P1, P2 As Int32
    End Class

    Sub Main()
        'Questo codice genera un errore: non ci si
        'può riferire a normali membri in questo modo:
        Console.WriteLine(Esempio.P1)
        
        'Questo codice invece è giusto:
        Dim P As New Esempio
        Console.WriteLine(P.P1)
    End Sub
End Module

Dichiarando un membro come Shared, invece, è possibile usare la prima chiamata dell'esempio. Tuttavia ci sono particolari situazioni in cui è buona norma utilizzare membri statici anzichè membri normali, e di seguito ve ne è una piccola lista.

Metodi Shared

Riprendiamo un esempio fatto in precedenza, quello della classe Calcolatrice. Nel modo in cui veniva dichiarata e scritta la classe era obbligatorio creare un nuovo oggetto, impostare i due campi a e b e successivamente richiamare il metodo corrispondente all'operazione da eseguire. Ora propongo la stessa classe riscritta usando i metodi Shared:

Module Module2
    Class Calcolatrice
        'La funzione è Shared e accetta un numero indefinito di parametri
        Shared Function Somma(ByVal ParamArray Valori() As Single) _ 
            As Single
            Dim Temp As Single = 0
            For I As Int16 = 0 To UBound(Valori)
                Temp += Valori(I)
            Next
            Return Temp
        End Function
        
        Shared Function Sottrazione(ByVal ParamArray Valori() As Single) _
            As Single
            Dim Temp As Single = Valori(0)
            For I As Int16 = 1 To UBound(Valori)
                Temp -= Valori(1)
            Next
        End Function
        '...
    End Class
    
    Sub Main()
        Console.WriteLine(Calcolatrice.Somma(1, 2, 3, 4))
        Console.WriteLine(Calcolatrice.Sottrazione(7, 2, 3, 2))
        Console.ReadKey()
    End Sub
End Module

Come si è visto, per accedere a un metodo statico è sufficiente anteporre ad esso il nome della sua classe, seguito dall'operatore punto. È molto importante ricordare che: non è assolutamente possibile accedere ai membri di istanza dall'interno di un metodo statico, per ovvi motivi; è invece possibile, ma non raccomandabile, accedere a metodi statici partendo da istanze della classe. Con una direttiva Imports all'inizio del progetto, infine, è possibile abbreviare la sintassi usata per richiamare un metodo condiviso:

Imports Calcolatrice
'...
Console.WriteLine(Somma(1, 2, 3, 4))

Può accadere che ci siano classi contenenti solo metodi statici e ciò si verifica in due casi: il primo è quando al classe fornisce solo metodi di "libreria", ossia si limita a esporre solo procedure e funzioni che serviranno in seguito per l'esecuzione di calcoli od operazioni; un esempio di questo caso è la classe System.Math, che riporta solo metodi statici per calcolare funzioni trigonometriche, potenze, radici, approssimazioni, eccetera. Il secondo caso si verifica quando di una classe può esistere una e una sola istanza e che quindi non può essere ulteriormente istanziata: un esempio di questo è la classe System.Console, che contiene solo metodi statici per agire sull'unica finestra console presente nel progetto; ogni classe con queste ultime caratteristiche viene definita oggetto singleton. Tuttavia una classe statica che contiene solo metodi di questo tipo non è molto differente da un modulo, anzi: ogni membro del modulo è implicitamente definto Shared. La caratteristica nota come Imports Statico non è altro che la capacità del Visual Basic.Net di poter richiamare una funzione da un modulo senza specificare il nome del modulo.

Campi Shared

Allo stessso modo dei metodi, i campi shared, e in questo caso mi riferisco solo alle variabili, appartengono esclusivamente alla classe e non alle sue istanze. Ogni variabile statica è di default considerata Private, e, nonostante sia possibile modificarne lo specificatore di accesso come visto in precedenza, è consigliabile non esporre mai variabili pubbliche, nè di istanza nè statiche, ma avvolgerle in una proprietà. Un esempio dell'uso di un campo statico è quello di contare quante istanze di una certa classe esitono nella memoria. Si può mettere in atto questa strategia dichiarando un campo statico e incrementandolo in ogni costruttore di istanza:

Module Module3
    Class Contatore
        Shared Count As Int32 = 0

        Public Sub New()
            Count += 1
        End Sub

        Public Sub ShowCount()
            Console.WriteLine(Count)
        End Sub
    End Class

    Sub Main()
        Dim A As New Contatore()
        A.ShowCount()

        Dim B As New Contatore()
        B.ShowCount()

        Console.ReadKey()
    End Sub
End Module

L'output che apparirà sullo schermo è:

1
2

Proprietà Shared

Le proprietà shared hanno più o meno la stessa funzione dei campi shared, ma, come si è visto, le proprietà servono il più delle volte per rendere pubblici campi privati e mediarne l'assegnazione o la lettura. Perciò esse sono usate per fare da wrapper a campi statici, o al massimo per restituire dati inerenti ad essi. Per esempio, nell'esempio appena fatto si potrebbe aggiungere una proprietà statica ReadOnly che comunichi quale sarà il prossimo numero di istanza.

The Totem's Lair - Copyright (C) 2009
È vietata la riproduzione sia totale che parziale del sito.