Enumeration de String

Version imprimable

Bonjour tous le monde,
Je cherche à faire une énumération d'objet ou à minima une énumération de string qui fonctionne comme l'Enum de base mais avec des String, comme ceci :

Code:

1
2
3
     For Each Value As String In MonEnum
            Debug.Print (Value)          ===> Doit afficher : 'Ma valeur 1' puis 'Ma valeur 2'
        Next

Je dois pouvoir accéder aux valeur en utilisant directement le nom de l'énumération :

Code:

1
2
Debug.print MonEnum.Enum1                 ===> Doit afficher : 'Ma valeur 1'
....etc

Voic ce que j'ai commencé à faire mais ca ne fonctionne pas :aie: :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
  Class MonEnum
        ' Enumeration de String :
        Inherits List(Of MonEnum)
        Private Value As String
        'Public Shared ReadOnly List As New List(OfMonEnum)
        Public Shared ReadOnly Enum1 As MonEnum = New MonEnum("Ma valeur 1")
        Public Shared ReadOnly Enum2 As MonEnum = New MonEnum("Ma valeur 2")
 
        Private Sub New(Value As String)
            Me.Value = Value
            Me.Add(New MonEnum(Value))
        End Sub
    End Class

22/08/2016, 11h48
François DORIN
Bonjour,

Déclarer tes valeurs en Public Shared ReadOnly est une très bonne idée pour pouvoir accéder à tes valeurs via MonEnum.Enum1.

Il te reste à pouvoir les parcourir. Pour cela, je ferais un tableau Values en Shared ReadOnly, qui contiendrait toutes les valeurs que tu auras définies. Tu pourras ainsi accéder à ton tableau via MonEnum.Values par exemple. Je sais, ce n'est pas comme une véritable énumération, mais je pense que c'est ce que tu peux faire et qui s'y rapprochera le plus. Ainsi, le parcours des valeurs se ferait ainsi :
Code:

1 2 3 For Each Value As String In MonEnum.Values Debug.Print (Value) ===> Doit afficher : 'Ma valeur 1' puis 'Ma valeur 2' Next

Si le but c'est "juste" d'avoir un conteneur avec des "constantes nommées" c'est à dire que lors de l'accès à FakeEnum.Item1 ce qui nous intéresse c'est uniquement la "valeur textuelle" autant directement faire une classe avec des constantes nommées :)
En ce qui concerne l'énumération ; je ne vois aucunement solution en utilisant juste le nom de la classe et comme l'a dit dorinf il faut une méthode (ou une propriété à la rigueur) pour y accéder un GetValues par exemple pour calquer le nom sur Enum.GetValues ce qui pourrait donner
Code:

1 2 3 4 5 6 7 8 9 10 11 12 Public NotInheritable Class FakeEnum Public Const Item1 As String = "Value 1" Public Const Item2 As String = "Value 2" Private Sub New() End Sub Public Shared Iterator Function GetValues() As IEnumerable(Of String) Yield Item1 Yield Item2 End Function End Class
Après s'il faut vraiment que ce qui est récupéré soit un objet, suffit juste de changer les Const en Shared ReadOnly (Property comme ça si un jour on doit rajouter du code dessus ça sera pas un breaking change) et surcharger ToString pour l'affichage
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 Public NotInheritable Class FakeEnum Private ReadOnly content As String Public Shared ReadOnly Property Item1 As New FakeEnum("Value 1") Public Shared ReadOnly Property Item2 As New FakeEnum("Value 2") Private Sub New(content As String) Me.content = content End Sub Public Shared Iterator Function GetValues() As IEnumerable(Of FakeEnum) Yield Value1 Yield Value2 End Function Public Overrides Function ToString() As String Return content End Function End Class

Merci beaucoup pour vos conseils, j'ai utilisé la méthode de dorinf pour l'instant, je verrais à l'usage les avantages des différentes solutions.
J'ai ajouté une méthode d’extension pour faciliter l'ajout d’éléments dans le tableau.
Voici ce que ça donne : (j'ai pas testé mais je pense que ça devrait faire l'affaire ;) )

Code:

1
2
3
4
5
6
7
Public Module ArrayExtensions
    <Extension()> _
    Public Sub Add(Of T)(ByRef arr As T(), item As T)
        Array.Resize(arr, arr.Length + 1)
        arr(arr.Length - 1) = item
    End Sub
End Module

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 Class MonEnum
        ' Enumeration de String :
        Private Value As String
        Public Shared ReadOnly Values() As String
        Public Shared ReadOnly Enum1 As MonEnum = New MonEnum("Ma valeur 1")
        Public Shared ReadOnly Enum2 As MonEnum = New MonEnum("Ma valeur 2")
 
        Private Sub New(Value As String)
              Me.Value = Value
              Values.Add(Value)
        Public Overrides Function ToString() As String
            Return Me.Value
        End Function
        End Sub
 
End Class

EDIT : je garde la variable Privé Value finalement.

22/08/2016, 13h54
Sehnsucht

La "solution" de dorinf et la "mienne" sont en gros identiques ; par contre ce que je pige pas trop c'est le principe d'une "enum" (donc un jeu fixe de valeurs) à laquelle on peut ajouter des valeurs ; c'est un peu contradictoire :koi:
Je pige pas trop non plus le coup de la méthode Add ; tu connais le nombre d'éléments autant directement faire un tableau de la bonne taille plutôt que des Add ou le Array.Resize va à chaque fois copier tout le tableau pour juste ajouter un élément
22/08/2016, 14h07
BasicZX81

