Eviter doublons de valeurs d'une variable de structure dans une classe

Version imprimable

Bonjour,
Bon je crois que mon titre n'est vraiment pas explicite, mais là je ne savais vraiment pas comment résumer ça :oops: (ouvert à toute suggestion de modification bien entendu)

Voici mon problème :

J'ai d'une part une classe :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 Public Class TTypesJeux Public Structure TypeJeu Dim Name As String Dim Mains() As String Dim TDefault As Boolean End Structure Public Types() As TypeJeu End Class
Puis dans une Form le code suivant :
Code:

1 2 3 4 Public MesTypesJeux As New TTypesJeux ReDim MesTypesJeux.Types(3) '... attibution de valeurs ...
je souhaiterais que lorsque je fais ceci (par exemple) :
Code:

1 2 MesTypesJeux.Types(0).TDefault = True
Que tous les autres TDefault de la collection passent à False (Types(1).TDefault , Types(2).TDefault ...). En bref, un seul doit avoir sa propriété TDefault à True.

Or je ne sais ni ou ni comment intégrer cette vérification dans ma classe ou dans ma structure :oops:

Est-il possible d'intégrer une procédure/fonction à la structure qui vérifie tous les objets de ma collection ?

Merci pour toute aide

Bonjour,

Essaie ça:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
    Public Class TTypesJeux
 
        Public Structure TypeJeu
            Dim Name As String
            Dim Mains() As String
            Dim TDefault As Boolean
        End Structure
 
        Public Types() As TypeJeu
 
        Public WriteOnly Property TDefaults
            Set(value)
                For Each t As TypeJeu In Types
                    t.TDefault = value
                Next
            End Set
        End Property
 
    End Class

Salut
peut etre ainsi

Code:

1
2
3
4
5
6
7
8
9
Private Sub initjeu(ByVal n As Integer)
        For iter = 0 To MesTypesJeux.Types.Length - 1
            If iter = n Then
                MesTypesJeux.Types(iter).TDefault = True
            Else
                MesTypesJeux.Types(iter).TDefault = False
            End If
        Next
    End Sub

12/04/2012, 07h57
avigeilpro

