Dynamische Methodenparameter

Nein, ist es nicht!

Angenommen du hast ein halbes Hundert Erzeugungsvorschriften im Array......

Eine Vorschrift dient zum erzeugen eines DB Objektes.
Eine Weitere zum erzeugen eines BenutzerModells.

Angenommern: BenutzerModell braucht DBObjekt

Was passiert?
Erst muß eine Instanz der DB Klasse gebildet werden bevor das BenutzerModell erzeugt werden kann.
Wie willst du diese Abhängigkeit in dem Array abbilden?

Es gibt so ein paar Grundsätze, die dir das leben erleichtern. Einer davon wäre Convention over Configuration. Das bedeutet, dass deine Applikationsstruktur sich an bestimmte Vorgaben zu halten hat, um diverse Prozesse zu automatisieren. Die simpelste Umsetzung, ist eine Klassenbenamung, um Autoloading zu ermöglichen. Damit kannst du dir das händische Laden schon ein mal sparen!

Du wirfst allerdings auch die ganze Zeit Laden und Instanzieren durcheinander. Das "laden" wäre hier lediglich das inkludieren der Datei, die die gewünschte Klasse enthält. Das instanzieren ist allerdings das, was du lt. deinem ersten Post aufgrund unterschiedlicher Parameter nicht hinbekommst.

Und da kommen wir wieder zu Convention over Configuration sowie das von combie erwähnte Dependency Injection Pattern, dass dir solche Arbeit abnimmt. Das bedeutet im Umkehrschluss allerdings auch, dass deine Applikation derzeit Design-Fehler aufweist. Jetzt stehst du vor der Wahl: Hast du Legacy-Code vor dir, den du nicht ohne weiteres ändern kannst, oder gehst du den harten und steinigen Weg, und instanziserst stets von Hand? Mehr Wege gibt es (für den Produktiveinsatz) nicht!

Am Ende bitte ich dich, die kursiv markierten Begriffe zu googlen! Das sind wertvolle Tipps, die dir hier gegeben wurden!

Ich muss mich hier dann aber doch noch mal melden. Ich habe jetzt noch mal ein bisschen was über das Registry Modell, Factory Modell und auch über Dependency Injection gelesen (was ich übrigens vorher auch schon hatte). Bevor ich mich da noch weiter vertiefe habe ich dennoch nicht das Gefühl, dass es meine Probleme löst. Ich muss ja trotzdem sagen wir mal 20 verschiedene Klassen starten und ich will ja eigentlich nur das "optimieren". Klar, eine gewisse "Abhängigkeit" besteht natürlich, denn die zu übergebenden Parameter ergeben sich ja erst zur Laufzeit aus der "Hauptklasse". Oder stehe ich an dieser Stelle komplett auf der Leitung?!?

Klar, eine gewisse "Abhängigkeit" besteht natürlich, denn die zu übergebenden Parameter ergeben sich ja erst zur Laufzeit aus der "Hauptklasse". Oder stehe ich an dieser Stelle komplett auf der Leitung?!?

Nöö...
Es gibt Abhängigkeiten!
Und sie wollen aufgelöst werden.

Ohne deinen Code zu kennen, kann man dir hier leider keine weiteren Hinweise geben. Wie ich schon sagte: Umbauen oder in den sauren Apfel beißen. Ich befürchte jedoch, du hast nicht ganz verstanden, was es mit Autoloading auf sich hat ...

Guten Morgen zusammen,

wir reden trotzdem aneinander vorbei. Meine Klassen haben keine Abhängigkeiten, keine der Klassen nutzt irgendwas von einer anderen Klasse. Die Klasse aus meinem ersten Posting bräuchte ich nicht mal, ich hab das laden meiner Klassen nur in eine Klasse gepackt, weil ich das "eleganter" finde. Ich könnte also auch einfach sowas machen:

PHP-Code:

$parameter1; 
$parameter2; 
$parameter3;

require_once("inc/class.filename1.inc.php");
$filename1 = new filename1($parameter1, $parameter2);

require_once("inc/class.filename2.inc.php");
$filename2 = new filename2($parameter2, $parameter3); 
 
require_once("inc/class.filename3.inc.php");
$filename3 = new filename3($parameter1, $parameter3); 


Komplett ohne Klasse. Die einzige "Überschneidung" ist, dass alle Klassen eine Teilmenge meiner Parameter benötigen. Die Werte der Parameter ergibt sich vorher durch einige Daten aus einer Config. Und alles was ich machen wollte war, den ganzen require und new ... Bereich aus meiner Sicht etwas schöner zu machen. Dazu wollte ich also die Klassen in ein Array packen und das dann mit foreach durchgehen. Und das Problem ist für mich dann nur die Parameterübergabe.

