Lernen Sie C#

C#-Flags verstehen

Tim Corey

8m 32s

C# Flags sind eine leistungsstarke, aber oft übersehene Funktion, die es Entwicklern ermöglicht, Berechtigungen und Optionen mit bitweisen Operationen zu verwalten. In seinem Video "Binary in C#: Flags in 10 Minuten oder weniger" erklärt Tim Corey klar und prägnant, wie Flags funktionieren und wie sie in C# effektiv genutzt werden können. In diesem Artikel werden wir Tims Erklärungen und Erkenntnisse aus dem Video aufschlüsseln, um ein besseres Verständnis von C# Flags zu erlangen.

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 jeweils nur eine Berechtigung halten kann. Zum Beispiel, wenn wir versuchen, einem Benutzer SystemPermissions.GitHub zuzuweisen, können wir nicht auch SystemPermissions.BuildSystem zuweisen, es sei denn, wir verwenden ein Array, das 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 ermöglicht, ein Enum als Bitfeld zu behandeln. 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
}

<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 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;

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

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

Dadurch werden SQL-, Redis- und GitHub-Berechtigungen timsPermissions zugeordnet und in einer einzigen Variable mithilfe von Bit-Operationen gespeichert.

Berechtigungen mit Flags prüfen

Einer der Hauptvorteile von Flags ist die Möglichkeit, zu überprüfen, ob eine bestimmte Berechtigung mit dem bitweisen UND-Operator (&) gesetzt ist. 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.");
}

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

Entfernen von Berechtigungen

Tim behandelt auch, wie man mit dem bitweisen UND- und NICHT-Operator (~) eine Berechtigung entfernen kann. Wenn wir die SQL-Berechtigung von timsPermissions widerrufen müssen, machen wir es so:

timsPermissions &= ~SystemPermissions.SQL;

timsPermissions &= ~SystemPermissions.SQL;

timsPermissions = timsPermissions And Not SystemPermissions.SQL

timsPermissions = timsPermissions And Not 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));

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

Console.WriteLine(Convert.ToString(CInt(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 bitweisen 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.