Zrozumieć Flag w C#

Tim Corey

8m 32s

Flagi w C# to potężna, ale często pomijana funkcja, która umożliwia programistom zarządzanie uprawnieniami i opcjami przy użyciu operacji bitowych. W swoim filmie "Binary in C#: Flags in 10 minutes or less" Tim Corey przedstawia jasne i zwięzłe wyjaśnienie działania flag i ich skutecznego wykorzystania w C#. W tym artykułe rozłożymy wyjaśnienia Tima oraz wnioski z filmu, aby lepiej zrozumieć Flagi w C#.

Co to są Flagi?

Tim zaczyna od wprowadzenia koncepcji Flag. Wyjaśnia, że Flagi pozwalają przypisać wiele wartości do jednej zmiennej, co czyni je przydatnymi do zarządzania uprawnieniami w aplikacji. Aby to zilustrować, Tim tworzy enum o nazwie SystemPermissions, który zawiera różne uprawnienia, takie jak SQL, WebServer, Redis, Azure, GitHub i BuildSystem.

Tim podkreśla, że bez Flags pojedyncza zmienna może przechowywać tylko jedno uprawnienie jednocześnie. Na przykład, jeśli spróbujemy przypisać SystemPermissions.GitHub do użytkownika, nie możemy również przypisać SystemPermissions.BuildSystem, chyba że użyjemy tablicy, co staje się trudne do zarządzania.

Problem bez Flag

W tym momencie, Tim demonstruje ograniczenia tradycyjnych przypisań enuma. Jeśli przypisujemy uprawnienia jedno po drugim, ich późniejsze sprawdzanie wymaga iteracji przez tablicę, co jest nieefektywne i mało skalowalne. Prowadzi to do "nieestetycznej" implementacji, jak to określa Tim, gdzie zarządzanie wieloma uprawnieniami staje się uciążliwe.

Wprowadzenie do atrybutu Flag

Aby rozwiązać ten problem, Tim wprowadza atrybut [Flags], który pozwala traktować enum jako pole bitowe. Wyjaśnia, że każdemu uprawnieniu przypisywana jest unikalna wartość binarna przy użyciu przesunięcia bitów.

Zamiast przypisywać inkrementalne liczby (0, 1, 2, 3, itd.), Tim przypisuje wartości używając potęg dwóch:

[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 wyjaśnia, że przesuwanie bitów zapewnia każdemu uprawnieniu unikalną wartość bez nakładania się, co umożliwia efektywne łączenie wielu uprawnień.

Przypisywanie i łączenie Flag

Tim następnie pokazuje, jak przypisywać i łączyć uprawnienia przy użyciu operacji bitowych. Wyjaśnia, że możemy przypisać wiele uprawnień do użytkownika, używając bitowej operacji OR (|) operatora:

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

To przypisuje uprawnienia SQL, Redis i GitHub do timsPermissions, przechowując je w jednej zmiennej za pomocą operacji bitowych.

Sprawdzanie uprawnień za pomocą Flag

Jedną z kluczowych zalet Flags jest możliwość sprawdzenia, czy określone uprawnienie jest ustawione, wykorzystując operator bitowy AND (&). Tim demonstruje, jak zweryfikować, czy użytkownik ma konkretne uprawnienie:

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 podkreśla, że to podejście jest znacznie bardziej wydajne niż pętlenie przez tablicę, ponieważ pozwala na szybkie porównania bitowe.

Usuwanie uprawnień

Tim omawia również, jak usunąć uprawnienie przy użyciu operatorów bitowych AND oraz NOT (~). Jeśli musimy cofnąć uprawnienie SQL z timsPermissions, robimy to w następujący sposób:

timsPermissions &= ~SystemPermissions.SQL;

timsPermissions &= ~SystemPermissions.SQL;

timsPermissions = timsPermissions And Not SystemPermissions.SQL

timsPermissions = timsPermissions And Not SystemPermissions.SQL

To skutecznie usuwa uprawnienie SQL, zachowując pozostałe uprawnienia nietknięte.

Wyświetlanie Flag w postaci binarnej

Aby zobaczyć jak działają Flagi, Tim sugeruje konwersję wartości enuma na jej reprezentację binarną. Używa metody pomocniczej, aby wyświetlić wartość binarną uprawnienia:

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 wyjaśnia, że to pomaga zrozumieć, jak poszczególne bity są ustawiane i manipulowane w enumie.

Dlaczego warto używać Flag?

Tim kończy, podkreślając, dlaczego Flagi są przydatne w C#:

• Pozwalają na przechowywanie wielu wartości w jednej zmiennej.
• Umożliwiają efektywne zarządzanie uprawnieniami.
• Uproszczają sprawdzanie i modyfikowanie uprawnień przy użyciu operacji bitowych.

Zwraca również uwagę, że Flagi są często używane w sytuacjach takich jak uprawnienia do plików, role użytkowników i ustawienia aplikacji.

Podsumowanie

Przez cały film Tim Corey daje jasne i praktyczne wprowadzenie do działania Flag w C#. Używając atrybutu [Flags] oraz operacji bitowych, możemy efektywnie zarządzać wieloma uprawnieniami bez potrzeby skomplikowanych struktur danych. Jeśli pracujesz z uprawnieniami lub ustawieniami wymagającymi wielu wartości, Flagi są doskonałym narzędziem do uproszczenia implementacji.

Aby zyskać praktyczne zrozumienie, obejrzyj film Tima Coreya, w którym wyjaśnia te koncepcje krok po kroku. Flagi mogą wydawać się skomplikowane na początku, ale kiedy zrozumiesz ich binarną naturę, stają się niezmiernie przydatną funkcją w rozwoju w C#.