Modyfikatory dostępu

Modyfikatory dostępu w C# to słowa kluczowe, które określają, z jakiego poziomu (czyli z jakiej części programu) można uzyskać dostęp do danej klasy, metody, pola lub właściwości. Dzięki nim programista może kontrolować, które elementy klasy są dostępne „na zewnątrz”, a które są chronione przed dostępem z innych klas lub przestrzeni nazw.

Rodzaje modyfikatorów dostępu

W C# dostępnych jest kilka modyfikatorów dostępu. Każdy z nich ma inny poziom ochrony:

a) public

• Zapewnia pełny dostęp do elementu z każdego miejsca w programie. Oznacza to, że element oznaczony jako public może być używany zarówno w tej samej klasie, w której został zdefiniowany, jak i w innych klasach oraz przestrzeniach nazw.

Przykład użycia public:

public class Samochod
{
    public string Marka;

    public void WyswietlMarke()
    {
        Console.WriteLine("Marka: " + Marka);
    }
}

Samochod auto = new Samochod();
auto.marka = "Toyota";  // Możemy ustawić wartość, bo pole jest publiczne
auto.WyswietlMarke();    // Wypisze: Marka: Toyota

Element public może być używany wszędzie, zarówno w tej samej klasie, jak i poza nią.

b) private

• Zapewnia dostęp tylko z wewnątrz klasy, w której element został zdefiniowany. Element oznaczony jako private jest niedostępny dla innych klas ani instancji tej samej klasy.

Przykład użycia private:

public class Samochod
{
    private string numerSeryjny;  // Tylko dostępne w tej klasie

    public Samochod(string numer)
    {
        numerSeryjny = numer;
    }

    public void WyswietlNumerSeryjny()
    {
        Console.WriteLine("Numer seryjny: " + numerSeryjny);
    }
}

Samochod auto = new Samochod("12345ABC");
// auto.numerSeryjny = "54321";  // Błąd - pole numerSeryjny jest prywatne
auto.WyswietlNumerSeryjny();  // Wypisze: Numer seryjny: 12345ABC

private chroni dane przed dostępem z zewnątrz, zapewniając bezpieczeństwo wewnętrznych szczegółów klasy. Można jednak udostępniać te dane za pomocą metod publicznych (jak w przykładzie z WyswietlNumerSeryjny).

c) protected

• Zapewnia dostęp do elementu z wewnątrz klasy i jej klas dziedziczących. Elementy oznaczone jako protected są chronione przed dostępem z zewnątrz, ale są dostępne dla klas, które dziedziczą po danej klasie.

Przykład użycia protected:

public class Pojazd
{
    protected string numerRejestracyjny;  // Dostępne w klasach dziedziczących

    public Pojazd(string numer)
    {
        numerRejestracyjny = numer;
    }
}

public class Samochod : Pojazd
{
    public Samochod(string numer) : base(numer) {}

    public void WyswietlNumerRejestracyjny()
    {
        Console.WriteLine("Numer rejestracyjny: " + numerRejestracyjny);  // Dostępne
    }
}

Samochod auto = new Samochod("XYZ1234");
auto.WyswietlNumerRejestracyjny();  // Wypisze: Numer rejestracyjny: XYZ1234

protected chroni elementy klasy przed dostępem z zewnątrz, ale pozwala na ich wykorzystanie w klasach dziedziczących.

d) internal

• Zapewnia dostęp do elementu z wewnątrz tego samego assembly (projektu). Oznacza to, że element oznaczony jako internal jest dostępny dla wszystkich klas w tej samej aplikacji, ale nie dla kodu z innych bibliotek lub aplikacji.

Przykład użycia internal:

internal class Silnik
{
    internal void Uruchom()
    {
        Console.WriteLine("Silnik uruchomiony");
    }
}

class Program
{
    static void Main()
    {
        Silnik silnik = new Silnik();
        silnik.Uruchom();  // Dostępne, bo klasy są w tym samym projekcie
    }
}

internal pozwala na dostęp w obrębie tego samego projektu, ale blokuje dostęp z innych projektów.

e) protected internal

• Łączy cechy modyfikatorów protected i internal. Elementy oznaczone tym modyfikatorem są dostępne z wewnątrz tej samej aplikacji (assembly) oraz z klas dziedziczących, nawet jeśli są w innym projekcie.

Przykład:

public class Pojazd
{
    protected internal string numerRejestracyjny = "XYZ1234";
}

public class Samochod : Pojazd
{
    public void WyswietlNumer()
    {
        Console.WriteLine("Numer rejestracyjny: " + numerRejestracyjny);  // Dostępne
    }
}

class Program
{
    static void Main()
    {
        Samochod auto = new Samochod();
        auto.WyswietlNumer();  // Wypisze: Numer rejestracyjny: XYZ1234
    }
}

protected internal zapewnia elastyczność dostępu zarówno wewnątrz aplikacji, jak i w klasach dziedziczących w innych projektach.

f) private protected

• Zapewnia dostęp tylko w klasie i klasach dziedziczących, które znajdują się w tym samym assembly (projekcie). To bardziej restrykcyjna wersja modyfikatora protected internal.

Przykład:

public class Pojazd
{
    private protected string numerRejestracyjny = "XYZ1234";
}

public class Samochod : Pojazd
{
    public void WyswietlNumer()
    {
        Console.WriteLine("Numer rejestracyjny: " + numerRejestracyjny);  // Dostępne
    }
}

private protected ogranicza dostęp do klasy i klas dziedziczących w ramach tego samego projektu.

Modyfikator partial

Modyfikator partial pozwala na podział definicji klasy, struktury lub interfejsu na wiele plików. Każda część klasy oznaczona słowem kluczowym partial może być zdefiniowana w innym pliku, ale w czasie kompilacji są one traktowane jak jeden obiekt.

Przykład użycia partial:

Plik 1:

public partial class Samochod
{
    public string Marka;
}

Plik 2:

public partial class Samochod
{
    public void WyswietlMarke()
    {
        Console.WriteLine("Marka: " + Marka);
    }
}

// Tworzenie obiektu
Samochod auto = new Samochod();
auto.Marka = "Toyota";
auto.WyswietlMarke();  // Wypisze: Marka: Toyota

Modyfikator partial umożliwia dzielenie definicji klasy na kilka plików. Jest to przydatne w dużych projektach, aby kod był bardziej czytelny i zorganizowany.

Wszystkie części klasy muszą być oznaczone jako partial, a nazwy muszą być takie same.