Per quali motivi useresti un'estensione di classe separata per ogni delegato in Swift?

Stavo lavorando attraverso un tutorial di Ray Wenderlich e ho notato che l'autore utilizza le estensioni di classe per contenere callback delegati anziché farli gestire nella classe stessa, ad esempio:

delegare callback all'interno dell'estensione di classe:

extension LogsViewController : UIPopoverPresentationControllerDelegate {
    func adaptivePresentationStyleForPresentationController(controller: UIPresentationController, traitCollection: UITraitCollection) -> UIModalPresentationStyle {
        ...
    }
}

al contrario di averlo contenuto nella classe:

delegare callback all'interno della classe:

class LogsViewController : UITableViewController, UIPopoverPresentationControllerDelegate {
    func adaptivePresentationStyleForPresentationController(controller: UIPresentationController, traitCollection: UITraitCollection) -> UIModalPresentationStyle {
        ...
    }
}

L'ho trovato strano e interessante allo stesso tempo. Ha un file dedicato solo alle estensioni della classe LogsViewController denominato "LogsViewControllerExtension.swift" e ha un'estensione diversa per ciascun protocollo delegato: UITableViewDataSource, UISplitViewDelegate, ecc.

più estensioni di classe ciascuna con callback delegati all'interno del proprio file:

extension LogsViewController: UISplitViewControllerDelegate {
    ... callbacks
}

extension LogsViewController : UIPopoverPresentationControllerDelegate {
    ... callbacks
}

Perché?

Quali vantaggi ci sono nel fare questo? Posso vedere dove potrebbe essere un po 'più leggibile separarlo ma allo stesso tempo è un livello di indiretta. Ci sono principi di OO che supportano o non fanno questo?

Non so perché hai detto che aggiunge un livello di riferimento indiretto. Forse vuoi dire qualcosa di diverso da quello rispetto al significato tradizionale, perché non esiste alcuna indiretta aggiuntiva creata facendo questo. Ma perché farlo?

Lo faccio perché è più modulare. Tutto il codice richiesto dall'interfaccia è raggruppato in un unico posto (tranne le proprietà effettive.) Se in seguito scelgo di creare una classe separata per implementare quel protocollo (e quindi introdurre un livello effettivo di indiretto), tutto ciò di cui ho bisogno fare è cambiare l'estensione in una classe a sé stante (passando le proprietà necessarie attraverso una funzione init) e creare una proprietà su ViewController per creare un'istanza dell'oggetto.

Ho anche inserito tutte le funzioni private che sono utilizzate solo dalle funzioni di quel protocollo nell'estensione. Non sono arrivato al punto di creare un file completamente separato per l'estensione, ma farlo chiarisce che quelle funzioni private sono solo per quel protocollo.

E in ogni caso, le persone spesso si lamentano dei fat view controller e rompere un controller di visualizzazione in questo modo aiuta a mantenerlo meglio organizzato, anche se in realtà non rende il controller di vista più sottile.

Come ha detto Daniel in merito all'indirizzamento indiretto, non esiste alcun livello.
Sono d'accordo e vorrei aggiungere una funzionalità extra potente delle estensioni di protocollo che conoscevo di recente.

Supponi di avere un protocollo, didCopyTextad esempio. Lo implementerai come:

protocol didCopyText {
  var charachtersCount: Int {get}
  func addToClipboardWith(text: String)
}

In Swift, proprietà e metodi non sono implementati nella dichiarazione del Protocollo, si vorrebbe scrivere l'implementazione in ogni classe conforme a didCopyText, con un numero incrementale di classi conformi a questo protocollo con la stessa implementazione, finirebbe con un semplice disordine codice ripetuto. Ecco dove le estensioni di protocollo sono utili.

protocol didCopyText {
var charachtersCount: Int {
    get {
     // implementation
    }
}
func addToClipboardWith(text: String) {
      // implementation
 }
}

Con l'implementazione delle proprietà e dei metodi del protocollo. Ora, qualsiasi classe conforme a questo protocollo, utilizzerà la stessa implementazione.

Supponiamo che la tua classe supporti tre protocolli e quindi devi aggiungere tre serie di funzioni. L'unico scopo di queste funzioni è supportare un protocollo, quindi è necessaria della documentazione.

Tuttavia, se si aggiunge un'estensione per ciascun protocollo e in ciascuna estensione si implementano esattamente le funzioni necessarie per quell'unico protocollo, ciò rende il codice molto più leggibile.

Molto probabilmente non li metterei in file separati a meno che queste estensioni non siano veramente grandi.