[php] pattern classes duidelijkheid

[tombo_inc]

beste mensen,

ik ben op het moment bezig met het schrijven van een aantal classes en objecten en kwam daarbij de volgende dingen tegen. ik was eens aan het kijken naar de verschillende patterns zoals beschreven op php.net. nu vroeg ik mij een paar dingen af:

1) bij het gebruiken van een pattern gaat het toch niet om de naamgeving van een methode van het pattern (bv factory) maar om de implementatie ervan. daarmee bedoel ik dat je een factory pattern methode net zo goed blaat kan noemen en niet perse factory hoeft te noemen? zelfde geld voor singleton.

2) bij het singleton pattern maken ze een private constructor die een fatal error veroorzaakt op het moment dat je een instantie van de classe probeert te maken. daardoor kun je dus geen objecten aanmaken van die classe (behalve via de methode die er voor gemaakt is). moet dit perse zo of kan je ook gewoon in een valid constructor kijken of er al een instantie is en zo ja een exception throwen. dan word er toch ook geen object geinstantieerd? en misschien zijn er nog wel meer mogelijkheden.

alvast bedankt.

[Nick_S]

Je kan het inderdaad wel anders gaan noemen, maar dan is 1 van de voordelen van Patterns weg. (Net zoals je een niet Pattern een Pattern naam gaat geven)

Namelijk de herkenbaarheid van je code, voor latere programmeurs (of voor je zelf)

[tombo_inc]

ja dat klopt. maar je kan natuurlijk altijd je werk van goed commentaar voorzien. maar ik snap wat je bedoelt, maar het is in ieder geval mogelijk. het is dus niet zo dat het pattern dan ineens niet meer zou werken omdat je geen juiste naam gebruikt, en dat wilde ik even uitsluiten

edit:
weet iemand nog iets over punt 2?

[ Voor 8% gewijzigd door tombo_inc op 16-03-2005 20:53 ]

[Sybr_E-N]

Tombo_inc schreef op woensdag 16 maart 2005 @ 20:39:
ja dat klopt. maar je kan natuurlijk altijd je werk van goed commentaar voorzien. maar ik snap wat je bedoelt, maar het is in ieder geval mogelijk. het is dus niet zo dat het pattern dan ineens niet meer zou werken omdat je geen juiste naam gebruikt, en dat wilde ik even uitsluiten

edit:
weet iemand nog iets over punt 2?

Een pattern is meer een manier van denken en implementeren, die naamgeving is handig om een pattern te herkennen.

En over nummer 2 hoe bedoel je precies? Een singleton klasse is op een der mate manier geconstrueerd dat er maar 1 instantie van gemaakt wordt. Als die eenmaal is aangemaakt worden bij de volgende aanzoeken om een instantie te maken de reeds bestaande instantie terug gegeven in plaats van een nieuwe.

edit:

Maar deze informatie valt op het internet ook veel over te vinden, of in boeken over patterns. Misschien heb je er wat aan om wat meer inzicht in Design Patterns te krijgen:
:: phpPatterns()
SitePoint Forums - Advanced PHP Programming
PHP manual: Patterns
Enterprise Patterns
Patterns Central
Microsoft patterns
J2EE Patterns

In dit PW topic staan allerlei info over programmeerboeken, oa patterns. Zoek eens op bv. GoF (Gang of Four)
[Alg] Centrale boekentopic - part II

[ Voor 37% gewijzigd door Sybr_E-N op 16-03-2005 21:18 ]

[tombo_inc]

ja dat snap ik nu.
maar wat ik met 2 bedoel is, kan je een singleton ook op een andere manier kan realiseren dan de manier beschreven op php.net. ik had bedacht dat je een geldige constructor maakt die kijkt of er al een instantie is. zo ja gooi een exception (dan word er geen nieuwe instantie gemaakt), zo nee maak de instantie. zo kan je toch gebruik maken van een constructor. verder impementeer je natuurlijk de __clone methode.
maar is het mogelijk om zo een singleton te maken of is de methode die php.net hanteerd de enige die werkt?

[joopst]

Als je een singleton op een andere manier realiseert, is het dan nog wel een singleton ?

[Michali]

Tombo_inc schreef op donderdag 17 maart 2005 @ 08:36:
ja dat snap ik nu.
maar wat ik met 2 bedoel is, kan je een singleton ook op een andere manier kan realiseren dan de manier beschreven op php.net. ik had bedacht dat je een geldige constructor maakt die kijkt of er al een instantie is. zo ja gooi een exception (dan word er geen nieuwe instantie gemaakt), zo nee maak de instantie. zo kan je toch gebruik maken van een constructor. verder impementeer je natuurlijk de __clone methode.
maar is het mogelijk om zo een singleton te maken of is de methode die php.net hanteerd de enige die werkt?

