Riferimento al genitore da un oggetto figlio

Question

La mia domanda riguarda la migliore pratica per accedere al genitore di un oggetto figlio.Quindi diciamo che una classe crea un'istanza di un'altra classe, a quell'istanza di classe viene ora fatto riferimento con un oggetto.Da quell'oggetto figlio, qual è il modo migliore per fare riferimento all'oggetto genitore?Attualmente conosco un paio di metodi che utilizzo spesso, ma non sono sicuro se A) esista un modo migliore per farlo o B) quale di essi sia la pratica migliore

Il primo metodo consiste nell'utilizzare getDefinitionByName, che non istanzia quella classe, ma consente l'accesso a qualsiasi cosa al suo interno che sia stata dichiarata pubblicamente.

_class:Class = getDefinitionByName("com.site.Class") as Class;

E quindi fare riferimento a quella variabile in base alla gerarchia da genitore a figlio.
Esempio, se il bambino sta tentando di fare riferimento a una classe che si trova a due livelli sopra se stessa:

_class(parent.parent).function();

Sembra funzionare bene, ma è necessario conoscere il livello a cui si trova il bambino rispetto al livello del genitore a cui stai tentando di accedere.

Posso anche ottenere la seguente istruzione per tracciare [object ClassName] nell'output di Flash.

trace(Class);

Non sono al 100% sull'implementazione di quella linea, non l'ho perseguita come un modo per fare riferimento a un oggetto al di fuori dell'oggetto corrente in cui mi trovo.

Un altro metodo che ho visto utilizzato è semplicemente passare un riferimento a questo nell'oggetto della classe che stai creando e catturarlo semplicemente con un argomento del costruttore

var class:Class = new Class(this);  

e poi nel file Class

public function Class(objectRef:Object) {
    _parentRef = objectRef;
} 

Questo riferimento richiede però anche di tornare indietro utilizzando la gerarchia da figlio a genitore.

Potrei anche importare quella classe e quindi utilizzare il percorso file diretto per fare riferimento a un metodo all'interno di quella classe, indipendentemente dal genitore o meno.

import com.site.Class;
com.site.Class.method();

Ovviamente la relazione genitore-figlio è irrilevante perché accedo al metodo o alla proprietà direttamente tramite la classe importata.

Mi sento come se mi mancasse qualcosa di veramente ovvio qui.Fondamentalmente sto cercando conferma se questi sono i modi corretti per fare riferimento al genitore e, in tal caso, qual è il più ideale o sto trascurando qualcos'altro?

Answer 1

In genere è utile avere la classe come istanza propria e ridurre lo stretto accoppiamento con qualcos'altro (come in questo caso, è il genitore).Se fai qualcosa come parent.doSomething() non è possibile utilizzare quella classe nel contenitore che non ha il metodo doSometing().Penso che sia decisamente meglio passare qualunque cosa la classe possa aver bisogno e poi all'interno della classe non deve più fare parent.parent ecc.

Con questo se in futuro desideri modificare la struttura, è molto semplice passare semplicemente un nuovo riferimento;l'implementazione della classe figlia non deve cambiare affatto.

Anche la terza alternativa che hai qui è molto diversa, sta accedendo a un metodo statico a livello di classe (non è necessario digitare l'intero percorso della classe quando accedi a quel metodo), non a un metodo di istanza come nei primi due.

Answer 2

In generale, se hai bisogno che un bambino comunichi con un genitore, dovresti cercare di farlo trasmettendo eventi.Ciò disaccoppia il bambino dal genitore e rende possibile che altre classi lavorino con il bambino.

Non consiglierei di passare un riferimento alla classe genitore al figlio.

Ecco un semplice esempio (l'ho testato/compilato quindi potrebbero esserci degli errori di battitura).

//Child.as
package
{
    import flash.events.EventDispatcher;
    import flash.events.Event;

    public class Child extends EventDispatcher
    {
        public function doSomething():void
        {
            var e:Event = new Event(Event.COMPLETE);
            dispatchEvent(e);
        }

        public function foo():void
        {
            trace("foo");
        }
    }
}


//Parent.as
package
{
    import flash.display.Sprite;
    import flash.events.Event;
    public class Parent extends Sprite
    {
        private var child:Child;
        public function Parent():void
        {
            c = new Child();
            c.addEventListener(Event.COMPLETE, onComplete);
            c.foo();//traces foo

            c.doSomething()
        }

        public function onComplete(e:Event):void
        {
            trace("Child broadcast Event.COMPLETE");
        }

    }
}

Nella maggior parte dei casi, invierai eventi personalizzati e passerai i dati con essi.

Fondamentalmente:

Il genitore ha riferimento al figlio e comunica tramite chiamate di metodo.Il bambino non ha riferimento al genitore e comunica (con chiunque) tramite l'invio di eventi.

Spero possa aiutare...

camere del microfono

mesh@adobe.com

Answer 3

Ho sempre utilizzato il tuo secondo metodo, passando un puntatore all'oggetto genitore al figlio e memorizzando quel puntatore in una variabile membro nella classe figlia.A me questo sembra essere il metodo più semplice con cui il bambino può comunicare con il genitore.

Answer 4

Mi piace passare il genitore come interfaccia (in modo che la classe possa essere contenuta in qualsiasi genitore che implementa quell'interfaccia) o implementare il riferimento come puntatore/delegato a evento/funzione a cui il genitore può agganciarsi.

Answer 5

Mi piace impostare una classe globale per gestire i riferimenti alle classi a cui deve accedere qualsiasi altra classe, non necessariamente la figlia.

La classe globale consiste semplicemente di getter e setter statici in questo modo:

private static const class:Class;

public static function setClass(_class:Class){
class = _class;
}
public static function getClass(void):Class{
return class;
}

La cosa bella è che non devi importare la classe che stai restituendo dalla classe globale, ma solo la classe globale stessa.

La classe a cui fare riferimento si aggiunge all'elenco globale.L'altra cosa interessante è che puoi inviare facilmente eventi da questa posizione centralizzata.

La maggior parte delle volte se è necessario che una classe faccia riferimento a classi figlie o qualsiasi altra classe, lo faccio tramite un'interfaccia.

Answer 6

Se questi oggetti si trovano nella DisplayList, hai altre opzioni.Se ho una ParentClass e una ChildClass, nella classe figlia, sembra che tu possa accedere al genitore se trasmetti la richiesta come ParentClass.per esempio.

ParentClass(parent).parentFunction();

So per certo che funziona se ParentClass è la Document Class.Poiché la classe documento è sempre il primo elemento nell'elenco di visualizzazione, funziona:

ParentClass(stage.getChildAt(0)).parentFunction();

Nel mio caso erano entrambi membri dello stesso pacchetto, quindi non ho avuto bisogno di importare nulla.Non l'ho testato in tutte le circostanze, ma ha funzionato quando ne avevo bisogno.

Ovviamente 'parent' e 'getChild...' funzionano solo se questi oggetti sono nella DisplayList, ma per me è stato abbastanza buono.