Ich freu mich ja über die Tipps und Anregungen, hab mir auch alles angesehen. Das scheint mir nur alles nicht die Lösung zu bringen.

Nur das Autoloading Thema hab ich noch nicht geguckt, das mach ich gleich mal. Bielang hab ich nur die Befürchtung, dass das Parameter Thema damit nicht gelöst ist.

So, erst mal schönen Tag. Bis später!

Zitat von DerEsWissenWill

Das scheint mir nur alles nicht die Lösung zu bringen.

Hast du denn das mit der Reflection überhaupt schon ausprobiert oder warum wartest du immer noch auf die Lösung?

Die require's fallen schon mal weg, wenn du Autoloading benutzt.

Für die Parametriesierung der Konstruktoren gibt es Alternativen:
- Config-Werte als Array übergeben
- Config als Objektreferenz übergeben
- Config gar nicht übergeben
--> Konstruktor holt sich die benötigten Werte selbst
--> Werte werden da geholt, wo sie gebraucht werden

Letzteres ist eigentlich der gebräuchlichste Ansatz. Das sieht dann etwa so aus:

PHP-Code:

class Foo {
    public function __construct() {
        // hier brauchen wir zufällig keine Config-Werte 
    }
    public function bar() {
        // hier brauchen wir einen, also holen wir ihn uns
        $bla = Config::get('bla');
        // ...
    }
} 


Zitat von AmicaNoctis

Hast du denn das mit der Reflection überhaupt schon ausprobiert oder warum wartest du immer noch auf die Lösung?

Mist, den Vorschlag hatte ich zwischenzeitig ganz verdrängt...

Zitat von onemorenerd

Letzteres ist eigentlich der gebräuchlichste Ansatz. Das sieht dann etwa so aus:

PHP-Code:

class Foo {
    public function __construct() {
        // hier brauchen wir zufällig keine Config-Werte 
    }
    public function bar() {
        // hier brauchen wir einen, also holen wir ihn uns
        $bla = Config::get('bla');
        // ...
    }
} 


Das ist aber eine derart versteckte und feste Abhängigkeit, dass es dem Singleton Antipattern in nichts nachsteht und imho noch schlimmer ist, als der Ansatz des TO. Seiner unterstützt dabei wenigstens noch Legacy- und native Klassen.

Zitat von AmicaNoctis

Hast du denn das mit der Reflection überhaupt schon ausprobiert oder warum wartest du immer noch auf die Lösung?

Mit Refelection lässt sich evtl. das Problem lösen, allerdings nicht für den Produktiveinsatz. Wie combie (oder war es h3ll? Tut mir leid Jungs, ich schmeiß euch immer durcheinander ) schon anmerkte, ist Reflection in PHP (noch?) extrem langsam. So extrem, dass wenn man eine Hand voll Klassen und Methoden reflektiert, mehrere Sekunden in Kauf nehmen muss. Das ist im Live-Betrieb undenkbar!

Ich bin langsam auch müde zu sagen, dass die Archtiektur des TS einfach nicht mehr hergibt. Wenn ich eine Reihe von Klassen habe, die alle eine wilde und willkürliche Anzahl von Parametern haben, dann stimmt was nicht. Warum? Was sind das überhaupt für Klassen? Warum halten diese sich nicht an ein Interface? Warum holen sich die Klassen ihre Werte nicht aus einer Konfiguration (wie onemorenerd schon sagte)? Das klingt für mich alles übel nach einem groben Design-Patzer.

Am Ende Frage ich mich, wofür die Klassen überhaupt benötigt werden. Wenn ich mir meine Applikationen so ansehe, dann gibt es nicht viel, dass ich von Hand instazieren muss … ich hab grad mal nachgesehen, es gibt tatsächlich nur den Autoloader den ich selbst registrieren muss. Der Rest läuft komplett über Dependency Injection. Ich kann mir eben nur schwer vorstellen, dass es so viele Objekte gibt, die die Applikation benötigt und die dann von Hand instanziert werden müssen …

Aber was solls, ist mir auch langsam zu doof. Der TS behauptet ja weiterhin steif und fest, dass wir alle nicht verstehen was er will und die Hinweise die wir ihm geben sind ja auch alle unnütz. Vergebene Liebesmüh' …

Zitat von DerEsWissenWill

Mist, den Vorschlag hatte ich zwischenzeitig ganz verdrängt...

Und den, das über SetterInjection abzuhandeln, auch
Oder, warum schmeckt der dir auch nicht?


