Créer un "Set of" de delphi: en C#

Bonjour,

quelqu'un pourrait m'aider à convertir cette déclaration Delphi en CSharp s.v.p.

Code:

---

1 2 3

Type MonType = (mtType1, mtType2, mtType3); MesTypes = Set of MonType;

---

je cherche aussi à convertir ceci qui sont en fait des constantes en delphi :

Code:

---

1 2 3

kUnselectedStates = [mtType1]; kSelectedStates = [mtType1, mtType2]; kActivatedStates = [mtType2, mtType3];

---

merci.

Moi qui vient du monde de Delphi Win32, je trouve solide de convertir un composant.


Je crois que je dois utiliser ENUM

Code:

---

1 2 3 4 5 6 7 8 9 10

enum eUIState { /* Null */ None, /* Selection */ Unselected, Selected, SelectActivated, Activated, /* Moving */ Moving, /* Sizing */ SizingWE, SizingNS, SizingNWSE, SizingNESW }

---

ensuite, je dois me créer des constante regroupant certain status

exemple :

Code:

---

1 2 3 4 5

kUnselectedStates = [uisUnselected]; kSelectedStates = [uisSelected, uisSelectActivated]; kActivatedStates = [uisActivated, uisSelectActivated]; kNotActivatedStates = [uisUnselected, uisSelected]; kSelectionStates = [uisUnselected, uisSelected, uisSelectActivated, uisActivated];

---

Ainsi, dans mon code .net, je désire pouvoir vérifier si mon statut est parmit kSelectedStates.

Exemple en delphi :

Code:

---

1 2	if ( MonStatut in kSelectedStates ) then // le status est bon;

---

Je ne suis pas certain si .net fait exactement le même genre de déclaration.
C'est ce que je cherche à savoir.

Quelqu'un peut m'aider s.v.p.?

Tu peux faire un enum dont on peut combiner les valeurs en utilisant FlagsAttribute. Ca donne aux éléments de l'enum des valeurs dont un seul bit est à 1, ce qui permet de les combiner avec des OU binaires :

Code:

---

1 2 3 4 5 6 7 8 9 10 11

