Fazendo referência ao pai a partir de um objeto filho

Question

Minha pergunta refere-se às melhores práticas para acessar o pai de um objeto filho.Então, digamos que uma classe instancie outra classe, essa instância de classe agora é referenciada por um objeto.A partir desse objeto filho, qual é a melhor maneira de fazer referência ao objeto pai?Atualmente conheço algumas maneiras que uso com frequência, mas não tenho certeza se A) existe uma maneira melhor de fazer isso ou B) qual delas é a melhor prática

O primeiro método é usar getDefinitionByName, que não instanciaria essa classe, mas permitiria acesso a qualquer coisa dentro dela que fosse declarada publicamente.

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

E então faça referência a essa variável com base em sua hierarquia pai para filho.
Exemplo, se o filho estiver tentando fazer referência a uma classe que está dois níveis acima dela:

_class(parent.parent).function();

Isso parece funcionar bem, mas você precisa saber o nível em que o filho está comparado ao nível do pai que você está tentando acessar.

Também posso obter a seguinte instrução para rastrear [object ClassName] na saída do Flash.

trace(Class);

Não estou 100% na implementação dessa linha, não a segui como uma forma de referenciar um objeto fora do objeto atual em que estou.

Outro método que vi ser usado é simplesmente passar uma referência a this para o objeto de classe que você está criando e capturá-lo com um argumento construtor

var class:Class = new Class(this);  

e depois no arquivo de classe

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

Essa referência também exige que você volte a usar a hierarquia filho para pai.

Eu também poderia importar essa classe e usar o caminho de arquivo direto para fazer referência a um método dentro dessa classe, independentemente de ser pai ou não.

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

É claro que o relacionamento pai-filho é irrelevante porque estou acessando o método ou propriedade diretamente através da classe importada.

Eu simplesmente sinto que estou perdendo algo realmente óbvio aqui.Basicamente, estou procurando a confirmação se essas são as maneiras corretas de fazer referência aos pais e, em caso afirmativo, qual é a mais ideal ou estou negligenciando outra coisa?

Answer 1

Geralmente é bom ter a classe como sua própria instância e reduzir o acoplamento rígido a outra coisa (como neste caso, é pai).Se você fizer algo como parent.doSomething() não é possível usar aquela classe em container que não possui o método doSometing().Eu acho que é definitivamente melhor passar tudo o que a classe precisa e, dentro da classe, não é mais necessário fazer nenhum parent.parent etc.

Com isso se futuramente você quiser mudar a estrutura, é muito fácil apenas passar uma nova referência;a implementação da classe filha não precisa mudar em nada.

A terceira alternativa que você tem aqui também é muito diferente, é acessar um método estático em nível de classe (você não precisa digitar todo o caminho da classe ao acessar esse método), e não um método de instância como nos dois primeiros.

Answer 2

Em geral, se você precisa que uma criança se comunique com os pais, você deve tentar fazer isso por meio da transmissão de eventos.Isso separa o filho do pai e possibilita que outras classes trabalhem com o filho.

Eu não recomendaria passar uma referência à classe pai para o filho.

Aqui está um exemplo simples (eu testei/compilei, então pode haver alguns erros de digitação).

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

    }
}

Na maioria dos casos, você despacharia eventos personalizados e passaria dados com eles.

Basicamente:

Parent faz referência a Child e se comunica por meio de chamadas de método.Child não tem referência ao Parent e se comunica (com qualquer pessoa) por meio de envio de eventos.

espero que ajude...

câmaras de microfone

mesh@adobe.com

Answer 3

Sempre usei seu segundo método, passando um ponteiro para o objeto pai para o filho e armazenando esse ponteiro em uma variável de membro na classe filho.Para mim, esse parece ser o método mais simples para a criança se comunicar com os pais.

Answer 4

Eu gosto de passar o pai como uma interface (para que a classe possa estar contida em qualquer pai que implemente essa interface) ou implementar a referência como um ponteiro/delegado de evento/função ao qual o pai pode se conectar.

Answer 5

Gosto de configurar uma classe global para lidar com referências a classes que precisam ser acessadas por qualquer outra classe, não necessariamente pelo filho.

A classe global consiste simplesmente em getters e setters estáticos assim:

private static const class:Class;

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

O bom disso é que você não precisa importar a classe que está retornando da classe global, apenas a própria classe global.

A classe que precisa ser referenciada é adicionada à lista global.A outra coisa legal é que você pode facilmente despachar eventos deste local centralizado.

Na maioria das vezes, se uma classe precisa ser referenciada por classes filhas ou qualquer outra classe, faço isso por meio de uma interface.

Answer 6

Se esses objetos estiverem no DisplayList, você terá mais algumas opções.Se eu tiver uma ParentClass e uma ChildClass, na classe filha, você parece conseguir acessar o pai se lançar a solicitação como ParentClass.por exemplo.

ParentClass(parent).parentFunction();

Tenho certeza de que funciona se ParentClass for a classe Document.Como a Classe do Documento é sempre o primeiro item na lista de exibição, isso funciona:

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

No meu caso, ambos eram membros do mesmo pacote, então nem precisei importar nada.Não testei em todas as circunstâncias, mas funcionou quando precisei.

É claro que 'parent' e 'getChild...' só funcionam se esses objetos estiverem no DisplayList, mas isso tem sido bom o suficiente para mim.