Bonjour à tous,

J'ai un ensemble de types qui obéissent au schéma suivant :
- une classe définissant le type à proprement parler
- une classe « wrapper » offrant une interface en lecture seule pour un objet dudit type
- une structure définissant les propriétés du type

Par exemple, pour un type Company, on a les 3 classes suivantes :

Company
Code : 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 Class Company
    Private _properties As CompanyPropertySet
 
    Public Sub New(ByVal properties As CompanyPropertySet)
        Me.properties = properties
    End Sub
 
    Public Property properties As CompanyPropertySet
        Get
            Return _properties
        End Get
        Set(ByVal value As CompanyPropertySet)
            'code garantissant les invariants de la classe
            '...
 
            _properties = value
        End Set
    End Property
End Class
CompanyConstWrapper
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
Public Class CompanyConstWrapper
    Private _company As Company
 
    Public Sub New(ByRef company As Company)
        _company = company
    End Sub
 
    Public ReadOnly Property properties As CompanyPropertySet
        Get
            Return _company.properties
        End Get
    End Property
End Class
CompanyPropertySet
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
Public Structure CompanyPropertySet
    Public id As UInteger
    Public reference As String
    Public name As String
End Structure
Étant donné que ce schéma est extrêmement redondant, j'aimerais naturellement le factoriser.
J'aimerais pour ce faire créer un type générique ConstWrapper(Of …), pour ne pas avoir à réécrire une classe XxxConstWrapper pour chaque type de ce genre.
Ce type générique ressemblerait à cela (ce code ne compile pas) :
Code : 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
Public Interface IConstWrappable(Of PropertySet)
    ReadOnly Property properties As PropertySet
End Interface
 
Public Class ConstWrapper(Of T As IConstWrappable(Of T.PropertySet))
    Private _obj As T
 
    Public Sub New(ByRef obj As T)
        _obj = obj
    End Sub
 
    Public ReadOnly Property properties As T.PropertySet
        Get
            Return _obj.properties
        End Get
    End Property
End Class
Ma question est la suivante : comment faire pour déterminer CompanyPropertySet (T.PropertySet dans le pseudocode du generic) à partir de Company (T dans le pseudocode du generic) ?
J'aimerais pouvoir utiliser mon type générique comme ceci :
Code : Sélectionner tout - Visualiser dans une fenêtre à part
Dim constCompany as ConstWrapper(Of Company)
sachant que ConstWrapper doit bien entendu pouvoir être configuré avec d'autres types (Employee, Contract, etc.).

Merci !