Objekte über __get() erzeugen?

[napsio]

Hallo,

ich habe mal eine Frage, denn ich weiß nicht ob der Folgende Code sinnvoll ist oder nicht.

<?php
class Modul1Class
{
    public $core;
    
    public function __construct($core)
    {
        $this->core = $core;
    }
    
    public function Output()
    {
        echo "Modul1Class<br />";
        $this->core->Modul2->Output();
    }
}

class Modul2Class
{
    public $core;
    
    public function __construct($core)
    {
        $this->core = $core;
    }
    
    public function Output()
    {
        echo "Modul2Class<br />";
        $this->core->Output();
    }
}

class CoreClass
{
    public function __get($value)
    {
        if(!isset($this->$value))
        {
            $className = $value."Class";
            $this->$value = new $className($this);
            return $this->$value;
        }
    }
    
    public function Output()
    {
        echo "CoreClass<br />";
    }
}


$core = new CoreClass();
$core->Modul1->Output();
?>

Es geht darum, dass ich explizit nur ein Objekt von der CoreClass erstellen muss.

Ich weiß, dass es nicht sehr viel Sinn macht das zu nutzen, wenn man ein explizites Objekt eines Moduls braucht. Aber für eine Funktionssammlung, die in Klassen gegliedert ist erachte ich persönlich es schon als sinnvoll, z.B. Datenbank Klasse oder Template Klasse, von denen jeweils in gesammten Script nur ein Objekt erstellt wird. Ich hoffe man kann mir folgen und versteht was ich meine.

Was haltet ihr davon? Sinnvoll? Nicht sinnvoll? Wo sind die Nachteile dabei?

Würde mich über Feedback freuen.

[Griecherus]

Ich bin mir nicht sicher, ob ich dich richtig verstanden habe, aber suchst du eventuell das Singleton Entwurfsmuster?

class SomeClass
{
    static private $_instance = null;

    static public function getInstance()
    {
        if (self::$_instance === null)
        {
            self::$_instance = new SomeClass();
        }

        return self::$_instance;
    }
}

$object = SomeClass::getInstance(); 

Damit kannst du die Anzahl der zu erzeugenden Objekte einer Klasse auf ein einziges Objekt (oder einen Pool) begrenzen.

Flexibler ist es noch, eine abstrakte Singleton Klasse zu definieren und die Klassen, von denen es jeweils nur ein Objekt geben soll, von dieser erben zu lassen.

[PHP-Desaster]

Ich finde deinen Ansatz ok! Würde das aber über Methoden getModule( $modulename ) und setModule( $modulename, $object ) umleiten, so dass auch etwas generischer auf die Klasse zugegriffen werden kann!

[napsio]

Ja, aber so habe ich den Vorteil, dann ich mit einen Ordner erstellen kann, in dem die Modulklassen reinkommen. In der __get() funktion wird dann ein Include ausgeführt. z.B.

class CoreClass
{
    public function __get($value)
    {
        if(!isset($this->$value))
        {
            $className = $value."Class";
            require_once("Modul/".$value."Class.php");
            $this->$value = new $className($this);
            return $this->$value;
        }
    }
} 

Somit lade ich eine Datei in der eine Klasse implementiert ist in den Modul Ordner und kann direkt mit

$core->NeueKlasse

auf die Klasse zugreifen, ohne sie vorher registrieren zu müssen.