Ja, irgendwo sagte ich: "Refelection ist teuer"
Und meinte schon die Ressourcen, Speicher und Zeit.
In einer Java Applikation, wo die Lebensdauer der erzeugten Klassen Stunden oder Monate beträgt, da kann man sich das schon ehr erlauben. Aber nicht bei unseren "kurzlebigen" PHP Scripten.

Zitat von combie

Ja, irgendwo sagte ich: "Refelection ist teuer"

Hat sich daran zufällig seit PHP 5.3 was getan? Ich hab es (weil ich Gewissheit wollte) nämlich grad mal gebenchmarkt.

8000 Instanzen werden erzeugt und das kommt raus:

PHP-Code:

Array
(
    [direct] => 0.0430080000
    [reflection] => 0.1016140000
    [difference] => 0.058606
) 


Alle Angaben in Sekunden.

Hier der Code

PHP-Code:

<?php
    class Pet {
        private $_birthDate;
        private $_name;
        public function __construct ($pName = null, $pBirthDate = null) {
            $this->setDateOfBirth($pBirthDate);
            $this->setName($pName);
        }
        public function getAge () {
            return date("Y") - date("Y", strtotime($this->_birthDate));
        }
        public function getDateOfBirth () {
            return $this->_birthDate;
        }
        public function getName () {
            return $this->_name;
        }
        public function makeNoise () {
            echo($this->getName() . " is making noise");
        }
        public function setDateOfBirth ($pValue) {
            $this->_birthDate = $pValue;
        }
        public function setName ($pValue) {
            $this->_name = $pValue;
        }
    }
    class Cat extends Pet {
        public function meeow () {
            $this->makeNoise();
            echo(": Meeow");
        }
    }
    class Dog extends Pet {
        private $_isBig;
        public function __construct ($pName = null, $pBirthDate = null, $pIsBig = false) {
            parent::__construct($pName, $pBirthDate);
            $this->_isBig = $pIsBig;
        }
        public function bark () {
            $this->makeNoise();
            echo(": " . ($this->_isBig ? "Woof" : "Wiif"));
        }
    }
    
    $begin = explode(" ", microtime());
    for ($i = 0; $i < 1000; $i++) {
        $p1 = new Pet();
        $p2 = new Pet("Ally");
        $p3 = new Pet("Bert", "2001-01-01");
        $p4 = new Cat("Clara");
        $p5 = new Cat("Danny", "2002-02-02");
        $p6 = new Dog("Eliah");
        $p7 = new Dog("Fanny", "2003-03-03");
        $p8 = new Dog("Ginger", "2004-04-04", true);
    }
    $end = explode(" ", microtime());
    $duration1 = number_format(($end[0] - $begin[0]) + ($end[1] - $begin[1]), 10);
    
    $begin = explode(" ", microtime());
    for ($i = 0; $i < 1000; $i++) {
        $config = array();
        $config[] = array("Pet");
        $config[] = array("Pet", "Ally");
        $config[] = array("Pet", "Bert", "2001-01-01");
        $config[] = array("Cat", "Clara");
        $config[] = array("Cat", "Danny", "2002-02-02");
        $config[] = array("Dog", "Eliah");
        $config[] = array("Dog", "Fanny", "2003-03-03");
        $config[] = array("Dog", "Ginger", "2004-04-04", true);
        foreach ($config as $k => $v) {
            $rc = new ReflectionClass(array_shift($v));
            $config[$k] = $rc->newInstanceArgs($v);
        }
    }
    $end = explode(" ", microtime());
    $duration2 = number_format(($end[0] - $begin[0]) + ($end[1] - $begin[1]), 10);

    print_r(array("direct" => $duration1, "reflection" => $duration2, "difference" => abs($duration2 - $duration1)));
?>

Ich komme bei mir unter 5.3 zu ähnlichen Ergebnissen...
Unter 5.2.6 sieht es schlimmer aus
Auch das OS scheint eine Rolle zu spielen.

php5.3(win):
[direct] => 0.0680080000
[reflection] => 0.1265960000
[difference] => 0.058588

php5.3(linux)
[direct] => 0.0800370000
[reflection] => 0.2373800000
[difference] => 0.157343

php5.2.6(linux)
[direct] => 0.0700670000
[reflection] => 0.3819360000
[difference] => 0.311869


Beide Systeme dümpeln unter geringer Last.

OffTopic:

---

haha! :d

---

Ich würde es übrigens mal mit "echten" Klassen ausprobieren … ich guck mal ob ich da schnell was hinbekomme.