Tout d'abord merci pour vos réponse,
Malheureusement cela ne convient pas :(
-N4w4k- le code que tu m'as proposé fait que tous les TDefault ont la même valeurs.

shayw je souhaite intégrer cette "fonctionnalité" à ma classe et non pas dans mon Form. De la même façon que, pour un radiobutton, lorsque l'on passe la propriété Checked d'un radiobutton a True, tous les autres du groupe passent automatiquement à False.
12/04/2012, 08h30
Pol63

si le but est de savoir qu'un seul est marqué comme ca, plutot que d'avoir un booléen par instance avec true dans celui qui est marqué, tu peux avoir un variable shared as TypeJeu qui contient celui qui est marqué

sinon les structures, et les tableaux avec redim il faut éviter
le mieux est une classe et une collection

Salut

pourquoi pas initialiser avec le constructor
aussi le fait d'écrire redim dans ta form c'est plutot dans ta class

ex

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
  Public Class ClassTTypesJeux
    Public Structure TypeJeu
        Dim Name As String
        Dim Mains() As String
        Dim TDefault As Boolean
    End Structure
 
    Public Types() As TypeJeu
    Private Sub initjeu(ByVal n As Integer)
        For iter = 0 To Types.Length - 1
            If iter = n Then
                Types(iter).TDefault = True
            Else
                Types(iter).TDefault = False
            End If
        Next
    End Sub
 
    Public Sub New(ByVal taille As Int32, ByVal defaut As Int32)
        ReDim Types(taille)
        initjeu(defaut)
    End Sub
End Class

dans ta form

Code:

1
2
Dim ttt As ClassTTypesJeux
        ttt = New ClassTTypesJeux(3, 0)

12/04/2012, 08h40
avigeilpro

Alors, j'ai transformé ma Structure en class.
Que veux-tu dire par "collection" ?

Sinon je pense avoir trouvé une solution, peut-être pas la plus jolie mais elle a l'air de fonctionner :
Dans le property set, je déclenche un évènement, intercepté par la classe TTypesJeux qui lance une procédure de vérification.

Bonjour,

Tu peux te faire ta propre List en utilisant l'interface IList .
et dans la fonction "public object this[int index]" :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
  public object this[int index]
        {
            get
            {
                return _contents[index];
            }
            set
        {
            _contents[index] = (TypeJeu)value;
            foreach(TypeJeu ty in _contents)
            {
                if (!ty.Equals((TypeJeu)value))
                {
                    ty.TDefault = !((TypeJeu)value).TDefault;
                }
            }
        }
        }

Soit le code complet , quelque chose comme çà :

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
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
 
 public class TTypesJeux
    {
 
        private MyList _types;       
 
        public MyList Types 
        {
            get{return _types;}
            set{_types=value;}
        }
    }
 
 
    public class TypeJeu
    {
       public string  Name ;
       public string[] Mains;
       public bool TDefault;
    }
 
    public class MyList : IList
    {
        private TypeJeu[] _contents = new TypeJeu[10];
        private int _count;
 
        public MyList()
        {
            _count = 0;
        }
 
        // IList Members
        public int Add(object value)
        {
            if (_count < _contents.Length)
            {
                _contents[_count] = (TypeJeu)value;
                _count++;
 
                return (_count - 1);
            }
            else
            {
                return -1;
            }
        }
 
        public void Clear()
        {
            _count = 0;
        }
 
        public bool Contains(object value)
        {
            bool inList = false;
            for (int i = 0; i < Count; i++)
            {
                if (_contents[i].Equals((TypeJeu)value))
                {
                    inList = true;
                    break;
                }
            }
            return inList;
        }
 
        public int IndexOf(object value)
        {
            int itemIndex = -1;
            for (int i = 0; i < Count; i++)
            {
                if (_contents[i].Equals((TypeJeu)value))
                {
                    itemIndex = i;
                    break;
                }
            }
            return itemIndex;
        }
 
        public void Insert(int index, object value)
        {
            if ((_count + 1 <= _contents.Length) && (index < Count) && (index >= 0))
            {
                _count++;
 
                for (int i = Count - 1; i > index; i--)
                {
                    _contents[i] = _contents[i - 1];
                }
                _contents[index] = (TypeJeu)value;
            }
        }
 
        public bool IsFixedSize
        {
            get
            {
                return true;
            }
        }
 
        public bool IsReadOnly
        {
            get
            {
                return false;
            }
        }
 
        public void Remove(object value)
        {
            RemoveAt(IndexOf(value));
        }
 
        public void RemoveAt(int index)
        {
            if ((index >= 0) && (index < Count))
            {
                for (int i = index; i < Count - 1; i++)
                {
                    _contents[i] = _contents[i + 1];
                }
                _count--;
            }
        }
 
        public object this[int index]
        {
            get
            {
                return _contents[index];
            }
            set
        {
            _contents[index] = (TypeJeu)value;
            foreach(TypeJeu ty in _contents)
            {
                if (!ty.Equals((TypeJeu)value))
                {
                    ty.TDefault = !((TypeJeu)value).TDefault;
                }
            }
        }
        }
 
        // ICollection Members
 
        public void CopyTo(Array array, int index)
        {
            int j = index;
            for (int i = 0; i < Count; i++)
            {
                array.SetValue(_contents[i], j);
                j++;
            }
        }
 
        public int Count
        {
            get
            {
                return _count;
            }
        }
 
        public bool IsSynchronized
        {
            get
            {
                return false;
            }
        }
 
        // Return the current instance since the underlying store is not
        // publicly available.
        public object SyncRoot
        {
            get
            {
                return this;
            }
        }
 
        // IEnumerable Members
 
        public IEnumerator GetEnumerator()
        {
            // Refer to the IEnumerator documentation for an example of
            // implementing an enumerator.
            throw new Exception("The method or operation is not implemented.");
        }
 
        public void PrintContents()
        {
            Console.WriteLine("List has a capacity of {0} and currently has {1} elements.", _contents.Length, _count);
            Console.Write("List contents:");
            for (int i = 0; i < Count; i++)
            {
                Console.Write(" {0}", _contents[i]);
            }
            Console.WriteLine();
        }
    }

Non testé :roll:

dkmix ça m'a l'air bien compliqué, de plus je ne connais pour ainsi dire rien au C :(

shayw la propriété TDefault peux changer après construction, je cherche vraiment à avoir le même fonctionnement que des RadioButton, par annalogie le groupe de radiobutton serait ma classe TTypesJeux, chaque radiobutton un Typejeu, et la propriété checked ma propriété TDefault.

Pour le redim je l'ai déjà dans ma classe, je l'avais mis dans le Form dans mon premier post pour facilité la compréhension de ma demande. Dans ma classe j'ai des procédure pour ajouter/retirer des types.
Je reste pour le moment sur ma solution, je la donne ci-dessous (simplifiée) :

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
39
40
41
42
43
44
45
46
47
48
49
50
51
 
    Public Class TTypesJeux
 
        Public Class TypeJeu
            Public Name As String
            Public Mains() As String
            Private _TDefault As Boolean
            Public Property TDefault As Boolean
                Set(value As Boolean)
                    _TDefault = value
                    If value Then
                        RaiseEvent DefaultChecked(Name)
                    End If
                End Set
                Get
                    Return _TDefault
                End Get
            End Property
            Public Event DefaultChecked(ByVal Name As String)
        End Class
 
        Public Types() As TypeJeu
 
        Private Sub DefaultCheck(Name As String)
            For Each t As TypeJeu In Types
                If t.Name <> Name Then
                    'évite la redondance de raiseevent
                    RemoveHandler t.DefaultChecked, AddressOf DefaultCheck
 
                    t.TDefault = False
 
                    AddHandler t.DefaultChecked, AddressOf DefaultCheck
                End If
            Next
        End Sub
 
        Public Function CreateNewType(Name As String) As Integer
            Dim NewId As Integer
            If Types IsNot Nothing Then
                NewId = UBound(Types) + 1
            Else
                NewId = 0
            End If
            ReDim Preserve Types(NewId)
            Types(NewId) = New TypeJeu
            Types(NewId).Name = Name
            AddHandler Types(NewId).DefaultChecked, AddressOf DefaultCheck
 
            Return NewId
        End Function
    End Class

Puis dans mon Form :

Code:

1
2
3
4
5
6
7
8
9
 
Public MesTypesJeux As New TTypesJeux
Dim Id As Integer
 
Id = MesTypesJeux.CreateNewType("NomDuType1")
Id = MesTypesJeux.CreateNewType("NomDuType2")
Id = MesTypesJeux.CreateNewType("NomDuType3")
 
MesTypesJeux.Types(1).TDefault = True

Lors de l'affectation de True à TDefault, l'event DefaultChecked est appelé, celui-ci est pointé sur la procédure DefaultCheck par ma classe TTypesJeux qui vérifie tous les objets de Types() si il n'ont pas leur TDefault à True (sauf celui qui à été changé bien entendu) avec un RemoveHandler pour éviter de rentrer dans des boucles sans fin.

12/04/2012, 14h02
dkmix

C# to VB

;)