Qual è il modo migliore per implementare una classe di pattern singleton in Actionscript 3?

Question

Poiché AS3 non consente costruttori privati, sembra l'unico modo per costruire un singleton e garantire che il costruttore non sia esplicitamente creato tramite " new " è passare un singolo parametro e controllarlo.

Ho sentito due consigli, uno è quello di controllare il chiamante e assicurarsi che sia getInstance statico (), e l'altro deve avere una classe privata / interna nello stesso spazio dei nomi del pacchetto.

L'oggetto privato passato al costruttore sembra preferibile ma non sembra che tu possa avere una classe privata nello stesso pacchetto. È vero? E, soprattutto, è il modo migliore per implementare un singleton?

Answer 1

Un leggero adattamento della risposta di enobrev è avere istanza come getter. Alcuni direbbero che questo è più elegante. Inoltre, la risposta di enobrev non impone un Singleton se si chiama il costruttore prima di chiamare getInstance. Questo potrebbe non essere perfetto, ma l'ho provato e funziona. (C'è sicuramente un altro buon modo per farlo nel libro "Advanced ActionScrpt3 with Design Patterns").

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

Lo sto usando da un po 'di tempo, che credo di aver avuto originariamente da Wikipedia di tutti i luoghi.

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

Ecco un interessante riassunto del problema, che porta a un soluzione simile

Answer 3

Puoi prendere una lezione privata in questo modo:

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

Il modello utilizzato da Cairngorm (che potrebbe non essere il migliore) è quello di lanciare un'eccezione di runtime nel costruttore se il costruttore viene chiamato una seconda volta. Ad esempio:

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

}