Existem muitos pontos onde podemos poupar o motor do flash, e não vou falar de todos mas apenas de 2, o weak reference em eventos e a atribuição de null.

Estes pontos trabalham directamente com o “core” do flash e podem poupar muitas dores de cabeça, embora eu não os use sempre, é importante que os conheçam no caso da sua aplicação ser comercial visto que pode poupar algumas dores de cebeça.
O flash possui um sistema de recolha de lixo, chamado de garbage collector ou apenas GC, ou seja, dentro da maquina virtual, periodicamente é vasculhado todo o código da aplicação à procura de elementos que já não sejam usados e no caso de encontrar algum o eliminar da memória, fazendo com que não seja ocupada memória desnecessária. Embora este sistema seja de extrema importancia ele contém algumas falhas e não faz o seu trabalho como deve ser… (não vou falar porque visto que é uma assunto muito debatido). Para evitar-mos uso da memória sem necessidade existem alguns truques, como o re-uso do código, arquitecturas de código bem feitas e exclusão de código desnecessário.

O weak reference, é uma “marca” que se pode atribuir a um evento, que faz com que o GC esteja atento a ele, e se este não for necessário o GC elimina-o… isto é muito util, visto que um eventListener é algo que usa memória, e por sinal, alguma memória… Por defeito o GC não elimina Listeners da memória, teriamos que o fazer manualmente usando o removeEventListener, não é que já não precisemos do removeEventListener, mas no caso de nos esquecer-mos de o escrever, o weakreference é uma óptima alternativa porque vai remover o listener automaticamente se este não for mais usado. Basta criarem os vossos eventos assim:

[coolcode]
meuObjecto.addEventListener(MouseEvent.CLICK, minhaFuncaoEscuta, false, 0, true);
[/coolcode]
onde o true indica que o evento deve ser marcado como weak reference, fazendo com que possa ser removido pelo GC. Todos os eventos podem ser considerados como weak references.

O weak reference, infelizmente apenas está disponivel nos eventos e em mais uma class, dictionary, mas que pouca gente usa. Embora tenha encontrado um hack que torna todos os objectos passiveis de serem marcados como wek Reference, este não me convenceu da sua real utilidade. Para quem estiver interessado em testar, veja o post aqui.

Outra dica é não deixar elementos soltos, ou seja, se uma variavel ou objecto não são mais necessários, elimine-os marcando-os como null.

Por exemplo:
[coolcode]
private var minhaVar1:Boolean;

minhaVar1=true;
[/coolcode]

Imaginem que apenas precisamos desta variavel uma unica vez, a maior parte das vezes deixa-mo-la assim, usamos e esquecemos a mesma, mas este pensamento está errado, porque apesar de não a usarmos mais, esta vai ficar sempre na memória, e não vai ser eliminada pelo garbage collector porque ela possui um valor… Mas podemos mudar este habito, e melhorar o desempenho da nossa aplicação, colocando:
[coolcode]
minhaVar1=null;
[/coolcode]
Desta forma a variavel será eliminada da memória pelo GC porque esta não possui nenhum valor.

A principal coisa a ter em mente é nunca esquecer de eliminar código que não seja necessário, eventos ou propriedades… depende de cada programador faze-lo, considerando sempre essa possibilidade principalmente quando a aplicação têm objectivos comerciais.

Embora existam alguns truques e inclusive um comando para executar o GC, este não aparenta melhorar o desempenho se não tomar-mos algumas das precauções em cima, mas para quem quiser testar a sua utilidade, por exemplo a seguir a alguns addChilds/removeCHild’s, basta escrever o código seguinte (apenas funciona nas versões debugger do flash e no AIR, nunca entendi porque não funcionam no flash player normal.):
[coolcode]
flash.system.System.gc();
[/coolcode]
ou usar um hack que já o vi funcionar, mas não parece ser muito lógico de usar em aplicações finais:
[coolcode]
private function gcHack():void
{
try
{
var lc1:LocalConnection = new LocalConnection();
var lc2:LocalConnection = new LocalConnection();
lc1.connect(‘name’);
lc2.connect(‘name’);
}
catch (e:Error) {
}
}
[/coolcode]
Este código, repetindo o localConnection parece disparar o GC, mas bom…visto que nao se pode garantir quaisquer vantagens em usa-lo, terá que decidir de o usar ou não.

Bom, espero que seja util.

Cumprimentos.

Vejam um exemplo de um “custom event” normal:

[coolcode]
var customEvent:Event = new Event(“meuEvento”);
[/coolcode]

Desta forma, acabamos por ter um evento pessoal chamado meuEvento que para o disparar:
[coolcode]
dispatchEvent(customEvent);
//ou directamente:
dispatchEvent(new Event(“meuEvento”));
[/coolcode]

Para escutar este evento:
[coolcode]
addEventListener(“meuEvento”, minhaFuncaoEvento);

