Stałe wyliczeniowe (Enum) w .NET

Kiedy projektujemy jakiś program dobrze jest utworzyć zestaw symbolicznych nazw, symbolicznych stałych, które reprezentują jakąś wartość ze ściśle określonego zbioru.

Wyobraźmy sobie, że Tworzymy program, który zarządza bazą danych pracowników w firmie. W programie tym, gdy do bazy dodawany jest jakiś pracownik należy podać jego formę zatrudnienia np. okres próbny, umowa na czas określony, umowa na czas nieokreślony, umowa zlecenia, umowa o dzieło. Dodatkowo domyślną "wartością" niech będzie umowa na czas określony.

Można to zrobić za pomocą metody, która na wejście przyjmuje formę zatrudnienia w postaci zmiennej liczbowej (int) np:

private void DodajPracownika(int formaZatrudnienia = 2)
{
    switch (formaZatrudnienia)
    {
        case 1:
            //kod ustawiający formę zatrudnienia na "okres próbny"
            break;
        case 3:
            //kod ustawiający formę zatrudnienia na "umowa na czas nieokreślony"
            break;
        case 4:
            //kod ustawiający formę zatrudnienia na "umowa zlecenia"
            break;
        case 5:
            //kod ustawiający formę zatrudnienia na "umowa o dzieło"
            break;
        case 2:
        default:
            //kod ustawiający formę zatrudnienia na "umowa na czas określony"
            break;
    }
}

Z łatwością można zauważyć, że taka konstrukcja podatna jest na błędy. Gdy ktoś wywoła powyższą metodę w następujący sposób:

DodajPracownika(10);

To do bazy danych zostanie dodany pracownik zatrudniony na czas określony. Można oczywiście z powyższego switch-a usunąć domyślny przypadek lub dla nieobsługiwanej wartości wyrzucić wyjątek ArgumentOutOfRangeException() jednak nie rozwiąże to problemu, że metoda na wejście może przyjmować dowolną wartość z zakresu int

Aby zapobiec takim przypadkom należy skorzystać z typu System.Enum.
Wyliczenia używane są w języku C# w wielu miejscach, np. metoda pobierająca zawartość określonego folderu Directory.GetFiles przyjmuje na wejście parametr określający czy pliki mają być wyszukiwane tylko we wskazanym folderze czy we wskazanym folderze i wszystkich podfolderach wchodzących w jego skład.

