Mida on liiga palju sõltuvuse süstimise kaudu andmete edastamiseks?

Sõltuvussüsti teema on objektorienteeritud programmeerimise ringkondades olnud juba mõnda aega. Mõnikord näeme seda WordPressis; mõnikord me ei tee seda.

Olen selle fänn, kuid ausalt öeldes pole ma alati kindel, kui palju teavet klassi süstida. Ütleme nii, et meile antakse kaks klassi ja ühes on teave, mida teine ​​vajab.

• Kas me ei sisesta ühtegi klassi teise klassi?
• Kas sisestame teise klassi ainult osa informatsioonist (olgu see siis string, täisarv, andmestruktuur või mis iganes)?

Ma arvan, et selleks ei ole ranget reeglit, kuid ilmselt võib kindlalt väita, et parem on sisestada just need andmed, mida vajate. Kuid siis tekib küsimus, kuidas valmistada andmeid ette antud klassi sisestamiseks?

• Kas loote meetodi ühes klassis ja edastate selle teise?
• Kas edastate sellesse privaatset või kaitstud teavet?

Jällegi, ma arvan, et see sõltub sellest, kas teabega peab midagi juhtuma enne, kui see klassi antakse.

Igatahes võiksin selle postituse lõpuni edasi-tagasi edasi-tagasi edasi-tagasi edasi-tagasi edasi-tagasi edasi-tagasi edasi-tagasi edasi-tagasi edasi-tagasi edasi-tagasi edasi-tagasi edasi-tagasi edasi-tagasi edasi-tagasi edasi-tagasi käia kogu ülejäänud postituse jooksul ega jõua kunagi järeldusele, nii et miks mitte läbi töötada lähtekoodi enne, kui on midagi mõistlikku.

Alustame sellega, et meil on peamine pluginaklassi fail ja see klass vastutab sellise teabe säilitamise eest nagu:

• tee pistikprogrammini,
• pistikprogrammi URL,
• kas pistikprogramm on laaditud või mitte,
• ekraan, mida praegu vaadatakse,
• ja klassid, kellele ta peab teatud teavet edastama (mõtle pub/sub ).

Võib-olla võib klassi luustik või tünn välja näha selline :

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

Alustame siis väga laialt. Ütleme, et tahame võtta kogu klassi ja suunata selle ühte klassi, kellele see teavet edastab.

Kui see nii oleks, võib see välja näha järgmine :

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

Kuid üks selle väljakutsetest on see, et see edastab teise klassi palju rohkem teavet kui vaja. Lisaks edastab see teavet, mis sisaldab teavet selle klassi kohta, kuhu see teave edastab.

Oletame, et tahame astuda sammu tagasi ja edastada lihtsalt ühe privaatse teabe. See on lihtne, eks? See näeb lõpuks välja umbes selline :

<?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 see võib mõnel juhul olla täiesti piisav. Kuid nagu varem mainitud, on ka aegu, mil tahame teavet võtta, seda töödelda ja seejärel klassi edastada.

Selleks määratleme lihtsalt meetodi, laseme sellel teavet töödelda, seejärel edastame tagastatava väärtuse klassi, mis seda teavet vajab :

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

Selle arutelu idee tekkis hiljutise projekti koodiülevaatuse kallal ja rääkides erinevatest võimalustest, kuidas teavet klassile edastada.

Nii et alustasin laiapõhjalisest (hoolimata sellest, mis on vajalik isegi ülaltoodud mõttekäiku arvestades) ja siis kitsendasin selle ainult vajalikuks.