În ce moment și în ce condiții începe să funcționeze…

Dispatch-ul metodelor (method dispatch) în Swift determină ce cod va fi executat la apelarea unei metode a unui obiect. Alegerea tipului de dispatch are loc în momentul compilării codului Swift.

Există trei tipuri principale de dispatch în Swift:

Dispatch direct (Direct Dispatch):
- Cel mai rapid.
- Adresa funcției este cunoscută în timpul compilării.
- Se aplică implicit pentru:
  - struct și enum (deoarece nu suportă moștenirea claselor).
  - Metodele final ale claselor.
  - Metodele private ale claselor (internal și public nu suportă dispatch direct).
  - Funcții globale.
  - Metode statice.
  - Extensii.
Dispatch pe tabel (Table Dispatch):
- Se folosește pentru class, când este necesar polimorfism și moștenire.
- Adresa implementării concrete a metodei este determinată în timpul execuției (runtime) folosind tabelul metodelor virtuale (vtable - Virtual Table).
- Fiecare clasă are propriul vtable, care conține pointeri către implementările metodelor.
- Suportă moștenirea și suprascrierea metodelor.
```
class Animal { // Se va aplica Table Dispatch
    func speak() {
        print("Sunet necunoscut")
    }
}

class Dog: Animal { // Suprascriere, folosește vtable
    override func speak() {
        print("Ham")
    }
}
```
Dispatch pe tabelul martorilor (Witness Table Dispatch):
- Se folosește pentru protocoale (protocol).
- Este similar cu dispatch-ul pe tabel, dar folosește un tabel de martori (witness table) pentru a găsi implementarea metodei protocolului pentru un anumit tip.
- Permite utilizarea polimorfismului cu protocoale.
```
protocol Speakable { // Se va aplica Witness Table Dispatch
    func speak()
}

struct Cat: Speakable { // Implementarea protocolului
    func speak() {
        print("Miau")
    }
}
```

Condiții care influențează alegerea:

Tipul de date: struct, enum, class, protocol.
Modificatori de acces: final, private, internal, public.
Moștenire: Capacitatea de a suprascrie metode.
Conformitate la protocoale: Implementarea metodelor protocolului.
Contextul de apel: Apelul printr-un tip concret sau printr-un protocol/clasă de bază.

Compilatorul Swift încearcă să utilizeze dispatch-ul direct ori de câte ori este posibil pentru a optimiza performanța, dar, dacă este necesar, trece la dispatch pe tabel sau pe tabelul martorilor pentru a suporta polimorfismul și moștenirea. Marcarea explicită a metodelor ca final sau private permite forțarea utilizării dispatch-ului direct.

În ce moment și în ce condiții începe să funcționeze gestionarea în Swift?