Klasa abstrakcyjna vs interfejs w C
Podstawowa definicja
// Interfejs - czysty kontrakt, żadnej implementacji (do C# 7)
public interface IOrderValidator
{
bool Validate(Order order);
}
// Klasa abstrakcyjna - może mieć implementację, może być częściowa
public abstract class OrderProcessorBase
{
protected readonly ILogger _logger;
protected OrderProcessorBase(ILogger logger) // konstruktor - czego interfejs nie ma
{
_logger = logger;
}
public abstract void Process(Order order); // metoda BEZ implementacji - musi być nadpisana
public void LogProcessing(Order order) // metoda Z implementacją - dziedziczona wprost
{
_logger.Log($"Przetwarzanie zamówienia {order.Id}");
}
}
Kluczowa różnica #1: Dziedziczenie wielokrotne
// ✅ Klasa może implementować WIELE interfejsów
public class Order : IValidatable, IComparable<Order>, IDisposable
{
public bool Validate() => true;
public int CompareTo(Order other) => 0;
public void Dispose() { }
}
// ❌ Klasa może dziedziczyć TYLKO z JEDNEJ klasy (abstrakcyjnej lub nie)
public class SpecialOrder : OrderProcessorBase, AnotherBaseClass // BŁĄD KOMPILACJI
{
}
To jest najczęściej wymieniana różnica na rozmowach - C# (jak większość języków OOP poza C++) nie wspiera wielokrotnego dziedziczenia klas, ale wspiera implementowanie wielu interfejsów. To bezpośrednio wraca do Interface Segregation Principle z SOLID - dlatego lepiej mieć wiele małych interfejsów niż próbować "upchnąć" wszystko w jedną hierarchię klas.
Kluczowa różnica #2: Stan (pola)
public abstract class RepositoryBase<T>
{
protected readonly AppDbContext _context; // ✅ Klasa abstrakcyjna MOŻE mieć pola/stan
protected RepositoryBase(AppDbContext context) => _context = context;
}
public interface IRepository<T>
{
// ❌ Interfejs NIE MOŻE mieć pól (tylko właściwości - bez backing fieldów)
// AppDbContext Context; // błąd kompilacji
}
Klasa abstrakcyjna może trzymać prawdziwy stan (pola instancyjne) i logikę operującą na tym stanie. Interfejs definiuje tylko co klasa implementująca musi udostępnić, nie jak to przechowuje.
Kluczowa różnica #3: Konstruktory
public abstract class ViewModelBase
{
protected ViewModelBase(ILogger logger) // ✅ konstruktor - inicjalizacja wspólnego stanu
{
Logger = logger;
}
protected ILogger Logger { get; }
}
public interface IViewModel
{
// ❌ interfejs NIE MOŻE mieć konstruktora
}
To ma realną konsekwencję praktyczną - klasa abstrakcyjna może wymusić inicjalizację wspólnych zależności przez konstruktor (jak w ViewModelBase), interfejs nie ma takiej możliwości - implementująca klasa musi sama zadbać o inicjalizację.
Kluczowa różnica #4: Modyfikatory dostępu
public abstract class OrderProcessorBase
{
public abstract void Process(Order order);
protected virtual void Validate(Order order) { } // protected - dostępne tylko dla klas pochodnych
private void InternalHelper() { } // private - w ogóle niedostępne z zewnątrz
}
public interface IOrderProcessor
{
void Process(Order order); // wszystko w interfejsie jest implicitly PUBLIC
// protected void Validate(Order order); // od C# 8+ MOŻLIWE (default interface methods), ale rzadko używane
}
Klasa abstrakcyjna daje pełną kontrolę nad widocznością (public, protected, private) - interfejs tradycyjnie wymusza wszystko jako public (choć nowoczesny C# częściowo to złagodził, patrz niżej).
Domyślna implementacja w interfejsach (C# 8+) - zaciera granicę
public interface ILogger
{
void Log(string message);
// Domyślna implementacja - NOWOŚĆ od C# 8.0
void LogError(string message) => Log($"BŁĄD: {message}"); // implementacja WEWNĄTRZ interfejsu
}
public class ConsoleLogger : ILogger
{
public void Log(string message) => Console.WriteLine(message);
// LogError NIE musi być nadpisane - dziedziczy domyślną implementację
}
To zbliża interfejsy do klas abstrakcyjnych (można mieć "gotowy" kod), ale wciąż interfejs nie ma pól/stanu ani konstruktorów - to jest fundamentalna granica, której default interface methods nie przekraczają.
Kiedy używać klasy abstrakcyjnej
Gdy klasy pochodne są ze sobą blisko powiązane i dzielą wspólną implementację - klasyczny Template Method Pattern, o którym mówiliśmy przy Inversion of Control:
public abstract class OrderProcessorBase
{
// Kontroluje KOLEJNOŚĆ - wspólna dla wszystkich podklas
public void Process(Order order)
{
Validate(order);
Save(order);
Notify(order);
}
protected virtual void Validate(Order order) { /* domyślna walidacja */ }
protected abstract void Save(Order order); // KAŻDA podklasa MUSI dostarczyć własną
protected virtual void Notify(Order order) { /* domyślne powiadomienie */ }
}
public class StandardOrderProcessor : OrderProcessorBase
{
protected override void Save(Order order) { /* zapis standardowy */ }
// Validate i Notify - dziedziczone bez zmian, bo pasuje domyślne zachowanie
}
To pokazuje siłę klasy abstrakcyjnej - wspólna logika i kolejność wykonania żyje w jednym miejscu, podklasy dostarczają tylko to, co faktycznie się różni.
Kiedy używać interfejsu
Gdy chcesz zdefiniować kontrakt, niekoniecznie powiązany hierarchią klas - klasy zupełnie niepowiązane mogą implementować ten sam interfejs:
public interface IComparable<T> { int CompareTo(T other); }
public class Order : IComparable<Order> { public int CompareTo(Order other) => 0; }
public class Product : IComparable<Product> { public int CompareTo(Product other) => 0; }
// Order i Product nie mają ze sobą NIC wspólnego poza tym jednym kontraktem
Wzorzec, który już wielokrotnie widzieliśmy - DI operuje właśnie na interfejsach:
public interface IOrderService { Task<Order> GetOrderAsync(int id); }
services.AddScoped<IOrderService, OrderService>();
Interfejs jest tu preferowany, bo pozwala na łatwą podmianę implementacji (mock w testach, inna implementacja w runtime) - to dokładnie Dependency Inversion Principle z SOLID.
Konkretny przykład - dlaczego ViewModelBase to klasa abstrakcyjna, a IOrderService to interfejs
// Klasa abstrakcyjna - bo WSZYSTKIE ViewModel dzielą DOKŁADNIE tę samą logikę SetProperty
public abstract class ViewModelBase : INotifyPropertyChanged
{
public event PropertyChangedEventHandler PropertyChanged;
protected void SetProperty<T>(ref T field, T value, [CallerMemberName] string propertyName = null)
{
if (EqualityComparer<T>.Default.Equals(field, value)) return;
field = value;
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
}
}
// Interfejs - bo różne implementacje (UserService, MockUserService w testach)
// mają RÓŻNĄ logikę wewnątrz, łączy je tylko kontrakt
public interface IUserService
{
Task<User> GetUserAsync(string id);
}
ViewModelBase dostarcza gotowy, współdzielony kod (implementację SetProperty) - to jest to, czego interfejs (przed C# 8) nie potrafił. IUserService to czysty kontrakt - każda implementacja robi coś zupełnie innego wewnątrz.
Można łączyć oba naraz
public interface IOrderProcessor
{
void Process(Order order);
}
public abstract class OrderProcessorBase : IOrderProcessor // implementuje interfejs
{
public void Process(Order order) // dostarcza wspólną implementację
{
Validate(order);
Save(order);
}
protected virtual void Validate(Order order) { }
protected abstract void Save(Order order);
}
public class StandardOrderProcessor : OrderProcessorBase
{
protected override void Save(Order order) { }
}
To jest częsty, dobry wzorzec - interfejs jako kontrakt widoczny na zewnątrz (do DI, do mockowania w testach), klasa abstrakcyjna jako wspólna implementacja dla rodziny pokrewnych klas wewnątrz.
Tabela porównawcza
| Klasa abstrakcyjna | Interfejs | |
|---|---|---|
| Dziedziczenie wielokrotne | ❌ Tylko jedna klasa bazowa | ✅ Wiele interfejsów naraz |
| Pola/stan | ✅ Tak | ❌ Nie (tylko properties bez backing field) |
| Konstruktor | ✅ Tak | ❌ Nie |
| Implementacja metod | ✅ Dowolna (pełna, częściowa, brak) | ⚠️ Częściowo od C# 8 (default methods) |
| Modyfikatory dostępu | ✅ public/protected/private | Domyślnie public (częściowo złagodzone w C# 8+) |
| Kiedy używać | Blisko powiązane klasy ze wspólną logiką (Template Method) | Kontrakt dla niepowiązanych klas, DI, testowalność |
Pytanie-pułapka na rozmowie
"Czy klasa abstrakcyjna może nie mieć żadnej metody abstract?" - Tak, technicznie może. Sam modyfikator abstract na klasie oznacza tylko "nie można stworzyć instancji tej klasy bezpośrednio" (new OrderProcessorBase() się nie skompiluje) - może zawierać wyłącznie metody virtual/zwykłe, bez ani jednej abstract. To rzadkie w praktyce (zwykle jest jakiś powód, żeby wymusić nadpisanie), ale pokazuje, że abstract class to przede wszystkim "nie instancjonuj mnie bezpośrednio, jestem bazą do dziedziczenia", niezależnie od tego, ile ma metod abstrakcyjnych.