Evaluación diferida en Ruby

Question

Tengo una situación para Ruby, donde posiblemente sea necesario crear un objeto, pero no es seguro. Y como la creación del objeto puede ser costosa, no estoy demasiado ansioso por crearla. Creo que este es un caso claro para la carga lenta. ¿Cómo puedo definir un objeto que no se crea solo cuando alguien le envía un mensaje? El objeto se crearía en un bloque. ¿Hay alguna forma de carga/inicialización simple y diferida en Ruby? ¿Estas cosas son compatibles con algunas gemas, que proporcionan diferentes soluciones para varios casos de inicialización perezosa de objetos? Gracias por tus sugerencias!

Answer 1

Hay dos formas.

El primero es dejar que el llamador maneje la creación de objetos perezosos. Esta es la solución más simple, y es un patrón muy común en código Ruby.

class ExpensiveObject 
    def initialize 
    # Expensive stuff here. 
    end 
end 

class Caller 
    def some_method 
    my_object.do_something 
    end 

    def my_object 
    # Expensive object is created when my_object is called. Subsequent calls 
    # will return the same object. 
    @my_object ||= ExpensiveObject.new 
    end 
end 

La segunda opción es dejar que el objeto se inicialice con pereza. Creamos un objeto delegado alrededor de nuestro objeto real para lograr esto. Este enfoque es un poco más complicado y no recomendado a menos que tenga un código de llamada existente que no pueda modificar, por ejemplo.

class ExpensiveObject  # Delegate 
    class RealExpensiveObject # Actual object 
    def initialize 
     # Expensive stuff here. 
    end 

    # More methods... 
    end 

    def initialize(*args) 
    @init_args = args 
    end 

    def method_missing(method, *args) 
    # Delegate to expensive object. __object method will create the expensive 
    # object if necessary. 
    __object__.send(method, *args) 
    end 

    def __object__ 
    @object ||= RealExpensiveObject.new(*@init_args) 
    end 
end 

# This will only create the wrapper object (cheap). 
obj = ExpensiveObject.new 

# Only when the first message is sent will the internal object be initialised. 
obj.do_something 

También es posible usar el stdlib delegate para construir esta en la parte superior de.

Answer 2

Si desea evaluar perezosamente piezas de código, utilice un proxy:

class LazyProxy 

    # blank slate... (use BasicObject in Ruby 1.9) 
    instance_methods.each do |method| 
    undef_method(method) unless method =~ /^__/ 
    end 

    def initialize(&lazy_proxy_block) 
    @lazy_proxy_block = lazy_proxy_block 
    end 

    def method_missing(method, *args, &block) 
    @lazy_proxy_obj ||= @lazy_proxy_block.call # evaluate the real receiver 
    @lazy_proxy_obj.send(method, *args, &block) # delegate unknown methods to the real receiver 
    end 
end 

A continuación, utilizar de esta manera:

expensive_object = LazyProxy.new { ExpensiveObject.new } 
expensive_object.do_something 

Usted puede utilizar este código para hacer la inicialización arbitrariamente compleja de cosas caras:

expensive_object = LazyProxy.new do 
    expensive_helper = ExpensiveHelper.new 
    do_really_expensive_stuff_with(expensive_helper) 
    ExpensiveObject.new(:using => expensive_helper) 
end 
expensive_object.do_something 

¿Cómo funciona? Crea una instancia de un objeto LazyProxy que contiene instrucciones sobre cómo construir algún objeto costoso en un Proc. Si luego llama a algún método en el objeto proxy, primero crea una instancia del objeto caro y luego delega la llamada al método.