Discussion :

[jimbolelephan]

Bonjour,

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

Code Delphi :

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

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 Delphi :

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

1
2
3
   kUnselectedStates   = [mtType1];
   kSelectedStates     = [mtType1, mtType2];
   kActivatedStates    = [mtType2, mtType3];

merci.

[jimbolelephan]

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


Je crois que je dois utiliser ENUM

Code :

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

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 :

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

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 :

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

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.?

[tomlev]

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 C# :

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

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 :

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

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 :

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

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...

[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.

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?

[jimbolelephan]

Voila, j'ai compris :

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

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
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.

[tomlev]

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).

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 :

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

1
2
3
4
public enum UIState : long
{
    ...
}

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 :

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
        [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