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