Qu’est-ce qui est trop pour transmettre des données via l’injection de dépendance ?

Le sujet de l’injection de dépendances est celui qui existe depuis un certain temps dans les cercles de programmation orientés objet. Parfois, nous le voyons dans WordPress ; parfois nous ne le faisons pas.

J’en suis fan mais, honnêtement, je ne suis pas toujours sûr de la quantité d’informations à injecter dans une classe. Je veux dire, disons qu’on nous donne deux classes, et que l’une contient les informations dont l’autre a besoin.

• N’injectons-nous aucune classe dans une autre classe ?
• Injectons-nous seulement une information (qu’il s’agisse d’une chaîne, d’un entier, d’une structure de données ou autre) dans l’autre classe ?

Je ne pense pas qu’il y ait une règle stricte pour cela, mais il est probablement prudent de dire qu’il est préférable d’injecter uniquement les données dont vous avez besoin. Mais alors cela pose la question de savoir comment préparer les données à injecter dans une classe donnée ?

• Créez-vous une méthode dans une classe et la transmettez-vous dans une autre ?
• Y transmettez-vous une information privée ou protégée ?

Là encore, je pense que cela dépend si quelque chose doit arriver à l’information avant qu’elle ne soit transmise à une classe.

Quoi qu’il en soit, je pourrais revenir sur ce sujet pour le reste du message et ne jamais arriver à une conclusion, alors pourquoi ne pas travailler sur un code source jusqu’à ce qu’il y ait quelque chose de raisonnable.

Commençons par dire que nous avons un fichier de classe de plug-in principal et que cette classe est responsable de la maintenance d’informations telles que :

• le chemin du plugin,
• l’URL du plugin,
• si le plugin est chargé ou non,
• l’écran en cours de visualisation,
• et les classes auxquelles il doit diffuser (pensez pub/sub) certaines informations.

Peut-être qu’un squelette ou un bout de la classe pourrait ressembler à ceci :

<?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(...)
        ];
    }
}

Alors commençons vraiment large. Disons que nous voulons prendre toute la classe et la transmettre à l’une des classes à laquelle elle diffuse des informations.

Si tel était le cas, cela pourrait ressembler à ceci :

<?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)
        ];
    }
}

Mais l’un des défis avec cela est qu’il transmet beaucoup plus d’informations que nécessaire dans une autre classe. De plus, il transmet des informations qui incluent des informations sur la classe dans laquelle ses informations sont transmises.

Supposons donc que nous voulions prendre du recul et simplement transmettre l’une des informations privées. C’est simple, non? Cela finit par ressembler à ceci :

<?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)
        ];
    }
}

Et cela peut être tout à fait suffisant dans certains cas. Mais, comme mentionné précédemment, il y a aussi des moments où nous voulons prendre l’information, la traiter, puis la transmettre à une classe.

Pour ce faire, il suffit de définir une méthode, de lui faire traiter les informations, puis de transmettre la valeur de retour à la classe qui a besoin des informations :

<?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’idée derrière cette discussion est apparue lorsque j’ai travaillé sur une révision de code pour un projet récent et que j’ai discuté des différentes options permettant de transmettre des informations à une classe.

J’ai donc commencé large (malgré ce qui est nécessaire, même compte tenu du processus de réflexion ci-dessus), puis je l’ai réduit à ce qui est seulement nécessaire.