Discussion :

[Sehnsucht]

Bonsoir,

Ceci est plutôt une interrogation qu'un réel problème, en faisant des recherches sur le pattern Singleton,
je me suis retrouvé face à 3 choix possibles qui a priori fonctionnent/sont fonctionnellement équivalents ;
et en fait je me demande surtout quelles sont leurs différences :

• si une écriture est à privilégier,
• si oui dans quels cas (pour tous les cas ?),
• les qualités/défauts de chaque pour faire court.

(Notamment en ce qui concerne la 3ème implémentation où je pige pas trop "le truc magique" )

1ère implémentation: le Singleton "classique"

Code VB.Net :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
Public NotInheritable Class Singleton
 
    Private Shared _Instance As Singleton
    Private Shared ReadOnly _SyncRoot As New Object
 
    Private Sub New()
    End Sub
 
    Shared ReadOnly Property Instance As Singleton
        Get
            If IsNothing(_Instance) Then
                SyncLock _SyncRoot
                    If IsNothing(_Instance) Then
                        _Instance = New Singleton
                    End If
                End SyncLock
            End If
            Return _Instance
        End Get
    End Property
 
End Class

2ème implémentation: le Singleton à initialisation tardive à l'aide de la classe Lazy(Of T) (Framework v4)

Code VB.Net :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
Public NotInheritable Class Singleton
 
    Private Shared ReadOnly _Instance As Lazy(Of Singleton)
 
    Private Sub New()
    End Sub
 
    Shared Sub New()
        _Instance = New Lazy(Of Singleton)(Function() New Singleton, True)
    End Sub
 
    Shared ReadOnly Property Instance As Singleton
        Get
            Return _Instance.Value
        End Get
    End Property
 
End Class

3ème implémentation: le Singleton a classe imbriquée

Code VB.Net :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
Public NotInheritable Class Singleton
 
    Shared ReadOnly Property Instance As Singleton
        Get
            Return Nested.Instance
        End Get
    End Property
 
    Private Class Nested
 
        Friend Shared ReadOnly Instance As New Singleton
 
        'Constructeur statique explicite pour que le type
        'ne soit pas marqué "beforefieldinit"
        Shared Sub New()
        End Sub
 
    End Class
 
End Class

En espérant que vous pourrez m'éclaircir tout cela , cordialement !

[Pol63]

la 1ère est thread safe et en effet classique

la 2ème je ne lui trouve aucun intérêt, la classe ne sera instanciée que lors du premier appel à singleton.instance ... mais la 1ère aussi ...

la 3ème je ne vois pas ce qu'elle apporte (il manque le private sub new)
et dans le pire des cas ce shared sub new sert juste à éviter une erreur d'exécution hypothétique

donc ne pas s'embeter, la 1ère est lisible et suffit

NB : le notinheritable n'est pas forcément nécessaire