Directory.GetFiles(@"E:\", "*.*", SearchOption.AllDirectories); //we wszystkich podfolderach
Directory.GetFiles(@"E:\", "*.*", SearchOption.TopDirectoryOnly); //tylko we wskazanym folderze

Innym przykładem wyliczenia jest np. DayOfWeek, FileAccess, FileAttributes, FormBorderStyle, Color czy Keys.

Definiowanie wyliczeń

Język C# umożliwia programiście tworzenie niestandardowych wyliczeń. Utwórzmy zatem wyliczenie reprezentujące formę zatrudnienia:

/// <summary>
/// Obsługiwane formy zatrudnienia
/// </summary>
public enum FormaZatrudnienia
{
    OkresProbny, // = 0
    UmowaNaCzasOkreslony, // = 1
    UmowaNaCzasNieokreslony, // = 2
    UmowaZlecenia, // = 3
    UmowaODzielo, // = 4
}

Enumerator czyli wyliczenie jest definiowany za pomocą słowa kluczowego enum. Po nim podajemy nazwę naszego enum-a oraz w nawiasach klamrowych piszemy, jakie wartości on przyjmuje. W wyliczeniu FormaZatrudnienia zdefiniowano pięć imiennych stałych odpowiadających wartościom liczbowym. Domyślnie pierwszy element (OkresProbny) jest ustawiany na wartość zero (0) a pozostałe zgodnie z progresją n+1.

Wartości początkowe można zmieniać wedle własnego upodobnienia np.

///
/// Obsługiwane formy zatrudnienia
///
public enum FormaZatrudnienia
{
    OkresProbny = 10,
    UmowaNaCzasOkreslony = 1,
    UmowaNaCzasNieokreslony,
    UmowaZlecenia = 5,
    UmowaODzielo = 4,
}

Jak widać na powyższym przykładzie kolejność w wyliczeniach nie musi być sekwencyjna, wartości unikatowe też nie są wymagane. Trzeba zauważyć, że elementy którym nie przydzieliliśmy konkretnej wartości (w naszym przypadku UmowaNaCzasNieokreslony) nadal będą automatycznie rosły zgodnie z progresją +1(w odniesieniu do elementu poprzedniego UmowaNaCzasOkreslony). Formy zatrudnienia dla powyższego wyliczenia będą miały zatem następujące wartości:

OkresProbny = 10,
UmowaNaCzasOkreslony = 1,
UmowaNaCzasNieokreslony = 2,
UmowaZlecenia = 5,
UmowaODzielo = 4,

Podając nazwę enumeratora nie należy stosować prefiksów i sufiksów. Poniższe nazwy wyliczeń NIE są poprawne:

public enum KolorEnum { Czerwony, Bialy, Niebieski };
public enum EnumKolor { Czerwony, Bialy, Niebieski };
public enum WyliczenieKolor { Czerwony, Bialy, Niebieski };
public enum Wyliczenie_Kolor { Czerwony, Bialy, Niebieski };

Używając wyliczeń trzeba pamiętać również o tym, że nie należy tworzyć typów wyliczeniowych z jedną tylko wartością.

//ZŁY PRZYKŁAD WYLICZENIA
public enum OpcjeProgramu {
   OpcjeDomyslne,
   //opcje dodatkowe które dodam w przyszłości
}

public void OdczytajOpcje(OpcjeProgramu opcje)
{
//...
}

Metoda odczytująca domyślne opcje programu nie musi przyjmować parametru oznaczającego OpcjeDomyslne. Lepiej jest przeciążyć tą metodę w przyszłości, gdy będziemy rozbudowywać nasze wyliczenie.

public enum OpcjeProgramu
{
    OpcjeDomyslne,
    OpcjeAdministratora,
}

/// 
/// Metoda odczytująca opcje domyślne
/// 
private void OdczytajOpcje()
{
    //odczyt opcji domyślnych
}

/// 
/// Metoda odczytująca opcje
/// 
public void OdczytajOpcje(OpcjeProgramu opcje)
{
    switch (opcje)
    {
        case OpcjeProgramu.OpcjeDomyslne:
            OdczytajOpcje(); //wywołanie metody odczytującej opcje domyślne
            break;
        case OpcjeProgramu.OpcjeAdministratora:
            //odczyt opcji dla administratora
            break;
        default:
            throw new ArgumentOutOfRangeException();
            break;
    }
}

Typ wyliczeń

Typem bazowym dla wartości wyliczenia jest System.Int32. Można to zmienić, przy czym należy jednak pamiętać że można używać tylko typów liczbowych reprezentujących liczby całkowite np: byte, short, int czy long.
Jeżeli chcemy zmienić typ wartości naszego wyliczenia FormaZatrudnienia możemy zrobić to w następujący sposób:

///
/// Obsługiwane formy zatrudnienia
///
public enum FormaZatrudnienia : byte
{
    OkresProbny = 10,
    UmowaNaCzasOkreslony = 1,
    UmowaNaCzasNieokreslony,
    UmowaZlecenia = 5,
    UmowaODzielo = 4,
}

Deklarowanie zmiennych typu Enum

Ponieważ wyliczenia tak naprawdę są tylko typami danych zdefiniowanych przez użytkownika, można ich używać jako parametrów wejściowych do metod, wartości zwracanych przez funkcje lub jako zmienne lokalne czy też jako właściwości klas.
Wróćmy teraz do naszej metody dodającej nowego pracownika do bazy. Niech metoda ta przyjmuje na wejście, zamiast trefnego w tym przypadku parametru typu int, parametr typu FormaZatrudnienia.

private void DodajPracownika(FormaZatrudnienia formaZatrudnienia = FormaZatrudnienia.UmowaNaCzasOkreslony)
{
    switch (formaZatrudnienia)
    {
        case FormaZatrudnienia.OkresProbny:
            //kod ustawiający formę zatrudnienia na "okres próbny"
            break;
        case FormaZatrudnienia.UmowaNaCzasNieokreslony:
            //kod ustawiający formę zatrudnienia na "umowa na czas nieokreślony";
            break;
        case FormaZatrudnienia.UmowaZlecenia:
            //kod ustawiający formę zatrudnienia na "umowa zlecenia";
            break;
        case FormaZatrudnienia.UmowaODzielo:
            //kod ustawiający formę zatrudnienia na "umowa o dzieło";
            break;
        case FormaZatrudnienia.UmowaNaCzasOkreslony:
            //kod ustawiający formę zatrudnienia na "umowa na czas określony";
            break;
    }
}

Zwróćmy uwagę, że ponieważ wyliczenia to stały zbiór, niedozwolone jest ustawienie zmiennej wyliczenia na wartość, która nie jest zdefiniowana bezpośrednio przez wyliczany typ. Mówiąc inaczej nie da się wywołać teraz metody DodajPracownika z innym parametrem niż zdefiniowane przez użytkownika w wyliczeniu FormaZatrudnienia.

DodajPracownika(10); //takie wywołanie nie jest możliwe
DodajPracownika(FormaZatrudnienia.UmowaODzielo); //takie wywołanie jest jak najbardziej prawidłowe

Załóżmy teraz, że nasza firma z przykładu zaczęła zatrudniać stażystów. W związku z czym nasz typ wyliczeniowy powiększy się o nową wartość Staz.

/// 
/// Obsługiwane formy zatrudnienia
/// 
public enum FormaZatrudnienia
{
    OkresProbny,
    UmowaNaCzasOkreslony,
    UmowaNaCzasNieokreslony,
    UmowaZlecenia,
    UmowaODzielo,
    Staz,
}

Wróćmy do naszej metody dodającej nowego pracownika do bazy danych. Wywołajmy ją z następującym parametrem formaZatrudnienia = FormaZatrudnienia.Staz:

DodajPracownika(FormaZatrudnienia.Staz);

Powyższe wywołanie nie doda ani pracownika do listy anie też nie zasygnalizuje wyjątku, że przekazane dane są nieobsługiwane. Należy zabezpieczyć się przed tym w taki oto sposób:

private static void DodajPracownika(FormaZatrudnienia formaZatrudnienia = FormaZatrudnienia.UmowaNaCzasOkreslony)
{
    switch (formaZatrudnienia)
    {
        case FormaZatrudnienia.OkresProbny:
            //kod ustawiający formę zatrudnienia na "okres próbny"
            break;
        case FormaZatrudnienia.UmowaNaCzasNieokreslony:
            //kod ustawiający formę zatrudnienia na "umowa na czas nieokreślony";
            break;
        case FormaZatrudnienia.UmowaZlecenia:
            //kod ustawiający formę zatrudnienia na "umowa zlecenia";
            break;
        case FormaZatrudnienia.UmowaODzielo:
            //kod ustawiający formę zatrudnienia na "umowa o dzieło";
            break;
        case FormaZatrudnienia.UmowaNaCzasOkreslony:
            //kod ustawiający formę zatrudnienia na "umowa na czas określony";
            break;
        default:
            throw new ArgumentOutOfRangeException();
            break;
    }
}

Teraz wywołanie metody dodającej nowego stażystę zasygnalizowane zostanie wyjątkiem.

NIGDY nie należy dodawać do wyliczeń wartości tymczasowych, które mogą być użyte kiedyś w przyszłości. Poniższe, zmodyfikowane wyliczenie FormaZatrudnienia jest jak najbardziej NIEPOPRAWNE:

//TAK NIE NALEŻY DEFINIOWAĆ WYLICZEŃ
public enum FormaZatrudnienia
{
    OkresProbny,
    UmowaNaCzasOkreslony,
    UmowaNaCzasNieokreslony,
    UmowaZlecenia,
    UmowaODzielo,
    Staz,
    ZarezerwowaneNaPrzyszlosc1,
    ZarezerwowaneNaPrzyszlosc2,
}

Zamiast powyższych zarezerwowanych wartości lepiej jest sprawdzać czy dany argument jest obsługiwany, tak jak ma to miejsce w metodzie dodającej pracownika. Obsługiwane wartości zostały w switch-u odpowiednio rozpisane, wartości nieobsługiwane (w naszym przykładzie przypadek default) zgłoszą wyjątek ArgumentOutOfRangeException.

Wartość domyślna wyliczenia

Wróćmy ponownie do naszego wyliczenia FormaZatrudnienia

/// 
/// Obsługiwane formy zatrudnienia
/// 
public enum FormaZatrudnienia
{
    OkresProbny,
    UmowaNaCzasOkreslony,
    UmowaNaCzasNieokreslony,
    UmowaZlecenia,
    UmowaODzielo,
    Staz,
}

Jak już wspomniano wyliczenia są typami danych, utwórzmy zatem klasę Pracownik która będzie posiadać właściwość FormaZatrudnienia typu FormaZatrudnienia.

public class Pracownik
{
    public FormaZatrudnienia FormaZatrudnienia { get; set; }
}

Po utworzeniu nowego obiektu typu Pracownik, właściwość FormaZatrudnienia przyjmie jakąś wartość domyślną. Jaką?

Pracownik pracownik = new Pracownik();
Console.WriteLine("Forma zatrudnienia to: {0}", pracownik.FormaZatrudnienia.ToString());
//na konsolę wypisane zostanie: 'Forma zatrudnienia to: OkresProbny'

W powyższym przypadku wywołany został domyślny konstruktor klasy Pracownik, który nadał właściwości FormaZatrudnienia wartość domyślną odpowiadającą pierwszej wartości typu wyliczeniowego FormaZatrudnienia czyli OkresProbny. Teraz nadajmy elementom wyliczenia wartości, domyślnie wartości nadane zostały przez kompilator, opisane są one w początkowej części tego artykułu "Definiowanie wyliczeń":

/// 
/// Obsługiwane formy zatrudnienia ze zmienionymi wartościami domyślnymi
/// 
public enum FormaZatrudnienia
{
    OkresProbny = 1,
    UmowaNaCzasOkreslony = 2,
    UmowaNaCzasNieokreslony = 3,
    UmowaZlecenia = 4,
    UmowaODzielo = 5,
    Staz = 6,
}

Ponownie utwórzmy obiekt typu Pracownik i sprawdźmy co teraz zostanie ustawione jako wartość domyślna właściwości FormaZatrudnienia.

Pracownik pracownik = new Pracownik();
Console.WriteLine("Forma zatrudnienia to: {0}", pracownik.FormaZatrudnienia.ToString());
//na konsolę wypisane zostanie: 'Forma zatrudnienia to: 0'

Co stało się w powyższym fragmencie kodu. Kompilator inicjalizując nowy obiekt typu Pracownik nadał właściwości FormaZatrudnienia domyślną wartość równą zero (0), która nie jest wyliczona w definicji wyliczenia FormaZatrudnienia.

Wniosek z powyższego przykładu nasuwa się sam. Przy projektowaniu wyliczeń dobrze jest dodawać wartość reprezentującą 0 (zero). W naszym przykładzie FormaZatrudnienia powinno to wyglądać tak:

/// 
/// Obsługiwane formy zatrudnienia
/// 
public enum FormaZatrudnienia
{
    Blad = 0,
    OkresProbny,
    UmowaNaCzasOkreslony,
    UmowaNaCzasNieokreslony,
    UmowaZlecenia,
    UmowaODzielo,
    Staz,
}

Oczywiście wartość reprezentującą 0 (zero) dobrze jest dodać do wyliczenia w przypadku gdy jego składowe mają nadane wartości i nie ma składowej równej 0 (zero).
Gdy wyliczenie ma wartości domyślne, nadane przez kompilator dodawanie składowej (0) zerowej nie ma większego sensu, zero (0) ustawiane jest dla pierwszej składowej wyliczenia. Zupełnie nielogiczne jest też dodawanie składowej wyliczenia równej 0 (zero) gdy używamy wyliczenia jak flag ... o tym później.

Nadawanie składowym wyliczenia wartości

Jak wspomniano w powyższych częściach niniejszego artykułu elementom wyliczenia można nadawać całkowitoliczbowe wartości. Domyślne wartości nadawane są przez kompilator zgodnie z zasadą: pierwszy element wyliczenia ustawiany jest na wartość zero (0) a pozostałe zgodnie z progresją n+1.
Jak zostaną ustawione zatem wartości składowych wyliczenia w poniższym przykładzie:

/// 
/// Obsługiwane formy zatrudnienia
/// 
public enum FormaZatrudnienia
{
    OkresProbny,
    UmowaNaCzasOkreslony,
    UmowaNaCzasNieokreslony = 0,
    UmowaZlecenia,
    UmowaODzielo,
    Staz,
}

Otóż zgodnie z progresją n+1 otrzymamy:

OkresProbny, // = 0
UmowaNaCzasOkreslony, // = 1
UmowaNaCzasNieokreslony = 0,
UmowaZlecenia, // = 1
UmowaODzielo, // = 2
Staz, // = 3

Składowe OkresProbny, UmowaNaCzasNieokreslony będą miały tą samą wartość czyli zero (0).
Co prawda powyższe rozwiązanie jest jak najbardziej poprawne, kompilator w konstrukcji (definicji) samego wyliczenia nie zgłosi żadnego błędu. Błąd zgłosi natomiast w metodzie dodającej nowego pracownika DodajPracownika, w switch-u. Mianowicie trzy przypadki będą miały tą samą wartość.

Inne przykłady nadawania wartości liczbowych elementom wyliczenia:

public enum FormaZatrudnienia
{
    OkresProbny,
    UmowaNaCzasOkreslony = 10,
    UmowaNaCzasNieokreslony,
    UmowaZlecenia = UmowaNaCzasOkreslony,
    UmowaODzielo,
    Staz,
}
//co daje nam:
//OkresProbny = 0
//UmowaNaCzasOkreslony = 10
//UmowaNaCzasNieokreslony = 11
//UmowaZlecenia = 10
//UmowaODzielo = 11
//Staz = 12

Można i tak:

public enum FormaZatrudnienia
{
    OkresProbny,
    UmowaNaCzasOkreslony = 10,
    UmowaNaCzasNieokreslony,
    UmowaZlecenia = UmowaNaCzasOkreslony,
    UmowaODzielo = UmowaZlecenia + 5,
    Staz,
}
//co daje nam:
//OkresProbny = 0
//UmowaNaCzasOkreslony = 10
//UmowaNaCzasNieokreslony = 11
//UmowaZlecenia = 10
//UmowaODzielo = 15
//Staz = 16

Lub tak:

public enum FormaZatrudnienia
{
    OkresProbny,
    UmowaNaCzasOkreslony = OkresProbny + 2,
    UmowaNaCzasNieokreslony = UmowaNaCzasOkreslony + 2,
    UmowaZlecenia = UmowaNaCzasNieokreslony + 2,
    UmowaODzielo = UmowaZlecenia + 2,
    Staz = UmowaODzielo + 2,
}
//co daje nam:
//OkresProbny = 0
//UmowaNaCzasOkreslony = 2
//UmowaNaCzasNieokreslony = 4
//UmowaZlecenia = 6
//UmowaODzielo = 8
//Staz = 10

Pobieranie wartości składowych wyliczenia

Wartości składowych wyliczenia pobieramy przez rzutowanie zmiennej enum na wykorzystywany typ bazowy.
Domyślny typ bazowy i jego zmiana opisane zostały w części "Typ wyliczeń". Wróćmy zatem do naszego wyliczenia FormaZatrudnienia

/// 
/// Obsługiwane formy zatrudnienia
/// 
public enum FormaZatrudnienia
{
    OkresProbny,
    UmowaNaCzasOkreslony,
    UmowaNaCzasNieokreslony,
    UmowaZlecenia,
    UmowaODzielo,
    Staz,
}

Wyliczenie to jest typu System.Int32. Typ wyliczenia można bardzo łatwo sprawdzić używając metod dostarczonych przez klasę System.Enum.

FormaZatrudnienia f = FormaZatrudnienia.OkresProbny;
Console.WriteLine("Wyliczenie 'FormaZatrudnienia' jest typu {0}", Enum.GetUnderlyingType(f.GetType()));
//na konsoli otrzymamy: Wyliczenie 'FormaZatrudnienia' jest typu System.Int32

Znając typ wyliczenia można pobrać wartości jego składowych np:

FormaZatrudnienia f = FormaZatrudnienia.OkresProbny;
Console.WriteLine("{0} = {1}", f.ToString(), (int)f);
f = FormaZatrudnienia.UmowaNaCzasOkreslony;
Console.WriteLine("{0} = {1}", f.ToString(), (int)f);
//co spowoduje wypisanie na konsoli:
//OkresProbny = 0
//UmowaNaCzasOkreslony = 1

Nadawanie zmiennym typu wyliczeniowego wartości

Zmiennym typu wyliczeniowego można nadawać wartości na kilka sposobów.

FormaZatrudnienia f1 = FormaZatrudnienia.OkresProbny;
//zmiennej o nazwie 'f1' typu 'FormaZatrudnienia' nadana została wartość jednej ze składowych wyliczenia - 'OkresProbny'
FormaZatrudnienia f2 = f1;
//zmiennej o nazwie 'f2' typu 'FormaZatrudnienia' została przypisana wartość zmiennej f1
FormaZatrudnienia f3 = (FormaZatrudnienia)4;
//zmiennej o nazwie 'f3' typu 'FormaZatrudnienia' została przypisana wartość jednej ze składowych wyliczenia,
//która to składowa ustawiona jest na 4 (UmowaODzielo)
FormaZatrudnienia f4 = f2 + 1;
//zmiennej o nazwie 'f4' typu 'FormaZatrudnienia' została przypisana wartość jednej ze składowych wyliczenia,
//składowa przypisana do 'f4' równa się wartości przypisanej do zmiennej 'f2'(OkresProbny) i powiększonej o 1
FormaZatrudnienia f5 = 0;
//zmiennej o nazwie 'f5' typu 'FormaZatrudnienia' została przypisana wartość jednej ze składowych wyliczenia,
//składowa przypisana do zmiennej 'f5' ustawiona jest na 0 (OkresProbny)

Po uruchomieniu poniższego kodu:

Console.WriteLine("'F1:' {0} = {1}", f1.ToString(), (int)f1);
Console.WriteLine("'F2:' {0} = {1}", f2.ToString(), (int)f2);
Console.WriteLine("'F3:' {0} = {1}", f3.ToString(), (int)f3);
Console.WriteLine("'F4:' {0} = {1}", f4.ToString(), (int)f4);
Console.WriteLine("'F5:' {0} = {1}", f5.ToString(), (int)f5);

Otrzymamy:

//'F1:' OkresProbny = 0
//'F2:' OkresProbny = 0
//'F3:' UmowaODzielo = 4
//'F4:' UmowaNaCzasOkreslony = 1
//'F5:' OkresProbny = 0

Na koniec spróbujmy wywołać taki kod:

FormaZatrudnienia f6 = 100;

Kompilator zgłosi nam błąd, że nie może przekonwertować liczby 100 na typ FormaZatrudnienia. Ponieważ wyliczenia to stały zbiór par nazwa/wartość, niedozwolone jest ustawienie zmiennej typu wyliczeniowego na wartość, która nie jest zdefiniowana bezpośrednio przez wyliczany typ.

FormaZatrudnienia f6 = 4;

Powyższy przykład też potraktowany zostanie jako błąd. Jedynym dozwolonym przypadkiem, jest przetoczony już powyżej przykład, który do zmiennej f5 przypisuje zero (0). I co najlepsze działa to dla wszystkich poniższych przypadków:

FormaZatrudnienia f6 = 0;
FormaZatrudnienia f6 = 0.000;
FormaZatrudnienia f6 = 00;
FormaZatrudnienia f6 = 00f;
FormaZatrudnienia f6 = 0x00;

Na koniec tego podrozdziału zagadka. Co zostanie wypisane na konsolę, czy poniższy fragment kodu jest poprawny:

FormaZatrudnienia f7 = FormaZatrudnienia.OkresProbny + 100;
Console.WriteLine("f7 = {0}", (int)f7);
//WYNIK: f7 = 100

Iterowanie po elementach wyliczenia

Klasa System.Enum zawiera metodę statyczną o nazwie GetValues(). Metoda ta zwraca instancję System.Array. Każdy element tej tablicy odpowiada składowej podanego wyliczenia. Pobranie zatem zawartości jakiegoś wyliczenia może mieć następującą postać:

//"konwersja" składowych wyliczenia na tablicę
Array formyZatrudnienia = Enum.GetValues(typeof(FormaZatrudnienia));

//"konwersja" składowych wyliczenia na kolekcję
IList<FormaZatrudnienia> formyZatrudnienia = Enum.GetValues(typeof(FormaZatrudnienia)) as IList<FormaZatrudnienia>;

//"konwersja" składowych wyliczenia na listę
List<FormaZatrudnienia> formyZatrudnienia = (Enum.GetValues(typeof(FormaZatrudnienia)) as IEnumerable<FormaZatrudnienia>).ToList();
List<FormaZatrudnienia> formyZatrudnienia = Enum.GetValues(typeof(FormaZatrudnienia)).OfType<FormaZatrudnienia>().ToList();

Iterację po elementach wyliczenia można zatem, używając metody GetValues(), zrobić np. tak:

foreach (FormaZatrudnienia formaZatrudnienia in Enum.GetValues(typeof(FormaZatrudnienia)))
{
    Console.WriteLine("{0} = {1}", formaZatrudnienia.ToString(), (int)formaZatrudnienia);
}
Etykiety: 

Dodaj nowy komentarz

Filtrowany HTML

  • Adresy internetowe są automatycznie zamieniane w odnośniki, które można kliknąć.
  • Dozwolone znaczniki HTML: <em> <strong> <cite> <blockquote> <code> <ul> <ol> <li> <dl> <dt> <dd>
  • Znaki końca linii i akapitu dodawane są automatycznie.
  • Tekstowe buźki będą zamieniane na ich graficzne odpowiedniki.

Czysty tekst

  • Znaczniki HTML niedozwolone.
  • Adresy internetowe są automatycznie zamieniane w odnośniki, które można kliknąć.
  • Znaki końca linii i akapitu dodawane są automatycznie.
  • Tekstowe buźki będą zamieniane na ich graficzne odpowiedniki.
CAPTCHA
W celu potwierdzenia, że jesteś człowiekiem, prosimy o wykonanie poniższego zadania
Target Image