Che cos’è troppo per passare i dati tramite l’iniezione di dipendenza?

L’argomento dell’iniezione di dipendenza è in circolazione da un po’ di tempo nei circoli della programmazione orientata agli oggetti. A volte lo vediamo in WordPress; a volte no.

Ne sono un fan ma, onestamente, però, non sono sempre sicuro di quante informazioni inserire in una classe. Voglio dire, diciamo che ci vengono date due classi e una contiene le informazioni di cui l’altra ha bisogno.

• Non iniettiamo nessuna classe in un’altra classe?
• Iniettiamo solo un’informazione (che sia una stringa, un intero, una struttura dati o altro) nell’altra classe?

Non penso che ci sia una regola rigida per questo, ma probabilmente è sicuro dire che è meglio iniettare solo i dati di cui hai bisogno. Ma allora questo solleva una domanda su come preparare i dati da iniettare in una data classe?

• Crei un metodo in una classe e lo passi in un’altra?
• Ci passi un’informazione privata o protetta?

Poi di nuovo, penso che dipenda se deve succedere qualcosa alle informazioni prima che vengano passate in una classe.

Ad ogni modo, potrei andare avanti e indietro su questo per il resto del post e non arrivare mai a una conclusione, quindi perché non lavorare con un codice sorgente finché non c’è qualcosa di ragionevole.

Iniziamo dicendo che abbiamo un file di classe del plugin principale e questa classe è responsabile del mantenimento di informazioni come:

• il percorso del plugin,
• l’URL del plugin,
• indipendentemente dal fatto che il plugin sia caricato o meno,
• lo schermo attualmente visualizzato,
• e le classi a cui ha bisogno di trasmettere (pensa pub/sub) determinate informazioni.

Forse uno scheletro o uno stub della classe potrebbe assomigliare a questo :

<?php

class Plugin
{
    protected $plugin_path;

    protected $plugin_url;

    private $loaded;

    public function __construct($file)
    {
        $this->loaded         = false;
        $this->plugin_path    = plugin_dir_path($file);
        $this->plugin_url     = plugin_dir_url($file);
    }

    public function isLoaded()
    {
        return $this->loaded;
    }

    public function load()
    {
      // ...
    }

    private function isCurrentAdminStatus()
    {
      // ...
    }

    public function getSubscribers()
    {
        return [
          new OtherPluginClass(...)
        ];
    }
}

Allora cominciamo davvero in largo. Supponiamo di voler prendere l’intera classe e passarla a una delle classi a cui trasmette informazioni.

Se così fosse, potrebbe apparire così :

<?php

class Plugin
{
    protected $plugin_path;

    protected $plugin_url;

    private $loaded;

    public function __construct($file)
    {
        $this->loaded         = false;
        $this->plugin_path    = plugin_dir_path($file);
        $this->plugin_url     = plugin_dir_url($file);
    }

    public function isLoaded()
    {
        return $this->loaded;
    }

    public function load()
    {
      // ...
    }

    private function isCurrentAdminStatus()
    {
      // ...
    }

    public function getSubscribers()
    {
        return [
          new OtherPluginClass($this)
        ];
    }
}

Ma una delle sfide con questo è che passa molte più informazioni del necessario in un’altra classe. Inoltre, trasmette informazioni che includono informazioni sulla classe in cui le sue informazioni passano.

Quindi diciamo che vogliamo fare un passo indietro e passare semplicemente una delle informazioni private. Questo è semplice, giusto? Finisce per assomigliare a questo :

<?php

class Plugin
{
    protected $plugin_path;

    protected $plugin_url;

    private $loaded;

    public function __construct($file)
    {
        $this->loaded         = false;
        $this->plugin_path    = plugin_dir_path($file);
        $this->plugin_url     = plugin_dir_url($file);
    }

    public function isLoaded()
    {
        return $this->loaded;
    }

    public function load()
    {
      // ...
    }

    private function isCurrentAdminStatus()
    {
      // ...
    }

    public function getSubscribers()
    {
        return [
          new OtherPluginClass($this->plugin_path)
        ];
    }
}

E questo può essere del tutto sufficiente per alcuni casi. Ma, come accennato in precedenza, ci sono anche momenti in cui vogliamo prendere le informazioni, elaborarle e poi passarle in una classe.

Per fare ciò, dobbiamo semplicemente definire un metodo, farlo elaborare le informazioni, quindi passare il valore restituito nella classe che ha bisogno delle informazioni :

<?php

class Plugin
{
    protected $plugin_path;

    protected $plugin_url;

    private $loaded;

    public function __construct($file)
    {
        $this->loaded         = false;
        $this->plugin_path    = plugin_dir_path($file);
        $this->plugin_url     = plugin_dir_url($file);
    }

    public function isLoaded()
    {
        return $this->loaded;
    }

    public function load()
    {
      // ...
    }

    private function isCurrentAdminStatus()
    {
      // ...
    }

    public function getSubscribers()
    {
        return [
          new OtherPluginClass($this->isCurrentAdminStatus())
        ];
    }
}

L’idea alla base di questa discussione è nata lavorando su una revisione del codice per un progetto recente e parlando delle varie opzioni in cui le informazioni potevano essere passate in una classe.

Quindi ho iniziato in modo ampio (nonostante ciò che è necessario anche dato il processo di pensiero sopra) e poi l’ho ristretto a ciò che è solo necessario.