Algo así como una función de delegado de devolución de llamada en php

Question

Me gustaría implementar algo similar a un método delegado C# en PHP. Una palabra rápida para explicar lo que trato de hacer en general: estoy tratando de implementar algunas funciones asincrónicas. Básicamente, algunas llamadas de uso intensivo de recursos que se ponen en cola, se almacenan en caché y se envían cuando el sistema subyacente se acerca. Cuando la llamada asíncrona finalmente recibe una respuesta, me gustaría que se produzca un evento de devolución de llamada.

Tengo algunos problemas para encontrar un mecanismo para realizar devoluciones de llamada en PHP. He encontrado un método que funciona por ahora pero no estoy contento con él. Básicamente implica pasar una referencia al objeto y el nombre del método que servirá como la devolución de llamada (tomando la respuesta como argumento) y luego usar eval para llamar al método cuando sea necesario. Esto no es óptimo por una variedad de razones, ¿hay alguna manera mejor de hacer esto que nadie sepa?

Answer 1

(Aparte del patrón de observador) también se puede utilizar call_user_func() o call_user_func_array().

Si pasa un array(obj, methodname) como primer parámetro se invocará como $obj->methodname().

<?php 
class Foo { 
    public function bar($x) { 
     echo $x; 
    } 
} 

function xyz($cb) { 
    $value = rand(1,100); 
    call_user_func($cb, $value); 
} 

$foo = new Foo; 
xyz(array($foo, 'bar')); 
?> 

Answer 2

¿Qué piensa sobre el uso del patrón Observer? Si no es así, se puede implementar una verdadera devolución de llamada de esta manera:

// This function uses a callback function. 
function doIt($callback) 
{ 
    $data = "this is my data"; 
    $callback($data); 
} 


// This is a sample callback function for doIt(). 
function myCallback($data) 
{ 
    print 'Data is: ' . $data . "\n"; 
} 


// Call doIt() and pass our sample callback function's name. 
doIt('myCallback'); 

Muestra: los datos: se trata de mis datos

Answer 3

Me preguntaba si podríamos utilizar __invoke método mágico para crear "una especie de" función de primera clase y por lo tanto poner en práctica una devolución de llamada

sonido algo por el estilo, para PHP 5,3

interface Callback 
{ 
    public function __invoke(); 
} 

class MyCallback implements Callback 
{ 
    private function sayHello() { echo "Hello"; } 
    public function __invoke() { $this->sayHello(); } 
} 

class MySecondCallback implements Callback 
{ 
    private function sayThere() { echo "World"; } 
    public function __invoke() { $this->sayThere(); } 
} 

class WhatToPrint 
{ 
    protected $callbacks = array(); 
    public function register (Callback $callback) 
    { 
     $this->callbacks[] = $callback; 
     return $this; 
    } 
    public function saySomething() 
    { 
     foreach ($this->callbacks as $callback) $callback(); 
    } 
} 

$first_callback = new MyCallback; 
$second_callback = new MySecondCallback; 
$wrapper = new WhatToPrint; 
$wrapper->register($first_callback)->register($second_callback)->saySomething(); 

---

Se imprimirá HelloWorld

Espero que ayude;)

Pero prefiero el patrón del Controlador con SPL para dicha función.