Tutte le categorie di membri che abbiamo analizzato nei precedenti capitoli - campi, metodi, proprietà, costruttori - sono sempre state viste come appartenenti ad un oggetto, ad un'istanza di classe. Infatti, ci si riferisce ad una proprietà o a un metodo di uno specifico oggetto, dicendo ad esempio "La proprietà SideLength dell'oggetto A di tipo Cube vale 3, mentre quella dell'oggetto B anch'esso di tipo Cube vale 4.". La classe, ossia il tipo di una variabile reference, ci diceva solo quali membri un certo oggetto potesse esporre: ci forniva, quindi, il "progetto di costruzione" di un oggetto nella memoria, in cui si potevano collocare tali campi, tali metodi, tal'altre proprietà e via dicendo.
Ora, un membro shared, o condiviso, o statico (termine da usarsi più in C# che non in VB.NET), non appartiene più ad un'istanza di classe, ma alla classe stessa. Mi rendo conto che il concetto possa essere all'inizio difficile da capire e da interiorizzare correttamente. Per questo motivo farò un esempio il più semplice, ma più significativo possibile. Riprendiamo la classe Cube, modificata come segue:

Module Module1

    Class Cube
        Private _SideLength As Single
        Private _Density As Single

        'Questo campo è Shared, condiviso. Come vedete,
        'per dichiarare un membro come tale, si pone la
        'keyword Shared dopo lo specificatore di accesso. Questa
        'variabile conterrà il numero di cubi creati
        'dal nostro programma.
        'N.B.: I campi Shared sono di default Private...
        Private Shared _CubesCount As Int32 = 0

        Public Property SideLength() As Single
            Get
                Return _SideLength
            End Get
            Set(ByVal value As Single)
                If value > 0 Then
                    _SideLength = value
                Else
                    _SideLength = 1
                End If
            End Set
        End Property

        Public Property Density() As Single
            Get
                Return _Density
            End Get
            Set(ByVal value As Single)
                If value > 0 Then
                    _Density = value
                Else
                    _Density = 1
                End If
            End Set
        End Property

        Public ReadOnly Property SurfaceArea() As Single
            Get
                Return (SideLength ^ 2)
            End Get
        End Property

        Public ReadOnly Property Volume() As Single
            Get
                Return (SideLength ^ 3)
            End Get
        End Property

        Public ReadOnly Property Mass() As Single
            Get
                Return (Volume * Density)
            End Get
        End Property

        'Allo stesso modo, la proprietà che espone il membro
        'shared deve essere anch'essa shared
        Public Shared ReadOnly Property CubesCount() As Int32
            Get
                Return _CubesCount
            End Get
        End Property

        'Ogni volta che un nuovo cubo viene creato, _CubesCount
        'viene aumentato di uno, per rispecchiare il nuovo numero
        'di istanze della classe Cube esistenti in memoria
        Sub New()
            _CubesCount += 1
        End Sub
    End Class
    
    Sub Main()
        Dim Cube1 As New Cube()
        Cube1.SideLength = 1
        Cube1.Density = 2700

        Dim Cube2 As New Cube()
        Cube2.SideLength = 0.9
        Cube2.Density = 3500

        Console.Write("Cubi creati: ")
        'Notate come si accede a un membro condiviso: poiché
        'appartiene alla classe e non alla singola istanza, vi si
        'accede specificando prima il nome della classe, poi
        'il comune operatore punto, e successivamente il nome
        'del membro. Tutti i membri shared funzionano in questo
        'modo
        Console.WriteLine(Cube.CubesCount)

        Console.ReadKey()
    End Sub
End Module 

Facendo correre l'applicazione, si vedrà apparire a schermo il numero 2, poiché abbiamo creato due oggetti di tipo Cube. Come si vede, il campo CubesCount non riguarda un solo specifico oggetto, ma la totalità di tutti gli oggetti di tipo Cube, poiché è un dato globale. In generale, esso è di dominio della classe Cube, ossia della rappresentazione più astratta dell'essenza di ogni oggetto: per sapere quanti cubi sono stati creati, non si può interpellare una singola istanza, perchè essa non "ha percezione" di tutte le altre istanze esistenti. Per questo motivo CubesCount è un membro condiviso.
Anche in questo caso c'è una ristretta gamma di casi in cui è opportuno scegliere di definire un membro come condiviso:

• Quando contiene informazioni riguardanti la totalità delle istanze di una classe, come in questo caso;
• Quando contiene informazioni accessibili e necessarie a tutte le istanze della classe, come illustrerò fra qualche capitolo;
• Quando si tratta di un metodo "di libreria". I cosiddetti metodi di libreria sono metodi sempre shared che svolgono funzioni generali e sono utilizzabili da qualsiasi parte del codice. Un esempio potrebbe essere la funzione Math.Abs(x), che restituisce il valore assoluto di x. Come si vede, è shared poiché vi si accede usando il nome della classe. Inoltre, essa è sempre usabile, poiché si tratta di una semplice funzione matematica, che, quindi, fornisce servizi di ordine generale;
• Quando si trova in un modulo, come spiegherò nel prossimo paragrafo.

Classi Shared

Come!?!? Esistono classi shared? Ebbene sì. Può sembrare assurdo, ma ci sono, ed è lecito domandarsi quale sia la loro funzione. Se un membro shared appartiene a una classe... cosa possiamo dire di una classe shared?
A dire il vero, abbiamo sempre usato classi shared senza saperlo: i moduli, infatti, non sono altro che classi condivise (o statiche). Tuttavia, il significato della parola shared, se applicato alle classi, cambia radicalmente. Un modulo, quindi una classe shared, rende implicitamente shared tutti i suoi membri. Quindi, tutte le proprietà, i campi e i metodi appartenenti ad un modulo - ivi compresa la Sub Main - sono membri shared. Che senso ha questo? I moduli sono consuetamente usati, al di fuori delle applicazioni console, per rendere disponibili a tutto il progetto membri di particolare rilevanza o utilità, ad esempio funzioni per il salvataggio dei dati, informazioni sulle opzioni salvate, eccetera... Infatti è impossibile definire un membro shared in un modulo, poiché ogni membro del modulo lo è già di per sé:

Module Module1
    Shared Sub Hello()
    
    End Sub
    
    '...
End Sub 

Il codice sopra riportato provocherà il seguente errore:

Methods in a Module cannot be declared 'Shared'. 

Inoltre, è anche possibile accedere a membri di un modulo senza specificare il nome del modulo, ad esempio:

Module Module2
    Sub Hello()
        Console.WriteLine("Hello!")
    End Sub
End Module

Module Module1
    Sub Main()
        Hello() ' = Module2.Hello()
        Console.ReadKey()
    End Sub
End Module 

Questo fenomeno è anche noto col nome di Imports statico.
A dir la verità esiste una piccola differenza tra classi statiche e moduli. Una classe può essere statica anche solo se tutti i suoi membri lo sono, ma non gode dell'Imports Statico. Un modulo, al contrario, oltre ad avere tutti i membri shared, gode sempre dell'Imports Statico. Per farla breve:

Module Module2
    Sub Hello()
        Console.WriteLine("Hello Module2!")
    End Sub
End Module

Class Class2
    Shared Sub Hello()
        Console.WriteLine("Hello Class2!")
    End Sub
End Class

Module Module1
    Sub Main()
        'Per richiamare l'Hello di Class2, è sempre 
        'necessaria questa sintassi:
        Class2.Hello()
        'Per invocare l'Hello di Module2, invece, basta
        'questa, a causa dell'Imports Statico
        Hello()
        Console.ReadKey()
    End Sub
End Module