private function minhaFuncaoEvento(evt:Event):void {
//codigo
}
[/coolcode]

Este é o procedimento normal de um custom event.

O meu problema na aplicação era de como passar dados no evento, ou seja, aproveitar um evento para enviar dados, por exemplo de um módulo para outro ou até simplesmente de um itemRender para o seu parent, ou tão simplesmente de um componente para outro. Se pensarmos que todos os eventos são classes, podemos pensar que estas podem ser extendidas, logo podem ser personalizados… vejamos um evento chamado meuEvPessoal:

[coolcode]
package
{
import flash.events.Event;

public class meuEvPessoal extends Event
{
public function meuEvPessoal(type:String, bubbles:Boolean=false, cancelable:Boolean=false)
{
super(type, bubbles, cancelable);
}

}
}
[/coolcode]

Neste momento temos um evento chamado meuEvPessoal derivado da class Event o que nos permite chama-lo da mesma forma que um evento:

[coolcode]
import meuEvPessoal;

dispatchEvent(new meuEvPessoal(“meuEvento”));

[/coolcode]
E escuta-lo da seguinte forma:

[coolcode]
addEventListener(“meuEvento”, minhaFuncaoEvento);

private function minhaFuncaoEvento(evt:meuEvPessoal):void {
//codigo
}
[/coolcode]
A partir de agora é simples, basta adicionar variaveis no nosso evento que elas estarão disponiveis na função que o escuta, vejam o evento:
[coolcode]
package
{
import flash.events.Event;

public class meuEvPessoal extends Event
{
public var itemID:int=0;
public var dados1:String=null;
public var dados2:Boolean=false;

public function meuEvPessoal(type:String, bubbles:Boolean=false, cancelable:Boolean=false)
{
super(type, bubbles, cancelable);
}

}
}
[/coolcode]
Neste momento podemos fazer:
[coolcode]
import meuEvPessoal;

var evento:meuEvPessoal = new meuEvPessoal(“meuEvento”);
evento.itemID=5;
evento.dados1=”OLA VINDO DO EVENTO!”;
evento.dados2=true;
dispatchEvent(evento);
[/coolcode]
Nesta altura o evento é disparado com as variaveis alteradas, pelo que na função de escuta estes dados estão disponiveis:
[coolcode]
addEventListener(“meuEvento”, minhaFuncaoEvento);

private function minhaFuncaoEvento(evt:meuEvPessoal):void {
trace(“Evento Detectado: “+evt.name);
trace(“itemID: “+evt.itemID);
trace(“dados1: “+evt.dados1);
trace(“dados2: “+evt.dados2);
}
[/coolcode]

E pronto, é isto… uma dica muito util… principalmente quando estamos sem saida na hora de passar dados de um componente para o outro, mas existem centenas de casos em que este uso se torna viável.

Espero que seja util.

Abraço.

Primeiro, temos que compreender as 2 diferentes maneiras de mostrar um alert, a segunda maneira é mais complexa, mas mais “personalizavel”… pelo que agora depende principalmente das vossas necessidades.

A mais simples:

import mx.controls.Alert;

//Alert.show("texto","titulo",botões);

Alert.show("um alerta","com titulo",Alert.NO | Alert.YES);

A mais complexa:

import mx.controls.Alert;

var meuAlerta:Alert = new Alert;

meuAlerta.text="um alerta";

meuAlerta.title="com titulo";

meuAlerta.buttonFlags=Alert.NO + Alert.YES;

addChild(meuAlerta);

E voilá! Temos duas maneiras de mostrar os alertas, agora para sabermos que botão foi clicado (ao clicar o botão o Alert fecha e dispara um CloseEvent que no seu parametro .detail “traz” a informação do botão clicado, ou seja, para isso temos que escutar esse CloseEvent, fazendo assim:

na primeira maneira:

import mx.controls.Alert;

import mx.events.CloseEvent;

Alert.show("um alerta","com titulo", Alert.NO | Alert.Yes, null, fechado);

//a função fechado ao ser definida aqui indica ao alert que terá que escutar 

//e chamar a função fechado quando ele for fechado ao clicar de um dos seu botoes

na segunda, basta adicionar antes do addChild() o seguinte:

meuAlerta.addEventListener(Event.CLOSE, fechado);

e finalmente a função que lida com os detalhes do evento close do nosso alerta:

private function fechado(evento:CloseEvent):void {

if(evento.detail==Alert.YES) //YES clicado

if(evento.detail==Alert.NO) //NO clicado

}

e está feito… podem ainda usar:

if(evento.detail==Alert.OK) //ok clicado
if(evento.detail==Alert.YES) //YES clicado
if(evento.detail==Alert.NO) //NO clicado
if(evento.detail==Alert.CANCEL) //CANCEL clicado

Bem simples, mas espero que seja util a alguém..

Abraço.