Hallo,
was wäre von den folgenden Möglichkeiten von Performance und vom Stil her besser?
In der Core Klasse eine Instanziierung der Error Klasse an eine Variable übergeben und diese Public setzen damit man in andere Klassen über $core->_error-> darauf zugreifen kann.
Instanziierungen in einer Registry speichern und bei bedarf wieder aufrufen…
In jeder Klasse im Construct die benötigten Klassen instanziieren
Wisst ihr vl auch ne bessere Realisierung?
mfg
Ich tue mich ein bisschen schwer mit einer richtigen Antwort. Ich würde sage, alles drei. Es kommt halt nur auf den Anwendungsfall drauf an.
Was genau macht denn deine Error-Klasse? Ist das ein Controller der Ausnahmen behandelt oder einfach nur eine eigene Exception-Klasse?
Die Error Klasse gibt den Error in einem Template aus und beendet das Script mit die. Der Anwendungsfall wäre besonders die Instantiierung bei Addons und Modulen…
In dem Fall würde ich einfach mit normaler Exception-Logik arbeiten. Für nicht-gefangene Exceptions kannst du die Anwendung selbst als Exception-Handler setzen:
[php]<?php
class ModuleException extends Exception {}
class ModuleXyz
{
public function __construct()
{
throw new ModuleException(‚Fehler‘);
}
}
class Application
{
protected $_modules = array();
public function __construct()
{
$this->_bootstrap();
$this->_loadModule('Xyz');
}
protected function _bootstrap()
{
set_exception_handler(array($this, 'exceptionHandler'));
}
protected function _loadModule($moduleName)
{
$moduleName = 'Module' . $moduleName;
$this->_modules[] = new $moduleName();
}
public function exceptionHandler(Exception $exception)
{
die($exception);
}
}
new Application();[/php]
Hier auf eigene Konstrukte auszuweichen, obwohl PHP Exceptions von Haus aus unterstützt, finde ich irgendwie unpraktisch.
Danke für deine Antwort. Nunja ich wollte eig. etwas über die Instanziierung allgemein wissen bzw. welche Methode da am besten wäre
Zum Exception fangen von deinen dreien keine. Du willst einen Controller der Fehler behandelt und darstellt. Klappen würde das so, wie’s mermshaus beschreibt.
xDD
Nunja ich wollte eig. etwas über die Instanziierung allgemein wissen bzw. welche Methode da am besten wäre
Die Error Klasse war nur ein Beispiel : )
What he says. 
Ich kann dir ein paar subjektive Meinungen geben, die bitte nicht als allgemeingültig zu verstehen sind.
Methode 1 (Objekt über weiteres übergebenes Objekt holen) lässt sich mit dem Hinweis auf das Law of Dementer beantworten.
„Übergib nicht mehr als notwendig.“
Methode 2 (Registry) hatten wir gerade in einem anderen Thread angeschnitten.
Ich glaube, auf php.de hat einer deiner Threads auch schon zu einer Diskussion dazu geführt.
Kurzversion: Für mich ist eine Registry im Grunde ein „globaler Zustand“ (wie ein Singleton oder eine globale Variable). Die Nutzung globaler Variablen verschleiert Abhängigkeiten, was Code oft schwieriger wiederverwendbar und testbar macht.
Viele Leute finden die Konstrukte praktisch (ich will nicht sagen, dass sie es nicht sind) und vor allem Frameworks nutzen Singletons und Registries überaus gerne. (Da ist das Argument der „Wiederverwendbarkeit“ vielleicht nicht so sehr gegeben, da sowieso das gesamte Framework bei jedem neuen Anwendungsfall erneut verwendet wird.)
Ich habe ehrlichgesagt selten den Drang verspürt, solche Muster einzusetzen. Üblicherweise lässt sich derselbe Effekt über „Injection“ (siehe unten) erreichen.
Methode 3 (Abhängigkeiten in Konstruktor neu erstellen) ist eher „altbacken“. Davon würde ich tendentiell abraten und eine Art von „Dependency Injection“ (wenn ich das Wort verwende, meine ich in der Regel Constructor/Setter Injection) verwenden.
Also nicht
[php]public function __construct()
{
$this->_someObject = new SomeObject();
}[/php]
, sondern:
[php]public function __construct(SomeObject $someObject)
{
$this->_someObject = $someObject;
}[/php]
Dabei gibt es wie gesagt keine Pauschalantworten, sondern nur Anwendungsfälle. Kein Pattern ist per se schlecht.
Bestimmt hat dir schon mal jemand empfohlen, dir ein OOP-Framework (wie etwa das Zend Framework) anzusehen. Das kann ich nur unterstreichen (auch in Hinblick auf deinen anderen aktuellen Thread). Das ist eine sehr geeignete Weise, herauszufinden, wie Probleme wie die, vor denen du stehst, angegangen werden können.
Hey,
ich danke für eure Antworten : )
Nun Dependency Injection wäre doch eher umständlich wenn ich mehrere Klassen brauche? Wenn ich die Registry verwende sollte ich dann alles sofort Speichern z.B. $test1 = new core(); Registry::set(„core“,$test1); usw … ? Neue Klassen im Constructor zu erstellen hab ich gesehen wird auch im Zend Framework angewandt…