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 autorisations comme SQL, WebServer, Redis, Azure, GitHub, et BuildSystem.

Tim souligne que sans Flags, une seule variable ne peut contenir qu'une seule permission à la fois. Par exemple, si nous essayons d'attribuer SystemPermissions.GitHub à un utilisateur, nous ne pouvons pas attribuer également SystemPermissions.BuildSystem sauf si nous utilisons un tableau, ce qui devient difficile à 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 à un enum d'être traité 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
}

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;

Cela attribue les permissions SQL, Redis, et GitHub à timsPermissions, les stockant dans une seule variable en utilisant des opérations sur les 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 à l'aide de l'opérateur ET bit à bit (&). 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.");
}

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 aborde aussi comment supprimer une permission en utilisant l'opérateur ET et NON bit à bit (~). Si nous avons besoin de révoquer la permission SQL de timsPermissions, nous le faisons ainsi :

timsPermissions &= ~SystemPermissions.SQL;

timsPermissions &= ~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));

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 sur les 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#.