Dat kan wel, maar dan is het nut van de singleton weg. Het is juist de bedoeling van een singleton dat hij op veel plaatsen (globaal) beschikbaar is, zonder hem als parameter door te geven bij allerlei functies. Hiervoor moet je hem dus kunnen ophalen middels een functie. Maar hoe weet jij nou of er al een instantie is gemaakt? Volgens jouw manier zou je daarvoor nog een extra functie moeten implementeren waarmee je dan bij de client controleert of er al een instantie is aangemaakt. Indien niet: maak je dus een nieuwe via de "officiele" constructor; indien wel: tja wat dan? Dit gedoe bij de client is al verkeerd. De client moet zich niet druk hoeven maken om dit soort zaken. De regels voor het aanmaken van deze instantie moeten bij de class zelf liggen of in een apart factory object. En wat ga je doen als je via de normale manier een instantie maakt? Hoe zorg je dan dat deze instantie in een totaal andere class ook beschikbaar is zonder hem als parameter mee te geven? Je zou dan weer een extra functie kunnen toevoegen waarmee je de instantie weer toekent aan de class. Daarnaast heb je dan weer een functie om hem weer op te halen. Maar als je die laatste functie toch al hebt. Waarom zou je dan zo moeilijk gaan doen terwijl het erg gemakkelijk kan?

Begrijp je nu waarom

[tombo_inc]

nee ik begrijp het nog niet helemaal
waarom zou dit niet werken?

PHP:

<?php

class testsingleton() {

    private static $instance;
    
    public function __construct() {
    
     try {
        if (isset(self::$instance)) {
           throw new Exception('blaat');    
        }
     }
     catch(Exception $blaat) {
        //doe iets  
     }
     
     //rest van de constructor
    }
    
    public function __clone() {
       trigger_error('Clone is not allowed.', E_USER_ERROR);
    }

    
    
    //de rest van de implementatie

}

$testobj = new testsingleton;
?>

[Janoz]

Wat je daar schrijft werkt niet. Zodra er al een instantie is gooi je een exception. Je kunt het object dus maar 1x instantieren. Het probleem is echter dat, zodra je dit gedaan hebt, je die instantie niet meer terug kan krijgen. Nogmaals die constructor aanroepen levert immers een exception op. Daarnaast kan een object in zijn constructor niet zichzelf vervangen door iets anders.

Dat er een apparte aanmaak methode is is niet voor niks. Dat is juist om het pattern zo te laten werken zoals het is bedoeld.

[tombo_inc]

ok dat wilde ik dus even weten. want het leek mij veel makkelijker om ook gewoon gebruik te kunnen maken van een constructor. maar dat gaat dus niet omdat je in de constructor niet kan doen wat je wil. je kan er wel voor zorgen dat je het object maar 1 keer aan kan maken, maar meer ook niet als ik het goed begrijp.

waar mijn methode dus wel voor geschikt is, is om te zorgen dat een object niet meer dan een keer geinstantieerd kan worden in de tijd dat het script draait. of vergis ik me daar weer een keer?

[ Voor 24% gewijzigd door tombo_inc op 17-03-2005 21:41 ]

[Michali]

Je geeft $instance nooit een waarde. En verder is dit gewoon onzin. Je begrijpt het doel niet helemaal. Even een voorbeeldje. Stel je hebt twee classes. class1 en class2. Deze willen beide gebruik maken van class3 waarin een waarde zit die opgevraagd kan worden en bewerkt kan worden middels methodes. Omdat class3 ook nog op verschillende andere plaatsen beschikbaar moet zijn en omdat class1 en class2 niet direct gerelateerd zijn is het niet mogelijk om ze als parameter door te geven.

PHP:

class class1
{
  function perform()
  {
    $class3 = class3::getInstance();
    print $class3->getValue();
    $class3->increaseValue();
  }
}

class class2
{
  function perform()
  {
    $class3 = class3::getInstance();
    print $class3->getValue();
    $class3->increaseValue();
  }
}

class class3
{
  private static $instance;
  
  public static function getInstance()
  {
    if ( self::$instance == null ) self::$instance = new class3();
    
    return self::$instance;
  }

  private function __construct() { }

  private $value = 0;

  public function getValue() { return $this->value; }

  public function increaseValue() { $this->value++; }
}

Het is belangrijk dat de vernieuwingen aan de instance van class3 overal doorgevoerd worden. class3 moet dus overal hetzelfde zijn. Dan is het vaak goed om een singleton te gebruiken.

Als je gebruik zou maken van de constructor zou dit niet mogelijk zijn (iig niet zonder omweg) en zou het hele doel van een singleton verdwijnen.

Natuurlijk kun je wel de methode die jij vertelt gebruiken als een soort controle, maar hoe ga je dan controleren of er al een instantie is aangemaakt? Ik voorzie al dat je daar veel problemen mee gaat krijgen. Stel dat je een class maakt die er gebruik van maakt en later nog een class toevoegt die dat ook doet. Zolang ze beide niet samen uitgevoerd worden is er niets aan de hand, maar als ze bij een vernieuwing toch moeten samenwerken hoe dan ook heb je dus een probleem.

[ Voor 4% gewijzigd door Michali op 18-03-2005 13:06 ]

[tombo_inc]

ok ik heb het door denk ik
bedankt!