[Flags] enum eUIState { /* Null */ None = 0, // pour t'assurer qu'il n'y a aucun bit à 1 /* Selection */ Unselected, Selected, SelectActivated, Activated, /* Moving */ Moving, /* Sizing */ SizingWE, SizingNS, SizingNWSE, SizingNESW }

---

Pour combiner les valeurs, tu peux faire :

Code:

---

eUIState kSelectionStates = eUIState.uisUnselected | eUIState.uisSelected | eUIState.uisSelectActivated | eUIState.uisActivated;

---

Après, pour tester si un état donné est dans kSelectionStates, tu utilises le ET binaire :

Code:

---

1 2 3 4

if ((MonStatut & kSelectionStates) != eUIState.None) { // le status est bon; }

---

Par contre je connais pas delphi, donc je suis pas sûr que ce soit tout à fait équivalent d'un point de vue sémantique...

Donc, si je comprends bien, si je défini en numéro mes statut, j'ai donc 32 choix possible (int a 4 octets).

Est-ce bien cela?

Puis-je en ajouter 85 status? Je sais je sais, c'est trop mais je veux être certain de bien comprendre car pour moi la comparaison binaire limite au nombre de bits composés dans un type.

en plus, j'ai remarqué que je dois déclarer cela comme variable (donc à l'intérieur d'un classe).

Je voudrais simplement avoir une constante non modifiable.
Est-ce possible de faire un readonly?

Voila, j'ai compris :

je me suis inspiré du code de tomlev et de mes méninges suite à mon auto-formation ;)

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

public class UIStates { public enum UIState { /* Null */ None = 0, /* Selection */ Unselected = 1, Selected = 2, SelectActivated = 4, Activated = 8, /* Moving */ Moving = 16, /* Sizing */ SizingWE = 32, SizingNS = 64, SizingNWSE = 128, SizingNESW = 256 }   // Use the binary comparison to know if the status is in the offset. // Example : if ((VarState & UIStates.SelectionStates) != 0) public readonly static UIState SelectedStates = UIState.Selected | UIState.SelectActivated;   public readonly static UIState ActivatedStates = UIState.Activated | UIState.SelectActivated;   public readonly static UIState NotActivatedStates = UIState.Unselected | UIState.Selected;   public readonly static UIState SelectionStates = UIState.Unselected | UIState.Selected | UIState.SelectActivated | UIState.Activated; }

---

Si quelqu'un a mieux je suis preneur car je cherche la meilleur solution.

Si tu effectues des combinaisons sur les états, il faut que tu mettes l'attribut Flags sur ton enum (cf. mon post précédent, et MSDN).

Citation:

---

Envoyé par jimbolelephan

Donc, si je comprends bien, si je défini en numéro mes statut, j'ai donc 32 choix possible (int a 4 octets).

Est-ce bien cela?

Puis-je en ajouter 85 status? Je sais je sais, c'est trop mais je veux être certain de bien comprendre car pour moi la comparaison binaire limite au nombre de bits composés dans un type.

---

Tu peux aller jusqu'à 64 valeurs si tu fais hériter ton enum de long (par défaut c'est int) :

Code:

---

1 2 3 4

public enum UIState : long { ... }

---

Citation:

---

Envoyé par jimbolelephan

en plus, j'ai remarqué que je dois déclarer cela comme variable (donc à l'intérieur d'un classe).

Je voudrais simplement avoir une constante non modifiable.
Est-ce possible de faire un readonly?

---

Ben tu pourrais très bien les déclarer comme constantes (const) ... Mais de toutes façons, pour les combinaisons de plusieurs flags, tu peux (et tu devrais) aussi les définir dans l'enum. Au final, tu peux faire quelque chose comme ça :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

[Flags] public enum UIState { /* Null */ None = 0, /* Selection */ Unselected = 1, Selected = 2, SelectActivated = 4, Activated = 8, /* Moving */ Moving = 16, /* Sizing */ SizingWE = 32, SizingNS = 64, SizingNWSE = 128, SizingNESW = 256, /* Combinations */ SelectedStates = Selected | SelectActivated, ActivatedStates = Activated | SelectActivated, NotActivatedStates = Unselected | Selected, SelectionStates = Unselected | Selected | SelectActivated | Activated }

---

Ce qui est quand même un peu plus propre que l'enum englobé dans une classe...

Autres lectures utiles sur les énumérations et les flags :
Conception d'énumérations
Conception d'énumérations d'indicateurs

wowowo, j'étais dans le large avec ma solution....elle fonctionnait quand même.

Merci pour l'optimisation.
ça marche.

Petite question :

Comme je parle à un connaisseur, j'en profite ....

puis-je empêcher le programmeur d'affecter SelectedStates, ActivatedStates, NotActivatedStates et SelectionStates à la variable.

Je voudrais que ces valeurs servent à la comparaison.

Non, tu ne peux pas l'empêcher
En fait, tu ne peux même pas empêcher de mettre des valeurs qui ne sont pas définies dans l'enum, par exemple je pourrais faire :

Code:

---

UIState state = (UIState)12345;

---

Ok, donc j'ai la un problème majeur.
Je ne peu laisser aucune marge de maneuvre pour ce statut sinon, le composant se comportera dans des effets non contrôlés.

Est-qu'il y a un type qui limite aux types définis? même si c'est plus compliqué à coder?

pas à ma connaissance

Juste un truc en passant : l'attribut Flags a du sens pour une enum lorsque ses valeurs peuvent se combiner. Là, elles s'excluent mutuellement : on peut pas être à la fois Selected et Unselected...

Donc, le fameux Set Of que tu veux, ce n'est pas qu'une simple collection en fait ?

Code:

---

1 2 3 4 5 6 7 8

List<UiState> liste = new List<UiState>(); // ou un HashSet si tu es en .Net 3 liste.Add(UiState.Selected); liste.Add(UiState.Unselected);   if liste.Contains(MonStatut) { // le status est bon; }

---

je note merci beaucoup.