Apprendre le C#

Comprendre les drapeaux C#

Tim Corey

8m 32s

Les drapeaux C# sont une fonctionnalité puissante mais souvent négligée qui permet aux développeurs de gérer les permissions et les options à l'aide d'opérations bit à bit. Dans sa vidéo "Binaire en C# : Flags in 10 minutes or less", Tim Corey fournit une explication claire et concise du fonctionnement des drapeaux et de la manière dont ils peuvent être exploités efficacement en C#. Dans cet article, nous allons décomposer les explications de Tim et les idées tirées de la vidéo pour mieux comprendre les drapeaux C#.

Qu'est-ce qu'un drapeau ?

Tim commence par présenter le concept des drapeaux. Il explique que les drapeaux permettent d'attribuer plusieurs valeurs à une seule variable, ce qui les rend utiles pour gérer les autorisations dans une application. Pour illustrer cela, Tim crée un enum appelé SystemPermissions qui inclut diverses permissions comme SQL, WebServer, Redis, Azure, GitHub, et BuildSystem.

Tim souligne qu'en l'absence de Flags, une seule variable peut contenir uniquement une permission à la fois. Par exemple, si nous essayons d'attribuer SystemPermissions.GitHub à un utilisateur, nous ne pouvons pas non plus attribuer SystemPermissions.BuildSystem à moins d'utiliser un tableau, ce qui devient fastidieux à gérer.

Le problème des drapeaux

À ce stade, Tim montre les limites des missions d'énumération traditionnelles. Si nous attribuons les autorisations une par une, leur vérification ultérieure nécessite d'itérer dans un tableau, ce qui est inefficace et non évolutif. Cela conduit à une implémentation "laide", comme le décrit Tim, où la gestion de multiples permissions devient un casse-tête.

Présentation de l'attribut Flags

Pour résoudre ce problème, Tim introduit l'attribut [Flags], qui permet de traiter un enum comme un champ de bits. Il explique que chaque permission se voit attribuer une valeur binaire unique à l'aide d'un décalage de bits.

Au lieu d'attribuer des nombres incrémentaux (0, 1, 2, 3, etc.), Tim attribue des valeurs en utilisant des puissances de deux :

[Flags]
enum SystemPermissions
{
    None = 0,
    SQL = 1 << 0,       // 00000001
    WebServer = 1 << 1, // 00000010
    Redis = 1 << 2,     // 00000100
    Azure = 1 << 3,     // 00001000
    GitHub = 1 << 4,    // 00010000
    BuildSystem = 1 << 5 // 00100000
}

[Flags]
enum SystemPermissions
{
    None = 0,
    SQL = 1 << 0,       // 00000001
    WebServer = 1 << 1, // 00000010
    Redis = 1 << 2,     // 00000100
    Azure = 1 << 3,     // 00001000
    GitHub = 1 << 4,    // 00010000
    BuildSystem = 1 << 5 // 00100000
}

<Flags>
Enum SystemPermissions
    None = 0
    SQL = 1 << 0       ' 00000001
    WebServer = 1 << 1 ' 00000010
    Redis = 1 << 2     ' 00000100
    Azure = 1 << 3     ' 00001000
    GitHub = 1 << 4    ' 00010000
    BuildSystem = 1 << 5 ' 00100000
End Enum

<Flags>
Enum SystemPermissions
    None = 0
    SQL = 1 << 0       ' 00000001
    WebServer = 1 << 1 ' 00000010
    Redis = 1 << 2     ' 00000100
    Azure = 1 << 3     ' 00001000
    GitHub = 1 << 4    ' 00010000
    BuildSystem = 1 << 5 ' 00100000
End Enum

Tim explique que le déplacement des bits garantit que chaque permission a une valeur unique sans se chevaucher, ce qui permet de combiner efficacement plusieurs permissions.

Assignation et combinaison de drapeaux

Tim montre ensuite comment attribuer et combiner des autorisations à l'aide d'opérations bit à bit. Il explique qu'il est possible d'attribuer plusieurs autorisations à un utilisateur en utilisant la méthode du OU binaire (|) :

SystemPermissions timsPermissions = SystemPermissions.SQL | SystemPermissions.Redis | SystemPermissions.GitHub;

