La bonne façon de faire des délégués ou des rappels en PHP

J'ai besoin pour mettre en œuvre le schéma suivant en php:

class EventSubscriber
{
private $userCode;
public function __construct(&$userCode) { $this->userCode = &$userCode; }
public function Subscribe($eventHandler) { $userCode[] = $eventHandler; }
}
class Event
{
private $subscriber;
private $userCode = array();
public function __construct()
{
$this->subscriber = new Subscriber($this->userCode)
}
public function Subscriber() { return $this->subscriber; }
public function Fire()
{
foreach ($this->userCode as $eventHandler)
{
/* Here i need to execute $eventHandler  */
}
}
}
class Button
{
private $eventClick;
public function __construct() { $this->eventClick = new Event(); }
public function EventClick() { return $this->eventClick->Subscriber(); }
public function Render()
{
if (/* Button was clicked */) $this->eventClick->Fire();
return '<input type="button" />';
}
}
class Page
{
private $button;
//THIS IS PRIVATE CLASS MEMBER !!!
private function ButtonClickedHandler($sender, $eventArgs)
{
echo "button was clicked";
}
public function __construct()
{
$this->button = new Button();
$this->button->EventClick()->Subscribe(array($this, 'ButtonClickedHandler'));
}
...
}

quelle est la façon correcte de le faire.

P. S.

J'ai été en utilisant call_user_func à cette fin et croyez-le ou pas, il a été en mesure d'appeler privée membres de la classe, mais après quelques semaines de développement, j'ai trouvé qu'il a cessé de travailler. Était-il un bug dans mon code ou était-ce une autre chose qui m'a fait penser que "call_user_func' appel privé des fonctions de classe, je ne sais pas, mais maintenant, je suis à la recherche d'un moyen simple, rapide et élégant méthode de l'appel en toute sécurité privée d'un membre de la classe de l'autre classe. Je suis à la recherche de fermetures pour l'instant, mais ont des problèmes avec "$this " à l'intérieur fermeture...

$this n'est pas pris en charge par des Fermetures (comme indiqué dans le manuel) et les membres privés sont privés, parce qu'ils la, qui a déclaré comme privés, ne veulent pas être appelés à partir d'un objet d'une classe différente. C'est la définition de "membre privé" 😉
Oui, les membres privés sont privés parce qu'ils sont privés 🙂 Mais imaginez que vous dites à votre bouton " Hey bouton execute mon code confidentiel, dans "ButtonClickedHandler" quand vous serez cliqué sur". Dans ce cas, je ne vois pas pourquoi le bouton doit répondre " Oh, je ne veux pas pour l'exécution de votre code, car il est privé, la rendre publique, alors je vais...", Mais soit je ne vois pas de raison pourquoi devrais-je faire mon code privé - public... Espérons que vous obtenez le point
PHP n'est pas .Net. À la différence de beurre d'arachide et chocolat. PHP ne sera pas meilleur goût avec ces choses entassé. Aussi, toute personne qui vient après vous serez probablement jeter votre code et de le reconstruire tous d'une façon saine.
Acceptez que php n'est pas .net, mais il n'y a rien de mal à avoir une programmation orientée objet wrapper pour php, personne n'a forcé à l'utiliser. Je ne peux pas supporter de spaghettis que php encourage les développeurs à faire.

