Cambiare il percorso per rispettare la legge di Demeter

Suggerirei di fare qualcosa di simile al seguente:

class Task {
   public function prepareCharges() {
      $charges = new Charges();
      $distanceCharge = new Money();
      $charges->add('distance', $distanceCharge);

      $fixedCharge = new Money();
      $charges->add('fixed', $fixedCharge); 

      $this->owner->charge($charges);
   }
}

class Owner {
   public function charge(Charges $charges) {
       $this->plan->charge($charges);
   }
}

Fondamentalmente, invece di cercare di indurre in modo imbarazzante una situazione in cui hai riferimenti a tutti quegli oggetti, metti tutte le accuse all'interno di un oggetto valore e passane il proprietario.

L'intenzione della legge di Demeter è di minimizzare la conoscenza che una parte del tuo sistema ha su un'altra. Task non dovrebbe sapere Plan . Il tuo approccio di avere Owner richiama in Task con un Plan può seguire la lettera della Legge di Demetra, ma risulta in Task con conoscenza approfondita di Owner , precisamente ciò che Demeter sta provando a evitare. Faresti meglio a restituire il piano perché quel codice era più facile da seguire.

Solitamente useresti solo uno strato di riferimento indiretto ...

class Task {

    private $owner;

    public function prepareCharges() {
        $this->owner->chargeFor(...);
    }
...

class Owner {
    public chargeFor() {
        $plan = $this->getPlan();
        $plan.chargeFor(...)
        ...

Penso che dovresti rendere il proprietario responsabile della gestione dei loro addebiti e semplicemente passare l'attività al proprietario. In questo modo il compito non deve mai toccare il piano.

Non credo che la tua alternativa sia davvero molto meglio perché un compito deve ancora sapere di un piano e sapere che è responsabile della determinazione del costo.

Ecco un esempio, presumo che l'attività sia responsabile della determinazione della variabile di costo (tempo di esecuzione), che il piano sia responsabile della determinazione della tariffa per unità di costo variabile e che il cliente sia responsabile della contabilizzazione del costo accumulato nel tempo:

class Task {

    /**
     * @var Owner
     */
    private $owner;

    public function execute() {
        // Do whatever a task does
        $this->owner->charge($this);    
    }

   public function getExecutionTime() {
       return 10; // Just an example
   }
}

class Owner {

    private $plan;
    private $bill = 0;

    public function charge(Task $task) {
        $taskCost = $this->plan->calculateCost($task->getExecutionTime());
        $bill += $taskCost;
    }

}

class Plan {

    private $rate = 0.5;

    public function calculateCost($time) {
        return $rate * $time;
    }

}

Se i proprietari sono responsabili di invocare l'esecuzione dell'attività, potreste essere in grado di farla franca senza nemmeno passare il proprietario all'attività, potreste semplicemente richiamare l'attività e ottenere il tempo di esecuzione dall'interno del proprietario. In questo modo l'attività non dipende da un proprietario da eseguire, anche se altri aspetti dell'attività dipendono dall'avere un proprietario, quindi non sarebbe pratico.