Mikä on liikaa tietojen välittämiseen riippuvuusinjektion kautta?

Riippuvuuden lisääminen on aihe, joka on ollut olemassa jo jonkin aikaa olio-ohjelmointipiireissä. Joskus näemme sen WordPressissä; joskus emme.

Olen sen fani, mutta rehellisesti sanottuna en kuitenkaan ole aina varma, kuinka paljon tietoa pitäisi lisätä luokkaan. Tarkoitan, sanotaanpa, että meille annetaan kaksi luokkaa, ja toisessa on tietoja, joita toinen tarvitsee.

• Emmekö lisää luokkaa toiseen luokkaan?
• Lisäämmekö vain osan tiedosta (olipa se merkkijono, kokonaisluku, tietorakenne tai mikä tahansa) toiseen luokkaan?

En usko, että tälle on tiukkaa sääntöä, mutta on luultavasti turvallista sanoa, että on parempi syöttää vain tarvitsemasi tiedot. Mutta sitten tämä herättää kysymyksen siitä, kuinka tiedot valmistetaan syötettäväksi tiettyyn luokkaan?

• Luotko menetelmän yhdessä luokassa ja siirrätkö sen toiseen?
• Siirrätkö siihen osan yksityistä tai suojattua tietoa?

Toisaalta luulen, että se riippuu siitä, täytyykö tiedoille tapahtua jotain ennen kuin se siirretään luokkaan.

Joka tapauksessa voisin palata tähän edestakaisin koko postauksen ajan, enkä koskaan tule tekemään johtopäätöksiä, joten miksi en työstäisi lähdekoodia läpi ennen kuin on jotain järkevää.

Aloitetaan sanomalla, että meillä on päälaajennusten luokkatiedosto ja tämä luokka on vastuussa tietojen ylläpitämisestä, kuten:

• polku laajennukseen,
• laajennuksen URL-osoite,
• onko laajennus ladattu vai ei,
• tällä hetkellä katsottava näyttö,
• ja luokat, joille sen on lähetettävä (ajattele pub/sub) tiettyjä tietoja.

Ehkä luokan luuranko tai tynkä saattaa näyttää tältä :

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

Aloitetaan sitten todella laajasti. Sano, että haluamme ottaa koko luokan ja siirtää sen jollekin luokasta, jolle se lähettää tietoja.

Jos näin olisi, se voisi näyttää tältä :

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

Mutta yksi tämän haasteista on, että se siirtää paljon enemmän tietoa kuin on tarpeen toiseen luokkaan. Lisäksi se välittää tietoa, joka sisältää tietoa luokasta, jolle se välittää tiedot.

Oletetaan siis, että haluamme ottaa askeleen taaksepäin ja välittää vain yhden yksityisistä tiedoista. Tämä on yksinkertaista, eikö? Se näyttää lopulta tältä :

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

Ja tämä voi olla täysin riittävä joissakin tapauksissa. Mutta kuten aiemmin mainittiin, on myös hetkiä, jolloin haluamme ottaa tiedon, käsitellä ne ja sitten siirtää ne luokkaan.

Tätä varten määritämme menetelmän, pyydämme sen käsittelemään tiedot ja siirtämään palautusarvon luokkaan, joka tarvitsee tiedot :

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

Ajatus tämän keskustelun taustalla syntyi, kun työskentelimme äskettäisen projektin koodiarvioinnin parissa ja keskustelimme eri vaihtoehdoista, joilla tietoa voitaisiin välittää luokkaan.

Joten aloitin laajasta (huolimatta siitä, mikä on välttämätöntä, vaikka yllä oleva ajatusprosessi otetaan huomioon) ja sitten rajasin sen siihen, mikä on vain välttämätöntä.