OriginalL'auteur Lu4 | 2011-01-03

  1. 4

    Rappels en PHP ne sont pas comme les rappels dans la plupart des autres langues. Typique langues représentent les rappels comme les pointeurs, alors que PHP les représente comme des chaînes de caractères. Il n'y a pas de "magie" entre la corde ou array() de la syntaxe et de l'appel. call_user_func(array($obj, 'str')) est la syntaxe est la même que $obj->str(). Si str est privé, l'appel échouera.

    Vous devez simplement faire de votre gestionnaire d'événement public. Ceci est valable sens sémantique, c'est à dire, "destiné à être appelé de l'extérieur de ma classe."

    Cette mise en œuvre, le choix a d'autres effets secondaires sont intéressants, par exemple:

    class Food {
static function getCallback() {
return 'self::func';
}
static function func() {}
static function go() {
call_user_func(self::getCallback());  //Calls the intended function
}
}
class Barf {
static function go() {
call_user_func(Food::getCallback());  //'self' is interpreted as 'Barf', so:
}                                         //Error -- no function 'func' in 'Barf'
}
    Merci zildjohn01, en fait j'ai été en utilisant cette approche avant que la chose intéressante, la façon dont php gère le contexte, parce que call_user_func semble être de travailler avec le privé, les méthodes de la classe à l'intérieur de la classe elle-même. Mais arrête de travailler à l'extérieur. Quant à faire de ma gestionnaires d'événements publics, je pense que c'est de la pure mal en termes de programmation orientée objet, et je cherchais un moyen d'appeler privé des membres de la classe en dehors de la classe elle-même, et cela est possible en PHP avec l'aide de ReflectionMethod, regardez le post ci-dessous. En tout cas merci de prendre la peine de répondre.

    OriginalL'auteur zildjohn01

  2. 4

    De toute façon, si quelqu'un est intéressé, j'ai trouvé la seule solution possible via ReflectionMethod. À l'aide de cette méthode avec Php 5.3.2 donne des performances et est 2,3 fois plus lent que l'appel de la classe membre directement, et seulement 1,3 fois plus lent que call_user_func méthode. Donc dans mon cas il est absolument acceptable. Voici le code si quelqu'un d'intéressé:

    class EventArgs {
}
class EventEraser {
private $eventIndex;
private $eventErased;
private $eventHandlers;
public function __construct($eventIndex, array &$eventHandlers) {
$this->eventIndex = $eventIndex;
$this->eventHandlers = &$eventHandlers;
}
public function RemoveEventHandler() {
if (!$this->eventErased) {
unset($this->eventHandlers[$this->eventIndex]);
$this->eventErased = true;
}
}
}
class EventSubscriber {
private $eventIndex;
private $eventHandlers;
public function __construct(array &$eventHandlers) {
$this->eventIndex = 0;
$this->eventHandlers = &$eventHandlers;
}
public function AddEventHandler(EventHandler $eventHandler) {
$this->eventHandlers[$this->eventIndex++] = $eventHandler;
}
public function AddRemovableEventHandler(EventHandler $eventHandler) {
$this->eventHandlers[$this->eventIndex] = $eventHandler;
$result = new EventEraser($this->eventIndex++, $this->eventHandlers);
return $result;
}
}
class EventHandler {
private $owner;
private $method;
public function __construct($owner, $methodName) {
$this->owner = $owner;
$this->method = new \ReflectionMethod($owner, $methodName);
$this->method->setAccessible(true);
}
public function Invoke($sender, $eventArgs) {
$this->method->invoke($this->owner, $sender, $eventArgs);
}
}
class Event {
private $unlocked = true;
private $eventReceiver;
private $eventHandlers;
private $recursionAllowed = true;
public function __construct() {
$this->eventHandlers = array();
}
public function GetUnlocked() {
return $this->unlocked;
}
public function SetUnlocked($value) {
$this->unlocked = $value;
}
public function FireEventHandlers($sender, $eventArgs) {
if ($this->unlocked) {
//защита от рекурсии
if ($this->recursionAllowed) {
$this->recursionAllowed = false;
foreach ($this->eventHandlers as $eventHandler) {
$eventHandler->Invoke($sender, $eventArgs);
}
$this->recursionAllowed = true;
}
}
}
public function Subscriber() {
if ($this->eventReceiver == null) {
$this->eventReceiver = new EventSubscriber($this->eventHandlers);
}
return $this->eventReceiver;
}
}

    OriginalL'auteur Lu4

  3. 0

    Comme le temps passe, plus il y a de nouvelles façons de réaliser cela.
    Actuellement, le PSR-14 est rédigé de façon à gérer ce cas d'utilisation.

    De sorte que vous pourriez trouver un de ces intéressantes:
    https://packagist.org/?query=psr-14

    La coqueluche de 8 ans à émerger pour un tel concept simple, je ne sais pas comment tout le monde vivait en passer pendant tout ce temps, une bonne rappels tellement naturels, comme la respiration

    OriginalL'auteur scones