Comprendre l'Enum Set Flag du C# : Attribution de drapeaux

Tim Corey

9m 57s

Lorsque nous travaillons avec des autorisations, des configurations ou des paramètres en C#, nous rencontrons souvent des situations où plusieurs valeurs doivent être stockées dans une seule variable. Au lieu d'utiliser des valeurs booléennes distinctes pour chaque paramètre, nous pouvons utiliser des Flag Enums. Cette méthode s'appuie sur des opérations binaires pour gérer efficacement plusieurs options au sein d'une seule valeur entière.

Dans cet article, nous allons approfondir la manière de définir des Flag Enums en C# en nous basant sur la vidéo de Tim Corey, Binary in C# : Assigning Flags in 10 Minutes or Less. Tim explique comment attribuer plusieurs valeurs à l'aide d'opérations binaires, ce qui rend notre code plus efficace et plus lisible. Plongeons-nous dedans.

Introduction aux Flag Enums

Tim commence par expliquer que cette leçon fait partie d'une série sur la compréhension du binaire en C#. Dans cette vidéo, il explique comment attribuer des drapeaux à l'aide d'opérations binaires. Les drapeaux nous permettent de stocker plusieurs valeurs dans un seul nombre entier, ce qui rend la gestion des autorisations beaucoup plus simple et efficace.

Assignation de drapeaux multiples à l'aide de Bitwise OR

Tim montre comment nous pouvons combiner plusieurs autorisations à l'aide de l'opérateur bitwise OR (|). Il crée une énumération SystemPermissions qui inclut différents niveaux de permission tels que SQL, Redis et BuildSystem. Au lieu d'utiliser plusieurs variables, nous pouvons stocker toutes les autorisations dans une seule valeur.

Exemple d'attribution de permissions multiples à une variable :

// Assume that SystemPermissions is an enum with values SQL, Redis, and BuildSystem
SystemPermissions TimPermissions = SystemPermissions.SQL | SystemPermissions.Redis;

// Print the current permissions - it will include both SQL and Redis
Console.WriteLine(TimPermissions);

// Assume that SystemPermissions is an enum with values SQL, Redis, and BuildSystem
SystemPermissions TimPermissions = SystemPermissions.SQL | SystemPermissions.Redis;

// Print the current permissions - it will include both SQL and Redis
Console.WriteLine(TimPermissions);

' Assume that SystemPermissions is an enum with values SQL, Redis, and BuildSystem
Dim TimPermissions As SystemPermissions = SystemPermissions.SQL Or SystemPermissions.Redis

' Print the current permissions - it will include both SQL and Redis
Console.WriteLine(TimPermissions)

' Assume that SystemPermissions is an enum with values SQL, Redis, and BuildSystem
Dim TimPermissions As SystemPermissions = SystemPermissions.SQL Or SystemPermissions.Redis

' Print the current permissions - it will include both SQL and Redis
Console.WriteLine(TimPermissions)

Affichage de la représentation binaire

Pour mieux comprendre ce qui se passe, Tim suggère de convertir la valeur entière en sa forme binaire en utilisant Convert.ToString(value, 2). Cela nous permet de visualiser quels bits sont activés :

// Convert the permissions to a binary string to see the set bits
Console.WriteLine(Convert.ToString((int)TimPermissions, 2));

// Convert the permissions to a binary string to see the set bits
Console.WriteLine(Convert.ToString((int)TimPermissions, 2));

' Convert the permissions to a binary string to see the set bits
Console.WriteLine(Convert.ToString(CInt(TimPermissions), 2))

' Convert the permissions to a binary string to see the set bits
Console.WriteLine(Convert.ToString(CInt(TimPermissions), 2))

Cela montre que différentes positions de bits correspondent à différentes permissions, ce qui montre comment nous pouvons stocker plusieurs paramètres dans un seul nombre entier.

Ajouter plus de permissions en utilisant OR-Equals

Tim explique que nous pouvons ajouter des permissions de manière dynamique en utilisant la fonction |opérateur = :

// Add the BuildSystem permission to the existing permissions
TimPermissions |= SystemPermissions.BuildSystem;

// Print the updated permissions - it now includes SQL, Redis, and BuildSystem
Console.WriteLine(TimPermissions);

// Add the BuildSystem permission to the existing permissions
TimPermissions |= SystemPermissions.BuildSystem;

// Print the updated permissions - it now includes SQL, Redis, and BuildSystem
Console.WriteLine(TimPermissions);

' Add the BuildSystem permission to the existing permissions
TimPermissions = TimPermissions Or SystemPermissions.BuildSystem

' Print the updated permissions - it now includes SQL, Redis, and BuildSystem
Console.WriteLine(TimPermissions)

' Add the BuildSystem permission to the existing permissions
TimPermissions = TimPermissions Or SystemPermissions.BuildSystem

' Print the updated permissions - it now includes SQL, Redis, and BuildSystem
Console.WriteLine(TimPermissions)

Comprendre la limite de 32 bits

Tim met en évidence un élément important : le type de données entier dans C# a une limite de 32 bits. Cela signifie que nous ne pouvons stocker que jusqu'à 32 drapeaux uniques dans un int. Si nous avons besoin de plus de 32 drapeaux, nous devrions envisager d'utiliser un long (64 bits) ou même plusieurs valeurs. Toutefois, dans la plupart des cas, 32 drapeaux suffisent amplement.

Stockage des drapeaux dans une base de données

L'un des principaux avantages de l'utilisation de flag enums est qu'ils peuvent être stockés efficacement dans une base de données. Au lieu de stocker plusieurs colonnes booléennes, nous pouvons stocker une seule valeur entière représentant toutes les autorisations. Tim explique que cette approche réduit considérablement la complexité de la base de données et les besoins de stockage.

Par exemple, si TimPermissions est stocké en tant que 37, cela représente une combinaison de :

• SQL (bit 1)
• Redis (bit 3)
• Système de construction (bit 5)

Lorsque nous extrayons cette valeur de la base de données, nous pouvons facilement la décoder pour déterminer les autorisations actives.

Conclusion

Tim conclut en soulignant la puissance des Flag Enums. En utilisant des opérations binaires, nous pouvons gérer efficacement plusieurs états au sein d'un seul nombre entier. Cette technique améliore les performances, simplifie le stockage des données et rend notre code plus lisible.

En suivant cette approche, vous pouvez mettre en œuvre un système de gestion des permissions propre et évolutif à l'aide des Flag Enums de C#. Regardez la vidéo complète pour mieux comprendre.