Modyfikatory dostępu w C
public - widoczne wszędzie
public class Order
{
public int Id { get; set; } // dostępne z DOWOLNEGO miejsca - innej klasy, innego assembly
}
Brak jakichkolwiek ograniczeń widoczności. Używane dla API klasy, które ma być wywoływane z zewnątrz - np. metody serwisów wstrzykiwanych przez DI, właściwości DTO.
private - widoczne tylko wewnątrz tej samej klasy
public class OrderService
{
private readonly AppDbContext _context; // widoczne TYLKO wewnątrz OrderService
private bool IsValidOrder(Order order) => order.Items.Count > 0; // tylko ta klasa może wywołać
}
Domyślny modyfikator, jeśli nic nie napiszesz (dla pól i metod klasy - class sama w sobie domyślnie jest internal). Standard dla pól przechowujących zależności (_context, _logger) i metod pomocniczych niepotrzebnych na zewnątrz - hermetyzacja w czystej postaci.
protected - widoczne w tej klasie i klasach pochodnych
public abstract class ViewModelBase
{
protected void SetProperty<T>(ref T field, T value, [CallerMemberName] string propertyName = null)
{
// ...
}
}
public class OrderViewModel : ViewModelBase
{
public void UpdateStatus(string status)
{
SetProperty(ref _status, status); // ✅ dostępne, bo OrderViewModel DZIEDZICZY po ViewModelBase
}
}
var vm = new OrderViewModel();
vm.SetProperty(...); // ❌ Błąd - niedostępne z ZEWNĄTRZ, nawet jeśli masz instancję
Klasyczne zastosowanie w Template Method Pattern - metody pomocnicze, które mają być używane przez podklasy, ale nie przez "obcy" kod.
internal - widoczne w tym samym assembly (projekcie)
// W projekcie MyApp.Core
internal class DatabaseMigrationHelper
{
internal void RunMigration() { }
}
// W tym samym assembly (MyApp.Core) - OK
var helper = new DatabaseMigrationHelper();
// W INNYM assembly (np. MyApp.Web, referencujący MyApp.Core) - błąd kompilacji
var helper = new DatabaseMigrationHelper(); // ❌ niewidoczne
Przydatne dla klas/typów wewnętrznej implementacji biblioteki, które nie powinny być częścią publicznego API - konsument Twojej biblioteki (.dll) nie powinien mieć do nich dostępu, ale różne klasy wewnątrz tego samego projektu mogą się nawzajem widzieć.
protected internal - suma uprawnień (OR logiczny)
public class Base
{
protected internal void Method() { }
}
Widoczne, jeśli którykolwiek warunek jest spełniony: klasa pochodna (nawet w innym assembly) LUB dowolna klasa w tym samym assembly (nawet bez dziedziczenia).
// Ten sam assembly, BEZ dziedziczenia po Base
public class Unrelated
{
void Test(Base b) => b.Method(); // ✅ OK - ten sam assembly wystarcza
}
// Inny assembly, Z dziedziczeniem po Base
public class DerivedInOtherAssembly : Base
{
void Test() => Method(); // ✅ OK - dziedziczenie wystarcza, mimo innego assembly
}
// Inny assembly, BEZ dziedziczenia
public class UnrelatedInOtherAssembly
{
void Test(Base b) => b.Method(); // ❌ Błąd - ani ten sam assembly, ani dziedziczenie
}
private protected - iloczyn uprawnień (AND logiczny) - C# 7.2+
public class Base
{
private protected void Method() { }
}
Widoczne tylko, jeśli oba warunki są spełnione jednocześnie: klasa pochodna ORAZ w tym samym assembly.
// Ten sam assembly, dziedziczenie - JEDYNY przypadek, który działa
public class Derived : Base
{
void Test() => Method(); // ✅ OK
}
// Inny assembly, dziedziczenie - NIE wystarczy
public class DerivedInOtherAssembly : Base
{
void Test() => Method(); // ❌ Błąd - inny assembly, mimo dziedziczenia
}
To najbardziej restrykcyjna forma "protected" - przydatna, gdy chcesz udostępnić coś podklasom, ale tylko w obrębie własnej biblioteki, nie zewnętrznym konsumentom, którzy mogliby dziedziczyć po Twojej publicznej klasie bazowej.
Tabela zbiorcza
| Modyfikator | Ta sama klasa | Klasa pochodna (ten sam assembly) | Klasa pochodna (inny assembly) | Dowolna klasa (ten sam assembly) | Dowolna klasa (inny assembly) |
|---|---|---|---|---|---|
public |
✅ | ✅ | ✅ | ✅ | ✅ |
protected internal |
✅ | ✅ | ✅ | ✅ | ❌ |
internal |
✅ | ✅ | ❌ | ✅ | ❌ |
protected |
✅ | ✅ | ✅ | ❌ | ❌ |
private protected |
✅ | ✅ | ❌ | ❌ | ❌ |
private |
✅ | ❌ | ❌ | ❌ | ❌ |