SystemPermissions timsPermissions = SystemPermissions.SQL | SystemPermissions.Redis | SystemPermissions.GitHub;

Dim timsPermissions As SystemPermissions = SystemPermissions.SQL Or SystemPermissions.Redis Or SystemPermissions.GitHub

Dim timsPermissions As SystemPermissions = SystemPermissions.SQL Or SystemPermissions.Redis Or SystemPermissions.GitHub

Cela attribue les permissions SQL, Redis, et GitHub à timsPermissions, les stockant dans une seule variable à l'aide d'opérations au niveau des bits.

Vérifier les permissions avec les drapeaux

L'un des principaux avantages des Flags est la capacité de vérifier si une permission spécifique est définie en utilisant l'opérateur ET binaire (&). Tim montre comment vérifier si un utilisateur dispose d'une autorisation particulière :

if ((timsPermissions & SystemPermissions.SQL) == SystemPermissions.SQL)
{
    Console.WriteLine("Tim has SQL access.");
}

if ((timsPermissions & SystemPermissions.SQL) == SystemPermissions.SQL)
{
    Console.WriteLine("Tim has SQL access.");
}

If (timsPermissions And SystemPermissions.SQL) = SystemPermissions.SQL Then
    Console.WriteLine("Tim has SQL access.")
End If

If (timsPermissions And SystemPermissions.SQL) = SystemPermissions.SQL Then
    Console.WriteLine("Tim has SQL access.")
End If

Tim souligne que cette approche est beaucoup plus efficace que le bouclage d'un tableau, car elle permet des comparaisons rapides par bit.

Suppression des permissions

Tim explique également comment supprimer une permission en utilisant les opérateurs ET et NON binaire (~). Si nous devons révoquer la permission SQL de timsPermissions, nous le faisons ainsi :

timsPermissions &= ~SystemPermissions.SQL;

timsPermissions &= ~SystemPermissions.SQL;

timsPermissions = timsPermissions And Not SystemPermissions.SQL

timsPermissions = timsPermissions And Not SystemPermissions.SQL

La traduction doit rester professionnelle et préserver l'exactitude technique tout en expliquant les caractéristiques et les avantages de ces outils de développement.

Affichage de drapeaux en binaire

Pour visualiser le fonctionnement des drapeaux, Tim propose de convertir la valeur de l'énumération en sa représentation binaire. Il utilise une méthode d'aide pour afficher la valeur binaire d'une permission :

Console.WriteLine(Convert.ToString((int)timsPermissions, 2));

Console.WriteLine(Convert.ToString((int)timsPermissions, 2));

Console.WriteLine(Convert.ToString(CInt(timsPermissions), 2))

Console.WriteLine(Convert.ToString(CInt(timsPermissions), 2))

Tim explique que cela permet de comprendre comment les bits individuels sont définis et manipulés dans l'énumération.

Pourquoi utiliser les drapeaux ?

Tim conclut en soulignant pourquoi les drapeaux sont utiles en C# :

Ils permettent de stocker plusieurs valeurs dans une seule variable.
Ils permettent une gestion efficace des autorisations.
Ils simplifient la vérification et la modification des permissions à l'aide d'opérations bit à bit.

Il souligne également que les drapeaux sont couramment utilisés dans des scénarios tels que les autorisations de fichiers, les rôles des utilisateurs et les paramètres des applications.

Conclusion

Tout au long de la vidéo, Tim Corey fait une démonstration claire et pratique du fonctionnement des drapeaux C#. En utilisant l'attribut [Flags] et les opérations au niveau des bits, nous pouvons gérer efficacement plusieurs permissions sans avoir besoin de structures de données complexes. Si vous travaillez avec des permissions ou des paramètres qui nécessitent plusieurs valeurs, les drapeaux sont un excellent outil pour simplifier votre mise en œuvre.

Pour une compréhension pratique, consultez la vidéo de Tim Corey, qui explique ces concepts étape par étape. Les drapeaux peuvent sembler délicats au début, mais une fois que vous comprenez leur nature binaire, ils deviennent une fonctionnalité incroyablement utile dans le développement C#.