Delegate functie mogelijk? Hoe moet ik dit aanpakken?

[GewoonWatSpulle]

Ik ben uit professie een .NET ontwikkelaar en daar maken we gebruik van de pracht constructie van delegate-functies, een blackbox kan deze aanroepen wanneer er iets gebeurt en voert dan jouw ingegeven code uit.

PHP:

  $page = new Page();
  $page->FinishedLogics = new function { echo 'yay ik ben klaar'; };

Als het Page object $page klaar is voert hij de bovenstaande functie uit en echo't:

yay ik ben klaar

Mocht de pagina nooit goed laden, dan voert hij de functie niet uit.

Weet iemand een mooie constructie voor dit "probleem" van gebrek aan delegate-functies in PHP?

Ik heb al gekeken naar een wikipedia: Observer-pattern maar vond dat ook niet de mooiste oplossing voor dit probleem.

[RobIII]

http://php.net/manual/en/function.call-user-func.php

PHP:

class Foo {
  private $_delegate;

  public function SetShoutFunction($delegate) {
    $this->_delegate = $delegate;
  }

  public function Shout($text) {
    call_user_func($this->_delegate, $text);
  }
}

class Bar {
  public function EchoShout($text) {
    echo $text;
  }
}

$y = new Bar();

$x = new Foo();
$x->SetShoutFunction(array($y, 'EchoShout'));
$x->Shout('W00t!');

Misschien ietwat omslachtig, maar ik denk dat je als .Net ontwikkelaar hier 't snelst herkent wat er gebeurt.

[ Voor 89% gewijzigd door RobIII op 11-11-2011 17:41 ]

[eamelink]

RobIII schreef op vrijdag 11 november 2011 @ 17:31:
http://php.net/manual/en/function.call-user-func.php

Noem je dat mooi?

Dit komt meer in de buurt: http://php.net/manual/en/functions.anonymous.php

[GewoonWatSpulle]

Kan inderdaad, staat ook op stackoverflow.com: Something like a delegate function in php maar is het ook nog niet helemaal vind ik.

Ik wil even kijken waar deze discussie als alternatief naar kan leiden!

[RobIII]

eamelink schreef op vrijdag 11 november 2011 @ 17:34:
Noem je dat mooi?

Hey; ik ben geen PHP-er

Daarbij heeft jouw suggestie (hoewel inderdaad mooier) wel wat haken en ogen:

quote: http://php.net/manual/en/functions.anonymous.php

Note: Anonymous functions are available since PHP 5.3.0.

Note: It was not possible to use $this from anonymous function before PHP 5.4.0.

In veel (hosted) omgevingen is PHP < 5.3 aanwezig is mijn (beperkte overigens) ervaring.

[ Voor 9% gewijzigd door RobIII op 11-11-2011 17:40 ]

[GewoonWatSpulle]

Lijkt mij inderdaad wel handig om even van 5.3 uit te gaan aangezien dat toch echt de versie is die je zou moeten draaien in de praktijk.

[NMe]

Ik denk dat het aantal keren dat je in een procedurele taal als PHP een anonieme functie binnen classcontext nodig hebt vrij klein is. Maar afgezien van call_user_func en deze nieuwe anonieme functies is er bij mijn weten geen non-deprecated alternatief in PHP voor dit soort constructies.

[RobIII]

While we're on the subject (maar dan voor .Net); misschien leuk om te lezen voor je:
http://geekswithblogs.net...ric-action-delegates.aspx
http://geekswithblogs.net...neric-func-delegates.aspx

NMe schreef op vrijdag 11 november 2011 @ 18:07:
Ik denk dat het aantal keren dat je in een procedurele taal als PHP een anonieme functie binnen classcontext nodig hebt vrij klein is.

Ja, maar als je als .Net-ter aan 't PHP-en gaat is zo'n voorbeeldje wel handig; de procedurele variant wijst zichzelf wel in de documentatie. Nu ben ik geen die-hard PHP-er maar de enige paar gevallen waar ik call_user_func nodig had (en dus geen anonymous functions kon gebruiken) had ik ze nou wél binnen classcontext nodig; en (ook omdat ik over wat regeltjes in de documentatie heen las ) daar heb ik toen best even op gepuzzeld . Ik zat maar $this of $x te passen als eerste argument, bleek ik een array($instance, 'methodname') te moeten gebruiken. WTF is dat voor vage constructie denk je dan als je een .Net achtergrond hebt

[ Voor 62% gewijzigd door RobIII op 11-11-2011 18:18 ]

