¿Qué es demasiado para pasar datos a través de la inyección de dependencia?

El tema de la inyección de dependencias ha existido durante algún tiempo en los círculos de programación orientada a objetos. A veces lo vemos en WordPress; a veces no lo hacemos.

Soy fanático de eso, pero, sinceramente, no siempre estoy seguro de cuánta información inyectar en una clase. Quiero decir, digamos que nos dan dos clases, y una tiene información que la otra necesita.

• ¿No inyectamos ninguna clase en otra clase?
• ¿Inyectamos solo una parte de la información (ya sea una cadena, un número entero, una estructura de datos o lo que sea) en la otra clase?

No creo que haya una regla estricta para esto, pero probablemente sea seguro decir que es mejor inyectar solo los datos que necesita. Pero entonces esto plantea la pregunta de cómo preparar los datos para inyectar en una clase determinada.

• ¿Creas un método en una clase y lo pasas a otra?
• ¿Le pasas una pieza de información privada o protegida?

Por otra parte, creo que depende de si tiene que pasar algo con la información antes de que pase a una clase.

De todos modos, podría ir y venir sobre esto por el resto de la publicación y nunca llegar a una conclusión, así que ¿por qué no trabajar con un código fuente hasta que haya algo razonable?

Comencemos diciendo que tenemos un archivo de clase de complemento principal y esta clase es responsable de mantener información como:

• la ruta al complemento,
• la URL del complemento,
• si el complemento está cargado o no,
• la pantalla que se está viendo actualmente,
• y las clases a las que necesita transmitir (piense en pub/sub) cierta información.

Quizás un esqueleto o un trozo de la clase podría verse así :

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

Entonces empecemos muy amplio. Digamos que queremos tomar toda la clase y pasarla a una de las clases a las que está transmitiendo información.

Si ese fuera el caso, entonces podría verse así :

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

Pero uno de los desafíos con esto es que pasa mucha más información de la necesaria a otra clase. Además, pasa información que incluye información sobre la clase a la que pasa información.

Así que digamos que queremos dar un paso atrás y simplemente pasar una de las piezas privadas de información. Esto es sencillo, ¿verdad? Termina luciendo algo como esto :

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

Y esto puede ser completamente suficiente para algunos casos. Pero, como se mencionó anteriormente, también hay momentos en los que queremos tomar la información, procesarla y luego pasarla a una clase.

Para hacer esto, simplemente definiríamos un método, haríamos que procesara la información y luego pasaríamos el valor devuelto a la clase que necesita la información :

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

La idea detrás de esta discusión surgió al trabajar en una revisión de código para un proyecto reciente y hablar sobre las diversas opciones en las que se podría pasar información a una clase.

Así que comencé de manera amplia (a pesar de lo necesario, incluso dado el proceso de pensamiento anterior) y luego lo reduje a lo que solo es necesario.