Enum i struct — nazwane stany oraz proste wartości

class Sprzet
{
    public string Nazwa { get; }
    public int Stan { get; set; }      // 0 - dostepny, 1 - wypozyczony, 2 - w naprawie...

    public Sprzet(string nazwa)
    {
        Nazwa = nazwa;
        Stan = 0;
    }
}

Sprzet s = new Sprzet("Laptop Dell");
s.Stan = 2;

if (s.Stan == 1)
{
    Console.WriteLine("nie mozna wypozyczyc");
}

public string Stan { get; set; }

s.Stan = "w naprawie";

if (s.Stan == "wnaprawie")      // literowka - warunek nigdy nie bedzie prawdziwy
{
    // ...
}

enum Stan
{
    Dostepny,
    Wypozyczony,
    WNaprawie,
    Wycofany
}

Stan s = Stan.WNaprawie;

Console.WriteLine(s);                        // WNaprawie - nazwa, nie liczba
Console.WriteLine($"stan: {s}");             // dziala w interpolacji

if (s == Stan.Wypozyczony)
{
    Console.WriteLine("ktos ma to u siebie");
}

// s = 5;                                    // BLAD CS0029
// s = Stan.Zniszczony;                      // BLAD CS0117 - nie ma takiej nazwy

Console.WriteLine((int)Stan.Dostepny);      // 0
Console.WriteLine((int)Stan.Wypozyczony);   // 1
Console.WriteLine((int)Stan.WNaprawie);     // 2
Console.WriteLine((int)Stan.Wycofany);      // 3

enum Priorytet
{
    Niski = 1,
    Sredni = 5,
    Wysoki = 10
}

enum KodBledu : byte      // mniejszy typ w tle, gdy wartosci sa male
{
    Brak = 0,
    BrakPliku = 4,
    BrakDostepu = 5
}

Stan s = Stan.WNaprawie;

int liczba = (int)s;                  // enum  -> int
Stan znowu = (Stan)liczba;            // int   -> enum
string nazwa = s.ToString();          // enum  -> tekst

Console.WriteLine($"{liczba} / {znowu} / {nazwa}");

Stan dziwny = (Stan)99;               // UWAGA: to sie kompiluje i dziala!
Console.WriteLine(dziwny);            // 99 - nie ma takiej nazwy
Console.WriteLine(Enum.IsDefined(dziwny));   // False

class Sprzet
{
    public string Nazwa { get; }
    public Stan Stan { get; private set; }

    public Sprzet(string nazwa)
    {
        Nazwa = nazwa;
        Stan = Stan.Dostepny;
    }

    public bool Wypozycz(string komu)
    {
        if (Stan != Stan.Dostepny)
        {
            Console.WriteLine($"{Nazwa}: nie mozna wypozyczyc, stan {Stan}");
            return false;
        }
        Stan = Stan.Wypozyczony;
        Console.WriteLine($"{Nazwa}: wypozyczono dla {komu}");
        return true;
    }

    public void OddajDoNaprawy()
    {
        Stan = Stan.WNaprawie;
    }
}

static string Komunikat(Stan s)
{
    return s switch
    {
        Stan.Dostepny    => "mozna wypozyczyc",
        Stan.Wypozyczony => "u kogos w domu",
        Stan.WNaprawie   => "w serwisie",
        Stan.Wycofany    => "zdjete z inwentarza",
        _                => "stan nieznany"
    };
}

foreach (Stan s in Enum.GetValues<Stan>())
{
    Console.WriteLine($"{(int)s,2}  {s,-12}  {Komunikat(s)}");
}

Console.Write("Podaj stan (Dostepny/Wypozyczony/WNaprawie/Wycofany): ");
string? wpisane = Console.ReadLine();

if (Enum.TryParse<Stan>(wpisane, true, out Stan wynikStanu))
{
    Console.WriteLine($"rozpoznano: {wynikStanu}");
}
else
{
    Console.WriteLine("nie rozpoznano stanu");
}

[Flags]
enum Dostep
{
    Brak      = 0,
    Czytanie  = 1,      // 0001
    Zapis     = 2,      // 0010
    Usuwanie  = 4,      // 0100
    Drukowanie = 8      // 1000
}

Dostep uczen = Dostep.Czytanie | Dostep.Drukowanie;

Console.WriteLine(uczen);                          // Czytanie, Drukowanie
Console.WriteLine((int)uczen);                     // 9  (1 + 8)
Console.WriteLine(uczen.HasFlag(Dostep.Zapis));    // False
Console.WriteLine(uczen.HasFlag(Dostep.Czytanie)); // True

uczen = uczen | Dostep.Zapis;                      // dodanie uprawnienia
Console.WriteLine(uczen);                          // Czytanie, Zapis, Drukowanie

uczen = uczen & ~Dostep.Drukowanie;                // odebranie uprawnienia
Console.WriteLine(uczen);                          // Czytanie, Zapis

struct Punkt
{
    public int X { get; }
    public int Y { get; }

    public Punkt(int x, int y)
    {
        X = x;
        Y = y;
    }

    public override string ToString()
    {
        return $"({X}, {Y})";
    }
}

