¿Cuál es la mejor manera de implementar una clase de patrón singleton en Actionscript 3?

Question

Dado que AS3 no permite constructores privados, parece ser la única forma de construir un singleton y garantizar que el constructor no se cree explícitamente a través de " new " es pasar un solo parámetro y verificarlo.

He escuchado dos recomendaciones, una es verificar la persona que llama y asegurarse de que es getInstance () estática, y la otra es tener una clase privada / interna en el mismo espacio de nombres de paquete.

El objeto privado pasado en el constructor parece preferible, pero no parece que pueda tener una clase privada en el mismo paquete. ¿Es esto cierto? Y, lo que es más importante, ¿es la mejor manera de implementar un singleton?

Answer 1

Una ligera adaptación de la respuesta de enobrev es tener instancia como getter. Algunos dirían que esto es más elegante. Además, la respuesta de enobrev no impondrá un Singleton si llama al constructor antes de llamar a getInstance. Puede que esto no sea perfecto, pero lo he probado y funciona. (Definitivamente, hay otra buena manera de hacer esto en el libro "Advanced ActionScrpt3 with Design Patterns" también).

package {
    public class Singleton {

    private static var _instance:Singleton;

    public function Singleton(enforcer:SingletonEnforcer) {
        if( !enforcer) 
        {
                throw new Error( "Singleton and can only be accessed through Singleton.getInstance()" ); 
        }
    }

    public static function get instance():Singleton
    {
        if(!Singleton._instance)
        {
            Singleton._instance = new Singleton(new SingletonEnforcer());
        }

        return Singleton._instance;
    }
}

}
class SingletonEnforcer{}

Answer 2

He estado usando esto durante algún tiempo, que creo que originalmente obtuve de wikipedia de todos los lugares.

package {
    public final class Singleton {
        private static var instance:Singleton = new Singleton();

        public function Singleton() {
            if( Singleton.instance ) {
                throw new Error( "Singleton and can only be accessed through Singleton.getInstance()" ); 
            }
        }

        public static function getInstance():Singleton {                
            return Singleton.instance;
        }
    }
}

Aquí hay un resumen interesante del problema, que conduce a un Solución similar.

Answer 3

Puedes obtener una clase privada como esta:

package some.pack
{
  public class Foo
  {
    public Foo(f : CheckFoo)
    {
      if (f == null) throw new Exception(...);
    }
  }

  static private inst : Foo;
  static public getInstance() : Foo
  {
     if (inst == null)
         inst = new Foo(new CheckFoo());
     return inst;
  }
}

class CheckFoo
{
}

Answer 4

El patrón que utiliza Cairngorm (que puede no ser el mejor) es lanzar una excepción de tiempo de ejecución en el constructor si se llama al constructor por segunda vez. Por ejemplo:

public class Foo {
  private static var instance : Foo;

  public Foo() {
    if( instance != null ) { 
      throw new Exception ("Singleton constructor called");
    }
    instance = this;
  }

  public static getInstance() : Foo {
    if( instance == null ) {
      instance = new Foo();
    }
    return instance;
  }

}