Référencement au parent à partir d'un objet enfant

Question

Ma question concerne la meilleure pratique pour accéder au parent d'un objet enfant.Supposons qu'une classe instancie une autre classe, cette instance de classe est désormais référencée avec un objet.À partir de cet objet enfant, quelle est la meilleure façon de faire référence à l'objet parent ?Actuellement, je connais quelques méthodes que j'utilise souvent, mais je ne sais pas si A) il existe une meilleure façon de le faire ou B) laquelle d'entre elles est la meilleure pratique.

La première méthode consiste à utiliser getDefinitionByName, qui n'instancierait pas cette classe, mais permettrait l'accès à tout ce qu'elle contient qui a été déclaré publiquement.

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

Et puis référencez cette variable en fonction de sa hiérarchie parent-enfant.
Exemple, si l'enfant tente de référencer une classe située à deux niveaux de lui-même :

_class(parent.parent).function();

Cela semble fonctionner correctement, mais vous devez connaître le niveau auquel se trouve l'enfant par rapport au niveau du parent auquel vous tentez d'accéder.

Je peux également obtenir l'instruction suivante pour tracer [object ClassName] dans la sortie de Flash.

trace(Class);

Je ne suis pas à 100% sur l'implémentation de cette ligne, je ne l'ai pas considérée comme un moyen de référencer un objet en dehors de l'objet actuel dans lequel je me trouve.

Une autre méthode que j'ai vue utilisée consiste simplement à transmettre une référence à ceci dans l'objet de classe que vous créez et à l'attraper simplement avec un argument de constructeur.

var class:Class = new Class(this);  

puis dans le fichier Classe

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

Cette référence vous oblige également à revenir en arrière en utilisant la hiérarchie enfant-parent.

Je pourrais également importer cette classe, puis utiliser le chemin de fichier direct pour référencer une méthode à l'intérieur de cette classe, qu'elle soit parent ou non.

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

Bien sûr, la relation parent-enfant n'est pas pertinente car j'accède à la méthode ou à la propriété directement via la classe importée.

J'ai juste l'impression qu'il me manque quelque chose de vraiment évident ici.Je cherche essentiellement à confirmer si ce sont les bonnes façons de référencer le parent, et si oui, laquelle est la plus idéale, ou est-ce que j'oublie autre chose ?

Answer 1

Il est généralement bon d'avoir la classe comme sa propre instance et de réduire le couplage étroit à autre chose (comme dans ce cas, c'est son parent).Si vous faites quelque chose comme parent.doSomething(), il n'est pas possible d'utiliser cette classe dans un conteneur qui n'a pas la méthode doSometing().Je pense qu'il est définitivement préférable de transmettre tout ce dont la classe peut avoir besoin, puis à l'intérieur de la classe, il n'est plus nécessaire de faire de parent.parent, etc.

Avec cela, si vous souhaitez modifier la structure à l'avenir, il est très simple de simplement transmettre une nouvelle référence ;l'implémentation de la classe enfant n'a pas du tout besoin de changer.

La troisième alternative que vous avez ici est également très différente, elle consiste à accéder à une méthode statique au niveau de la classe (vous n'avez pas besoin de taper le chemin de classe complet pour accéder à cette méthode), et non à une méthode d'instance comme dans les deux premières.

Answer 2

En général, si vous avez besoin qu’un enfant communique avec un parent, vous devriez envisager de le faire en diffusant des événements.Cela découple l'enfant pour le parent et permet à d'autres classes de travailler avec l'enfant.

Je ne recommanderais pas de transmettre une référence à la classe parent à l'enfant.

Voici un exemple simple (je l'ai testé/compilé donc il peut y avoir quelques fautes de frappe).

//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");
        }

    }
}

Dans la plupart des cas, vous distribuerez des événements personnalisés et transmettrez des données avec eux.

Essentiellement:

Parent fait référence à Child et communique via des appels de méthode.L'enfant n'a aucune référence au parent et communique (avec n'importe qui) via des événements de répartition.

J'espère que cela pourra aider...

chambres de micro

mesh@adobe.com

Answer 3

J'ai toujours utilisé votre deuxième méthode, en passant un pointeur vers l'objet parent à l'enfant et en stockant ce pointeur dans une variable membre de la classe enfant.Cela me semble être la méthode la plus simple permettant à l’enfant de communiquer avec ses parents.

Answer 4

J'aime transmettre le parent en tant qu'interface (afin que la classe puisse être contenue dans n'importe quel parent implémentant cette interface) ou implémenter la référence en tant que pointeur/délégué d'événement/fonction auquel le parent peut s'accrocher.

Answer 5

J'aime configurer une classe globale pour gérer les références aux classes auxquelles toute autre classe doit accéder, pas nécessairement l'enfant.

La classe globale se compose simplement de getters et setters statiques comme ceci :

private static const class:Class;

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

Ce qui est bien, c'est que vous n'avez pas besoin d'importer la classe que vous renvoyez de la classe globale, mais simplement la classe globale elle-même.

La classe qui doit être référencée s'ajoute à la liste globale.L'autre avantage est que vous pouvez facilement envoyer des événements à partir de cet emplacement centralisé.

La plupart du temps, si une classe doit être référencée par des classes enfants ou toute autre classe, je le fais via une interface.

Answer 6

Si ces objets se trouvent dans la DisplayList, vous disposez d'options supplémentaires.Si j'ai une ParentClass et une ChildClass, dans la classe enfant, vous semblez pouvoir accéder au parent si vous lancez la demande en tant que ParentClass.par exemple.

ParentClass(parent).parentFunction();

Je sais avec certitude que cela fonctionne si ParentClass est la classe Document.Comme la classe Document est toujours le premier élément de la liste d'affichage, cela fonctionne :

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

Dans mon cas, ils étaient tous deux membres du même package, je n’ai donc même pas eu besoin d’importer quoi que ce soit.Je ne l'ai pas testé dans toutes les circonstances, mais il a fonctionné quand j'en avais besoin.

Bien sûr, « parent » et « getChild... » ne fonctionnent que si ces objets sont dans la DisplayList, mais cela me suffit.