Discussion :

[Xzander]

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 :

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

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 :

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

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 :

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

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.

[Thomas Lebrun]

Ben, c'est quoi la question


Pis, dans ce que tu as écrit, pourquoi ne pas passer par une simple énumération ?

[Xzander]

L'énumération ne permet pas simplement de mettre un bit à off ou on, il faut avoir recours aux opérations binaires.

Exemple

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
 
[Flags]
public enum Errors{
    SocketError = 1,
    CorruptedMessage = 2,
    UnknownError = 4,
}
 
private void Exemple(){
    Errors myErrors = Errors.SocketError & Errors.UnknownError;
    //Mettre un bit à on.
    myErrors |= Errors.CorruptedMessage;
    //Inverser un bit.
    myErrors ^= Errors.CorruptedMessage;
    //Mettre un bit à off.
    myErrors &= !Errors.CorruptedMEssage;
}

Le processeur doit effectuer plusieurs opérations simplement pour modifier un bit. Il serait plus simple de l'accéder directement pour lui affecter sa valeur. Moins d'opérations seraient en jeu et le code tournerait plus vite:

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
 
public flags Errors{
    SocketError,
    CorruptedMessage,
    UnknownError,
}
 
private void Exemple(){
    Errors myErrors = Errors.SocketError & Errors.UnknownError;
    //Mettre un bit à on.
    myErrors |= Errors.CorruptedMessage;
    myErrors.CorruptedMessage = true;
    //Inverser un bit.
    myErrors ^= Errors.CorruptedMessage;
    myErrors.CorruptedMessage = !myErrors.CorruptedMessage;
    //Mettre un bit à off.
    myErrors &= !Errors.CorruptedMessage;
    myErrors.CorruptedMessage = false;
}

En passant, ce n'est pas une question, ce sont juste deux idées que j'ai eues et dont je souhaite discuter.

[SaumonAgile]

Oui mais quel est l'intérêt ? Le langage est écrit comme ça, soit tu l'acceptes, soit tu utilises un autre langage.
Je ne comprends pas ce que tu attends...

[Xzander]

Je n'attends rien. Je ne compte pas modifier c# lol, mais peut-être envoyer la suggestion à Microsoft si après discussion, il s'avère que ça semble utile à plus d'une personne. Alors la question, c'est 'Comment trouvez-vous cette idée?' ou comme je l'ai dit vers la fin de mon premier message, 'Qu'en pensez-vous?'.

[SaumonAgile]

J'aime les enums comme elles sont

[Thomas Lebrun]

J'aime les enums comme elles sont

+1: pkoi se compliquer la vie alors que ce que l'on a fonctionne très bien

[Xzander]

Et le progrès dans tout ça? Je vous rappelle que la programmation séquentielle fonctionne très bien. Ce n'est pas en se disant "pkoi se compliquer la vie alors que ce que l'on a fonctionne très bien" que notre situation a évoluée vers la POO.

Oui les enums fonctionnent, et on peut travailler avec, moi je cherche des gens constructifs pour critiquer l'idée que j'ai lancée, pas pour me dire que ce que l'on a fonctionne.

Au fait je viens d'apporter un correctif à ce que j'avais écrit, j'avais oublié les valeurs de mes enums qui ont l'attribut [Flags]: elles doivent être des puissances de deux. Autre chose qui serait inutile de faire avec 'flags' au lieu de 'enum'.

Sois dit en passant, je ne propose pas un remplacement de enum par flags, mais un remplacement de '[Flags] enum' par 'flags', 'flags' étant un mot clé de C#.

[SaumonAgile]

Ce n'est pas parce qu'on n'est pas d'accord qu'on n'est pas constructif.
Personnellement je trouve ton idée d'accéder aux bits directement inutile et dangereuse.
Pour une enum déclarée dans une assembly externe, tu aurais la possibilité de modifier des bits dans la valeur sans connaitre les valeurs définies. Au moins avec les enum classiques, en utilisant les opérations avec des bits tu utilises généralement le libellé de l'enum et pas des 1, 2, 4, etc.

Le même problème se pose pour la maintenance, si tu commences à tomber sur du code où le développeur s'amuse à modifier directement les bits, tu es obligé d'aller dans la déclaration de l'enum pour trouver à quoi cela correspond... Bonjour le gain de temps et les parties de débogages endiablées...

[Xzander]

Au moins avec les enum classiques, en utilisant les opérations avec des bits tu utilises généralement le libellé de l'enum et pas des 1, 2, 4, etc.

Bon ça c'est ce que j'appelle un commentaire constructif. Je répondrais à cela en te disant de regarder davantage mon exemple plus haut.

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
public flags Errors{
    SocketError,
    CorruptedMessage,
    FatalError = SocketError | CorruptedMessage,
    UnknownError, 
}   
 
private void Exemple(){
    Errors myErrors = Errors.SocketError & Errors.UnknownError; 
 
    //Mettre un bit à on.  
    myErrors |= Errors.CorruptedMessage;
    myErrors.CorruptedMessage = true;
 
    //Inverser un bit.  
    myErrors ^= Errors.CorruptedMessage; 
    myErrors.CorruptedMessage = !myErrors.CorruptedMessage; 
 
    //Mettre un bit à off.  
    myErrors &= !Errors.CorruptedMessage;
    myErrors.CorruptedMessage = false;
 
    //Toutes les opérations peuvent aussi être effectuées sur des groupes de flags.
    myErrors.FatalError = false;
    myErrors.FatalError = true;
    myErrors.FatalError = !myErrors.FatalError;
}

Comme on le voit dans cet exemple d'utilisation, il n'y a pas un accès direct au bits et ce sont les libellés qui sont utilisés. Prenez l'exemple "myErrors.CorruptedMessage = false; ". Indirectement, tu as accès à un bit, ou s'il s'agit d'un ensemble de flags, tu as accès à un ensemble de flags comme une seule entité. L'idée, c'est de pouvoir affecter une valeur avoir à sortir les comparaisons binaires.

Voilà un résumé de ce que ferait 'flags':
1. Lors de la déclaration, les libellés ne peuvent pas être numérotés.
2. Lors de la déclaration, un libellé peut être déclaré comme étant une combinaison d'autres libellés.
3. Conservation des opérations binaires actuellement admises avec '[Flags] enum'.
4. Possibilité d'accéder à un flag comme s'il s'agissait d'un membre de façon à lui affecter un booléen.