Suggestion pour les flags en C#
Bonjour,
Lorsqu'on veut manipuler des flags, nous avons deux choix:
Utiliser une énumération avec l'attribut [Flags] ou utiliser une structure.
Avantages d'une énumération [Flags]:
- Permet les comparaisons binaires.
Désavantages d'une énumération [Flags]:
- Opérations binaires nécessaires pour modifier un bit.
Avantages d'une structure:
- Modification d'un bit facile.
Désavantages d'une structure:
- Pas d'opérateurs binaires pour comparer la structure en entier.
On pourrait envisager d'ajouter l'opérateur [] à un nombre de sorte que l'on puisse accéder à ses bits directement. Ainsi, nous aurions:
Code:
1
2
| int i = 1024;
i[9] = false; |
Nous pourrions donc déclarer une énumération allant de 0 à 31 permettant de manipuler jusqu'à 31 flags.
Toutefois, nous nous retrouvons à devoir utiliser une énumération et un entier conjointement.
Cette proposition reste une idée, mais inefficace pour les flags.
La deuxième solution consisterait en une combinaison des forces de toutes ces idées:
Code:
1
2
3
4
5
| public flags ErrorFlags{
MessageCorrupted,
SocketError,
UnknownError,
} |
C'est une déclaration semblable à une énumération. Toutefois, voici ce que flags nous permettrait:
-Comparaisons binaires de l'ensemble complet.
-Accès à un bit particulier.
Code:
1
2
3
4
5
6
7
8
9
10
11
|
public void myFunc(){
//Initialisation comme une énumération avec l'attribut [Flags]
ErrorFlags myflags = ErrorFlags.MessageCorrupted | ErrorFlags.SocketError;
//Comparaisons binaires de l'ensemble
if(myflags == (ErrorFlags.MessageCorrupted & ErrorFlags.UnknownError)){
//Accès à un bit particulier.
myflags.UnknownError = false;
}
} |
Simple, élégant, que pensez-vous de cela?
-Ajouter l'opérateur [] sur les int. (pas pour les flags mais pourraît être utile)
-Créer l'équivalent de mon 'flags' dans l'exemple, qui ressemble à un enum ave c l'accès aux bits particuliers.
