Vad är för mycket för att skicka data via beroendeinjektion?

Ämnet med beroendeinjektion är ett ämne som har funnits ett tag i objektorienterade programmeringskretsar. Ibland ser vi det i WordPress; ibland gör vi inte det.

Jag är ett fan av det, men ärligt talat är jag inte alltid säker på hur mycket information som ska injiceras i en klass. Jag menar, låt oss säga att vi får två klasser, och en innehåller information som den andra behöver.

• Injicerar vi ingen klass i en annan klass?
• Injicerar vi bara en bit information (vare sig det är en sträng, heltal, datastruktur eller vad som helst) i den andra klassen?

Jag tror inte att det finns en hård och snabb regel för detta, men det är nog säkert att säga att det är bättre att injicera just den data du behöver. Men då väcker detta en fråga om hur man förbereder data för att injicera i en given klass?

• Skapar du en metod i en klass och överför den till en annan?
• Skickar du en del privat eller skyddad information till den?

Återigen, jag tror att det beror på om något måste hända med informationen innan den skickas till en klass.

Hur som helst, jag skulle kunna gå fram och tillbaka på detta under resten av inlägget och aldrig komma till en slutsats så varför inte arbeta igenom lite källkod tills det finns något rimligt.

Låt oss börja med att säga att vi har en huvudpluginklassfil och den här klassen ansvarar för att upprätthålla information som:

• vägen till plugin,
• URL:en till plugin-programmet,
• om plugin-programmet är laddat eller inte,
• skärmen som för närvarande visas,
• och de klasser som den behöver för att sända (tänk pub/sub) viss information.

Kanske ett skelett eller en stubb från klassen kan se ut så här :

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

Låt oss sedan börja riktigt brett. Säg att vi vill ta hela klassen och skicka den till en av klasserna som den sänder information till.

Om så var fallet kan det se ut så här :

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

Men en av utmaningarna med detta är att det skickar mycket mer information än nödvändigt till en annan klass. Dessutom skickar den information som inkluderar information om klassen till vilken informationen skickas.

Så låt oss säga att vi vill ta ett steg tillbaka och bara skicka en av de privata uppgifterna. Det här är enkelt, eller hur? Det slutar med att det ser ut ungefär så här :

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

Och detta kan vara helt tillräckligt för vissa fall. Men, som tidigare nämnts, finns det också tillfällen då vi vill ta informationen, bearbeta den och sedan skicka den till en klass.

För att göra detta skulle vi bara definiera en metod, låta den behandla information och sedan skicka returvärdet till klassen som behöver informationen :

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

Idén bakom den här diskussionen kom upp när man arbetade med en kodgranskning för ett nyligen genomfört projekt och pratade igenom de olika alternativen där information kunde skickas till en klass.

Så jag började brett (trots vad som är nödvändigt även med tanke på tankeprocessen ovan) och minskade det sedan till det som bara är nödvändigt.