Esiste un nome per questo motivo di progettazione, utilizzando ganci / callback?

Question

Esiste un nome per questo motivo di progettazione, utilizzando ganci / callback?

#1 da (6 voti)
#2 da (0 voti)

4

Ho visto / usato alcuni oggetti che hanno una struttura come questa, progettati per permettere ai bambini di estendere la funzionalità delle funzioni senza doverle sovrascrivere. C'è un nome per questo modello?

esempio di codice:

class CrudModel {
  public function create($data) {
    $data = $this->pre_create($data);
    //create logic
  }

  public function delete($data) {
    $data = $this->pre_delete($data);
    //delete logic
  }

  protected function pre_create($data) { //empty }
  protected function pre_delete($data) { //empty } 

}

class SpecificCrudModel extends Model {
    protected function pre_create($data) {
      //custom logic for this object.
    }

}

design-patterns

posta GSto 01.09.2011 - 16:46

fonte

2 risposte

0

Questo sembra un caso piuttosto standard di qualsiasi modello basato sull'ereditarietà, a seconda di come lo si usa. È piuttosto comune inserire qualsiasi codice di implementazione specifico in funzioni virtuali in un genitore astratto e implementarlo in una classe figlia.

Questo è letteralmente il caso esemplare in c ++; sembra che tu stia usando PHP, e questo è sicuramente il metodo preferito. Molto più facile da seguire rispetto all'utilizzo di callback. Se stai usando questo in un framework MVC (o costruendo uno) potresti voler anteporre un '_' alla chiamata dell'utility di setup.

risposta data 01.09.2011 - 17:09

fonte

Leggi altre domande sui tag design-patterns

Quando non riutilizzare il software? Quale tecnologia viene utilizzata per creare "Visual Studio 11"?

score 6 · Accepted Answer

Sembra un modello di metodo del modello , ma i metodi in questione non sono astratti e la classe figlio non viene costretti a implementarli. Direi che è solo un uso comune dell'ereditarietà o forse un modello di metodo del modello borderline.

Preferirei implementare queste cose tramite eventi / delegati / callback, comunque. È molto più chiaro di cosa puoi connettere e non puoi ignorare accidentalmente il comportamento necessario. È anche più flessibile.

@GSto

Ecco un esempio di utilizzo di callback con PHP. Non è elegante come in altre lingue con supporto di eventi nativi (come le offerte di C # per esempio), ma è flessibile e puoi registrare tali callback nel costruttore di una classe figlia, ad esempio. Questo sito web qui mi ha detto come implementare i callback in PHP, il cuore di esso è call_user_func funzione di PHP. Questo può registrare tutti i gestori che vuoi e qualsiasi cosa con un riferimento all'oggetto può registrare i gestori.

class Model {

    protected $_before_create_callbacks = array();
    protected $_after_create_callbacks = array();

    function register_before_create_handler($callback) {
        $this->_before_create_callbacks[] = $callback;
    }

    function register_after_create_handler($callback) {
        $this->_after_create_callbacks[] = $callback;
    }

    function create(){
        $this->before_create();

        //logic of create...

        $this->after_create();
    }

    protected function before_create() {
        foreach ($this->_before_create_callbacks as $callback){
            call_user_func($callback);
        }
    }

    protected function before_create() {
        foreach ($this->$_after_create_callbacks as $callback){
            call_user_func($callback);
        }
    }
}

function someFunction(){
    logSomething();
}

$anyModel->register_before_create_handler("someFunction");