पीएचपी

Question

में प्रतिनिधियों या कॉलबैक करने का सही तरीका मैं 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')); 
    } 

    ... 

}  

क्या ऐसा करने के लिए सही तरीका है।

पीएस

मैं उस उद्देश्य के लिए call_user_func का उपयोग कर रहा था और मानता हूं कि यह निजी वर्ग के सदस्यों को कॉल करने में सक्षम था, लेकिन विकास के कुछ सप्ताह बाद मुझे पता चला कि यह काम करना बंद कर दिया है। क्या यह मेरे कोड में एक बग था या यह कुछ और था जो मुझे लगता है कि 'call_user_func' कॉल निजी वर्ग के कार्यों को कॉल करने में सक्षम है, मुझे नहीं पता, लेकिन अब मैं सुरक्षित रूप से एक सरल, तेज़ और सुरुचिपूर्ण विधि की तलाश में हूं किसी के निजी वर्ग के सदस्य को दूसरे वर्ग से बुलाओ। मैं अभी बंद करने के लिए देख रहा हूं, लेकिन बंद होने के अंदर '$ this' के साथ समस्याएं हैं ...

Answer 1

वैसे भी, अगर कोई दिलचस्पी है, तो मुझे ReflectionMethod के माध्यम से एकमात्र संभावित समाधान मिला है। पीएचपी 5.3.2 के साथ इस विधि का उपयोग प्रदर्शन दंड देता है और क्लास सदस्य को कॉल करने से 2.3 गुना धीमा है, और कॉल_user_func विधि से केवल 1.3 गुना धीमा है। तो मेरे मामले में यह बिल्कुल स्वीकार्य है। अगर कोई दिलचस्पी लेता है तो कोड यहां दिया गया है:

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; 
    } 

} 

Answer 2

PHP में कॉलबैक अन्य भाषाओं में कॉलबैक की तरह नहीं हैं। विशिष्ट भाषाएं पॉइंटर्स के रूप में कॉलबैक का प्रतिनिधित्व करती हैं, जबकि PHP उन्हें तारों के रूप में दर्शाती है। स्ट्रिंग या array() वाक्यविन्यास और कॉल के बीच कोई "जादू" नहीं है। call_user_func(array($obj, 'str')) वाक्य रचनात्मक रूप से $obj->str() जैसा ही है। यदि str निजी है, तो कॉल विफल हो जाएगा।

आपको बस अपना ईवेंट हैंडलर सार्वजनिक बनाना चाहिए। इसका वैध अर्थपूर्ण अर्थ है, यानी, "मेरी कक्षा के बाहर से बुलाया जाने वाला इरादा है।"

इस कार्यान्वयन विकल्प अन्य रोचक साइड इफेक्ट, उदाहरण के लिए:

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' 
}