C#-Flags verstehen

Was sind Flaggen?

Tim beginnt mit einer Einführung in das Konzept der Flags. Er erklärt, dass Flags es uns ermöglichen, einer einzigen Variablen mehrere Werte zuzuweisen, was sie für die Verwaltung von Berechtigungen in einer Anwendung nützlich macht. Um dies zu veranschaulichen, erstellt Tim ein Enum namens SystemPermissions, das verschiedene Berechtigungen wie SQL, WebServer, Redis, Azure, GitHub und BuildSystem umfasst.

Tim hebt hervor, dass ohne Flags eine einzelne Variable nur eine Berechtigung gleichzeitig halten kann. Wenn wir beispielsweise versuchen, SystemPermissions.GitHub einem Benutzer zuzuweisen, können wir SystemPermissions.BuildSystem nicht ebenfalls zuweisen, es sei denn, wir verwenden ein Array, das jedoch schwer zu verwalten wird.

Das Problem ohne Flaggen

An dieser Stelle zeigt Tim die Grenzen der traditionellen Aufzählungsaufgaben auf. Wenn wir eine Berechtigung nach der anderen zuweisen, erfordert die spätere Überprüfung eine Iteration durch ein Array, was ineffizient und nicht skalierbar ist. Dies führt zu einer "hässlichen" Implementierung, wie Tim es beschreibt, bei der die Verwaltung mehrerer Berechtigungen zu einem Problem wird.

Einführung in das Attribut "Flags"

Um dieses Problem zu lösen, führt Tim das Attribut [Flags] ein, das es einem Enum ermöglicht, als Bitfeld behandelt zu werden. Er erklärt, dass jeder Berechtigung durch bitweises Verschieben ein eindeutiger Binärwert zugewiesen wird.

Anstatt inkrementelle Zahlen (0, 1, 2, 3 usw.) zuzuweisen, weist Tim Werte mit Zweierpotenzen zu:

[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 erklärt, dass durch das Verschieben der Bits sichergestellt wird, dass jede Berechtigung einen eindeutigen Wert hat, ohne dass es zu Überschneidungen kommt, wodurch eine effiziente Kombination mehrerer Berechtigungen möglich ist.

Zuweisung und Kombination von Flags

Anschließend demonstriert Tim, wie man mit bitweisen Operationen Berechtigungen zuweist und kombiniert. Er erklärt, dass wir einem Benutzer mehrere Berechtigungen zuweisen können, indem wir das bitweise ODER (|) Operator:

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

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

Dies weist SQL-, Redis- und GitHub-Berechtigungen zu timsPermissions zu, indem sie in einer einzigen Variable mithilfe von Bit-Operationen gespeichert werden.

Berechtigungen mit Flags prüfen

Einer der Hauptvorteile von Flags ist die Möglichkeit, zu überprüfen, ob eine bestimmte Berechtigung gesetzt ist, indem der bitweise UND (&) Operator verwendet wird. Tim demonstriert, wie man überprüft, ob ein Benutzer eine bestimmte Berechtigung hat:

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 betont, dass dieser Ansatz viel effizienter ist als die Schleifenbildung durch ein Array, da er schnelle bitweise Vergleiche ermöglicht.

Entfernen von Berechtigungen

Tim erklärt auch, wie man eine Berechtigung mithilfe des bitweisen UND- und NICHT (~) Operators entfernt. Wenn wir die SQL-Berechtigung von timsPermissions widerrufen müssen, tun wir es wie folgt:

timsPermissions &= ~SystemPermissions.SQL;

timsPermissions &= ~SystemPermissions.SQL;

Dadurch wird die SQL-Berechtigung effektiv entfernt, während die anderen Berechtigungen erhalten bleiben.

Flags im Binärformat anzeigen

Um die Funktionsweise von Flags zu veranschaulichen, schlägt Tim vor, den Enum-Wert in seine binäre Darstellung zu konvertieren. Er verwendet eine Hilfsmethode, um den binären Wert einer Berechtigung anzuzeigen:

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

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

Tim erklärt, dass dies dabei hilft, zu verstehen, wie einzelne Bits innerhalb der Enum gesetzt und manipuliert werden.

Warum Flags verwenden?

Abschließend betont Tim, warum Flags in C# nützlich sind:

• Sie ermöglichen die Speicherung mehrerer Werte in einer einzigen Variable.
• Sie ermöglichen eine effiziente Rechteverwaltung.
• Sie vereinfachen die Überprüfung und Änderung von Berechtigungen durch bitweise Operationen.

Er weist auch darauf hin, dass Flags häufig in Szenarien wie Dateiberechtigungen, Benutzerrollen und Anwendungseinstellungen verwendet werden.

Abschließende Gedanken

Während des gesamten Videos demonstriert Tim Corey anschaulich und praktisch, wie C# Flags funktionieren. Durch die Verwendung des [Flags] Attributs und von Bit-Operationen können wir mehrere Berechtigungen effizient verwalten, ohne komplexe Datenstrukturen zu benötigen. Wenn Sie mit Berechtigungen oder Einstellungen arbeiten, die mehrere Werte erfordern, sind Flags ein hervorragendes Werkzeug, um Ihre Implementierung zu vereinfachen.

Für ein praktisches Verständnis sehen Sie sich das Video von Tim Corey an, in dem er diese Konzepte Schritt für Schritt erklärt. Flags mögen auf den ersten Blick kompliziert erscheinen, aber sobald man ihre binäre Natur verstanden hat, werden sie zu einer unglaublich nützlichen Funktion in der C#-Entwicklung.