Punkt a = new Punkt(3, 4);
Punkt b = a;                   // KOPIA calej wartosci, nie drugie odwolanie

Console.WriteLine(a);          // (3, 4)
Console.WriteLine(b);          // (3, 4)
Console.WriteLine(a.Equals(b));// True - porownuje pola, nie adresy

Punkt zero = default;          // (0, 0) - pola dostaja wartosci domyslne
Console.WriteLine(zero);

// Program.cs - pelny plik
List<Sprzet> magazyn = new List<Sprzet>
{
    new Sprzet("Laptop Dell", Kategoria.Komputer, new Punkt(1, 2)),
    new Sprzet("Projektor Epson", Kategoria.Prezentacja, new Punkt(1, 5)),
    new Sprzet("Drukarka HP", Kategoria.Komputer, new Punkt(3, 1)),
    new Sprzet("Mikroskop", Kategoria.Laboratorium, new Punkt(4, 4))
};

Console.WriteLine("=== stan magazynu ===");
Pokaz(magazyn);

Console.WriteLine();
Console.WriteLine("=== operacje ===");
magazyn[0].Wypozycz("Kasia Nowak");
magazyn[0].Wypozycz("Marek Lis");          // juz wypozyczony
magazyn[1].OddajDoNaprawy();
magazyn[3].Wycofaj();

Console.WriteLine();
Console.WriteLine("=== stan po operacjach ===");
Pokaz(magazyn);

Console.WriteLine();
Console.WriteLine("=== zestawienie po stanach ===");
foreach (Stan s in Enum.GetValues<Stan>())
{
    int ile = 0;
    foreach (Sprzet sp in magazyn)
    {
        if (sp.StanSprzetu == s)
        {
            ile++;
        }
    }
    Console.WriteLine($"{s,-12} {ile}  ({Komunikat(s)})");
}

Console.WriteLine();
Console.WriteLine("=== uprawnienia ===");
Dostep uczen = Dostep.Czytanie;
Dostep nauczyciel = Dostep.Czytanie | Dostep.Zapis | Dostep.Usuwanie;

Sprawdz("uczen", uczen);
Sprawdz("nauczyciel", nauczyciel);

Console.WriteLine();
Console.WriteLine("=== polki sa kopiowane, nie wspoldzielone ===");
Punkt polka = magazyn[0].Polka;
Punkt kopia = polka;
Console.WriteLine($"polka {polka}, kopia {kopia}, rowne: {polka.Equals(kopia)}");

static void Pokaz(List<Sprzet> lista)
{
    foreach (Sprzet s in lista)
    {
        Console.WriteLine($"{s.Nazwa,-18} {s.KategoriaSprzetu,-13} polka {s.Polka,-8} {s.StanSprzetu}");
    }
}

static string Komunikat(Stan s)
{
    return s switch
    {
        Stan.Dostepny    => "mozna wypozyczyc",
        Stan.Wypozyczony => "u kogos w domu",
        Stan.WNaprawie   => "w serwisie",
        Stan.Wycofany    => "zdjete z inwentarza",
        _                => "stan nieznany"
    };
}

static void Sprawdz(string kto, Dostep d)
{
    Console.WriteLine($"{kto,-11} {d,-30} zapis: {d.HasFlag(Dostep.Zapis)}");
}


enum Stan
{
    Dostepny,
    Wypozyczony,
    WNaprawie,
    Wycofany
}

enum Kategoria
{
    Inne = 0,
    Komputer = 1,
    Prezentacja = 2,
    Laboratorium = 3
}

[Flags]
enum Dostep
{
    Brak = 0,
    Czytanie = 1,
    Zapis = 2,
    Usuwanie = 4
}

struct Punkt
{
    public int Rzad { get; }
    public int Miejsce { get; }

    public Punkt(int rzad, int miejsce)
    {
        Rzad = rzad;
        Miejsce = miejsce;
    }

    public override string ToString()
    {
        return $"{Rzad}/{Miejsce}";
    }
}

class Sprzet
{
    public string Nazwa { get; }
    public Kategoria KategoriaSprzetu { get; }
    public Punkt Polka { get; }
    public Stan StanSprzetu { get; private set; }

    public Sprzet(string nazwa, Kategoria kategoria, Punkt polka)
    {
        Nazwa = nazwa;
        KategoriaSprzetu = kategoria;
        Polka = polka;
        StanSprzetu = Stan.Dostepny;
    }

    public bool Wypozycz(string komu)
    {
        if (StanSprzetu != Stan.Dostepny)
        {
            Console.WriteLine($"{Nazwa}: odmowa, stan {StanSprzetu}");
            return false;
        }
        StanSprzetu = Stan.Wypozyczony;
        Console.WriteLine($"{Nazwa}: wypozyczono dla {komu}");
        return true;
    }

    public void OddajDoNaprawy()
    {
        StanSprzetu = Stan.WNaprawie;
        Console.WriteLine($"{Nazwa}: oddane do serwisu");
    }

    public void Wycofaj()
    {
        StanSprzetu = Stan.Wycofany;
        Console.WriteLine($"{Nazwa}: wycofane z inwentarza");
    }
}