Ouaippp ,je comprends les questionnements :aie:....J'ai toujours appris tout seul la programmation depuis l'époque des premières machine en Basic donc j'ai surement pris des habitudes bonnes ou mauvaises...
Quoi qu'il en soit j'évite au maximum de coder des trucs en dures en général, le code doit pouvoir s'adapter de lui-même...Même si c'est plus de travail au final c'est plus facile de modifier/faire évoluer le code et éviter des erreurs par qu'on a oublier de redimensionner un tableau suite à l'ajout d'un nouvelle élément par exemple ;).
22/08/2016, 14h35
BasicZX81
Bon apriori il faut que je trouve une autre solution :

Citation:

Une exception de type 'System.TypeInitializationException' s'est produite dans AC Tools.exe mais n'a pas été gérée dans le code utilisateur

L'erreur se produit lorsque je tente d'initialiser une variable dans une autre classe :
Code:

1 2 3 4 5 6 Public NotInheritable Class Options Private Sub New() End Sub Private Shared _MonEnum As MonEnum = MonEnum.Enum1 ===> Erreur sur cette ligne. ..... End Class
22/08/2016, 14h37
François DORIN

Erreur classique qui se produit lorsque tu as une exception dans le constructeur Shared d'une classe.

Ici, je pense que le problème vient du redimensionnement d'un tableau non initialisé ;)
22/08/2016, 16h22
BasicZX81

En effet Dorinf, le problème vient de l'initialisation du tableau Values().
Par contre j'ai un autre problème je n'arrive pas à remplir le tableau Values qui est pourtant partagé grâce à Shared donc ce n'est pas un problème d'instance je pense.
De plus j'utilise Byref pour ajouter mes valeurs mais au retour de la procédure Add, Values() est vide:?. Une idée ?

Bon c'est OK, c’était laborieux mais j'ai fini par y arriver. Merci à vous ;)

Code:

1
2
3
4
5
6
7
8
9
10
11
Public Module ArrayExtensions
    <Extension()> _
    Public Sub Add(Of T)(ByRef arr As T(), item As T)
     If arr Is Nothing Then
            ReDim arr(0)
        Else
            ReDim Preserve arr(arr.Length)
        End If
        arr(arr.Length - 1) = item
    End Sub
End Module

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 Class MonEnum
        ' Enumeration de String :
        Private _Value As String
        Private Shared _Values() As String
        Public Shared ReadOnly Enum1 As MonEnum = New MonEnum("Ma valeur 1")
        Public Shared ReadOnly Enum2 As MonEnum = New MonEnum("Ma valeur 2")
 
        Private Sub New(Value As String)
              Me._Value = Value
              Values.Add(Value)
        Public Shared ReadOnly Property Values As String()
            Get
                Return _Values
            End Get
        End Property
        Public Overrides Function ToString() As String
            Return Me._Value
        End Function
        End Sub
 
End Class

22/08/2016, 17h36
Sehnsucht

T'es sûr que ça fonctionne :koi: parce Array.Resize ou Redim Preserve c'est basiquement la même chose et en testant ton code (pour être sûr de mon impression) si je récupère MonEnum.Values j'obtiens Nothing à ce compte là ça serait quand même vachement plus simple d'utiliser un List(Of String) en interne et exposer ce qu'on veut après : tableau, IEnumerable, IList, IReadOnlyList

Note au passage t'as une boulette dans ton code le constructeur a son End Sub qui a décidé de migrer après le reste (ligne 19 au lieu de ligne 11) ;)

J'ai trouvé autre chose finalement ;)

Code:

1
2
3
4
5
6
 
Imports System.ComponentModel
Public Enum MonEnum
    <Description("Description de Enum1")> Enum1 ' if you want a numeric value : = 0
    <Description("Description de Enum2")> Enum2
End Enum

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
Public Class EnumAttributs
    ''This procedure gets the <Description> attribute of an enum constant, if any.
    ''Otherwise it gets the string name of the enum member.
    Public Shared Function EnumDescription(ByVal EnumConstant As [Enum]) As String
        Dim field As FieldInfo = EnumConstant.GetType().GetField(EnumConstant.ToString())
        Return EnumDescription(field)
    End Function
    Public Shared Function EnumDescription(Of T)(ByVal FieldName As String) As String
        Dim field As FieldInfo = GetField(Of T)(FieldName)
        Return EnumDescription(field)
    End Function
    Public Shared Function EnumDescription(ByVal Field As FieldInfo) As String
        Dim aattr() As DescriptionAttribute = DirectCast(Field.GetCustomAttributes(GetType(DescriptionAttribute), False), DescriptionAttribute())
        If aattr.Length > 0 Then
            Return aattr(0).Description
        Else
            Return Field.Name
        End If
    End Function
    Private Shared Function GetField(Of T)(StringEnum As String) As FieldInfo
        Dim Type As Type = GetType(T)
        Dim fields As FieldInfo() = Type.GetFields
        For Each Field As FieldInfo In fields
            If Field.Name = StringEnum Then Return Field
        Next
        Return Nothing
    End Function
    Public Shared Function GetFields(Of T)() As FieldInfo()
        Dim fields As FieldInfo() = GetType(T).GetFields
        Return fields
    End Function
    Public Shared Function GetValues(Of T)() As Array
        Return [Enum].GetValues(GetType(T))
    End Function
    Public Shared Function GetNames(Of T)() As String()
        Return [Enum].GetNames(GetType(T))
    End Function
End Class

Merci à vous.