[ReenL]

In php 5.3 kan je geen functie in een propety van je class direct uitvoeren. Dit kan wel (vanaf 5.3 niet in 5.2):

PHP:

<?php
class Page
{
    public $finishedLogics = null;

    public function doSomething()
    {
        $func = $this->finishedLogics;
        $func();
    }
}
$page = new Page();
$page->finishedLogics = function () { echo 'yay ik ben klaar'; };
$page->doSomething();

Logica of een pagina wel of niet goed laad, zul je zelf moeten implementeren. Onderaan een groot try catch blok?

Wil je $page gebruiken doe dan dit:

PHP:

$page->finishedLogics = function () use ($page) { echo 'yay ik ben klaar ' . get_class($page); };

[ Voor 13% gewijzigd door ReenL op 11-11-2011 19:20 ]

[NMe]

RobIII schreef op vrijdag 11 november 2011 @ 18:13:
WTF is dat voor vage constructie denk je dan als je een .Net achtergrond hebt

Dat denk je zonder .NET-achtergrond ook hoor.

[GewoonWatSpulle]

Ik was dit topic even uit het oog verloren maar ik heb een alternatieve oplossing bedacht die ook redelijk netjes is!

PHP:

$page = new Page();
$page->FinishedLogics();

Is wat er eigenlijk gebeurt in geval van een delegate functie, met wat logica in FinishedLogics(); gepropt.

PHP:

abstract class Page{ abstract function FinishedLogics(); }

PHP:

class StartPage extends Page{ function FinishedLogics(){ /* doe iets leuks */ } }

[ Voor 4% gewijzigd door GewoonWatSpulle op 17-11-2011 14:12 ]

[RobIII]

Dat is nogal een verschil met een delegate...

[NMe]

Sowieso kun je een abstracte class niet instantiëren en is het discutabel om het op deze manier te doen in plaats van middels een interface.

[GewoonWatSpulle]

Klopt er word geen Page geinstantieerd maar een StartPage.

De reden waarom ik niet voor een interface ben gegaan is omdat er in de base class Page ook wat logica verscholen zit.

Ik zeg niet dat dit DE oplossing is voor het gebrek aan delegate functies in PHP maar dit is naar mijn bescheiden mening een mooie oplossing voor het "probleem" waar ik mee te kampen had.

[NMe]

Je kan natuurlijk zowel een abstracte class deriven en een interface implementen:

PHP:

class StartPage extends Page implements Finalizable { /* ... */ }

[GewoonWatSpulle]

Hmm goed punt, vanavond nog maar eens een keer alles verbouwen

[Kajel]

RobIII's manier lijkt een beetje op de Objective-C manier. Als je ontwikkelt voor iOS, kom je het gebruik van delegates ook heel veel tegen. Dit is hoe ik het in PHP zou oplossen, met een half oog kijkend naar Objective-C/iOS:

De interface:

PHP:

<?php
interface PageDelegate {
    
    function finishedLoading();

}
?>

De Page class:

PHP:

<?php
class Page {
    
    private PageDelegate $_pageDelegate;
    
    function setDelegate(PageDelegate $p) {
        $_pageDelegate = $p;
    }
    
    function load() {
        // Do all loading stuff
        
        // and in the end...
        if($_pageDelegate) {
            $_pageDelegate->finishedLoading();
        }
    }
}
?>

De class die de delegate functie gaat bevatten:

PHP:

<?php
class SomeController implements PageDelegate {
    
    function pageAction($request) {
        $page = new Page();
        $page->setDelegate($this);
    }
    
    function finishedLoading() {
        echo "It's done!";
    }
    
}
?>

[ZpAz]

NMe schreef op vrijdag 11 november 2011 @ 18:07:
Ik denk dat het aantal keren dat je in een procedurele taal als PHP een anonieme functie binnen classcontext nodig hebt vrij klein is. Maar afgezien van call_user_func en deze nieuwe anonieme functies is er bij mijn weten geen non-deprecated alternatief in PHP voor dit soort constructies.

Lithium van wat ik heb gezien is het idee ongeveer gelijk aan Node.JS, een anonieme functie voor vanalles dmv callbacks.

Obj-C "sprinkelt" delegation ook overal overheen idd.

[ Voor 4% gewijzigd door ZpAz op 18-11-2011 20:19 ]

[iH8]

ZF2 heeft een eventmanager: http://mwop.net/blog/266-Using-the-ZF2-EventManager Fijn spul.