######################################################
# Ministério da Saúde Adverte: Este post será bem maior do que o
# convencional e esta explicação sobre o funcionamento viciante
# do Data Binding pode fazer o seu cérebro entrar em loop.
######################################################
O [Bindable] é uma Metadata Tag o que significa dizer que é uma
instrução para o compilador fazer alguma coisa. Neste caso você está
falando para o compilador gerar o código necessário para sua
propriedade ser a fonte do DataBinding.
O segredo do funcionamento do DataBinding está na classe
"mx.binding.utils.ChangeWatcher". Esta classe se baseia em listeners
para fazer a "mágica" do DataBinding.
Tomemos o seguinte trecho de código abaixo para facilitar a
explicação:
<mx:TextInput id="tiSource"/>
<mx:TextInput id="tiDestination" text="{tiSource.text}"/>
Neste exemplo, toda vez que o usuário digitar algo no TextInput
"tiSource" isto será automaticamente copiado para o TextInput
"tiDestination".
Isto é possível porque a propriedade "text" é Bindable. Como tal, toda
vez que esta propriedade mudar ela distribuirá um evento - que neste
caso é chamado de "textChanged". Graças ao ChangeWatcher, que é usado
implicitamente toda vez que usamos as chaves {} para determinar o
Binding, será criado automaticamente um EventHandler para tratar este
evento "textChanged". A implementação deste EventHandler pegará o
valor do "text" de "tiSource" e copiará para o "text" de
"tiDestination".
Em outras palavras, a mágica do DataBinding é um código que é gerado
automaticamente pelo compilador do Flex que se baseia na arquitetura
Listener - Handler que já conhecemos: alguém distribui um evento e
alguém ouve para fazer alguma coisa. Neste caso uma propriedade muda,
e um código gerado automaticamente através de uma sintaxe predefinida
(chaves{}) copia o valor desta propriedade para outra.
Eu fiz um teste no Flex usando a opção keep-generated-
actionscript=true com uma propriedade Bindable e o resultado segue
abaixo.
Test.mxml
========
<?xml version="1.0" encoding="utf-8"?>
<mx:Application xmlns:mx="http://www.adobe.com/2006/mxml";
width="100%" height="100%">
<mx:Script>
<![CDATA[
[Bindable]
private var myProp:String;
]]>
</mx:Script>
</mx:Application>
_Test-binding-generated.as (Código gerado pelo compilador Flex)
======================================================
class BindableProperty
{
[Bindable(event="propertyChange")]
private function get myProp():String
{
return this._1060147409myProp;
}
private function set myProp(value:String):void
{
var oldValue:Object = this._1060147409myProp;
if (oldValue !== value)
{
this._1060147409myProp = value;
dispatchEvent(mx.events.PropertyChangeEvent.createUpdateEvent(this,
"myProp", oldValue, value));
}
}
}
Ou seja, o usar o [Bindable] o compilador Flex gerou o arquivo "_Test-
binding-generated.as" cujo conteúdo pode ser visto acima. Observe que
no "set" da propriedade um evento é disparado. No MXML acima se a
propriedade "myProp " não fosse Bindable este código não seria gerado.
Mas isso é só uma parte do funcionamento do Bindable. Ainda é preciso
definir o que irá acontecer toda vez que o "myProp" mudar.
Primeiramente apenas definimos a propriedade como Bindable. Agora
vamos usá-la.
Test.mxml
========
<?xml version="1.0" encoding="utf-8"?>
<mx:Application xmlns:mx="http://www.adobe.com/2006/mxml";
width="100%" height="100%">
<mx:Script>
<![CDATA[
[Bindable]
private var myProp:String;
]]>
</mx:Script>
<mx:TextInput id="myTextInput" text="{myProp}"/> <!-- USANDO O
BINDING -->
</mx:Application>
Agora, outro trecho de código gerado pelo Flex, desta vez no arquivo
"Test-generated.as" é o seguinte:
Test-generated.as
===============
private function _Test_bindingsSetup():void
{
...
binding = new mx.binding.Binding(this,
function():String
{
var result:* = (myProp);
var stringResult:String = (result == undefined ?
null : String(result));
return stringResult;
},
function(_sourceFunctionReturnValue:String):void
{
myTextInput.text = _sourceFunctionReturnValue;
},
"myTextInput.text");
...
}
Quem quiser entender o que faz cada linha do trecho de código acima
pode olhar no código fonte da classe mx.binding. Binding. Mas em
resumo, é este trecho de código que pega o valor de "myProp" toda vez
que ele mudar e copia para "myTextInput.text".
Por fim, eu gostaria de sintetizar o que o Daniel e o Erko.
Erko (Tese):
"então a dica é: use [bindable] para o que for realmente necessário "
Daniel (Antítese):
"Use bindable para tudo. Acredito ser muito dificil ele prejudicar a
performance de forma a ser perceptíviel"
Beck (Síntese):
Você pode sim usar o Bindable despreocupadamente do ponto de vista da
performance, mas em alguns casos o Bindable reduz a legibilidade do
seu código, o que dificulta na manutenção. Além disso por usar Event
Listeners, o Bindable cria dependências entre os objetos o que impede
que eles sejam excluídos da memória pelo Garbage Collection.
Será que alguém entedeu alguma coisa? Será que alguém leu tudo
isso? :-)
[]'s
Beck Novaes
On 23 nov, 14:20, Daniel Schmitz <[EMAIL PROTECTED]> wrote:
> "então a dica é: use [bindable] para o que for realmente necessário "
>
> Use bindable para tudo. Acredito ser muito dificil ele prejudicar a
> performance de forma a ser perceptíviel
>
> Outra coisa, o bindable ajuda a manter o seu código mais limpo e com
> mens bugs. Só isso já compensa o 100 milisegundos perdidos por causa
> do bindable.
>
> Agora, não culpe o bindable lento se seu grid tem 10.000 registros :)
> Ae ninguem aguenta :)
>
> Abraços,
> Daniel Schmitz
>
> On 23 nov, 11:45, "Erko Bridee de Almeida Cabrera"
>
> <[EMAIL PROTECTED]> wrote:
> > Marcelo quanto a sua pergunta:
>
> > campos bindable tendem a diminuir a performace do sistema???
>
> > do ponto de vista gasto computacional (aumento do consumo de processamento)
> > a resposta seria SIM, mas isso depende muito de como vc vai usar
>
> > este recurso é amplamente utilizado em aplicações flex
>
> > é como se você tivesse um método set para este atributo que nele
> > vc alem de atualizar o valor do atributo, sai percorrendo toda tua aplicação
> > vendo onde que este está relacionado a campos e outros compontes
> > atualizando os mesmo
>
> > então a dica é: use [bindable] para o que for realmente necessário
>
> > []´s
>
> > Em 23/11/07, Thiago Rodrigues Fernandes <[EMAIL PROTECTED]> escreveu:
>
> > > Eu nunca senti diferença usando bindable ou não...
>
> > > Não sei no caso de muitos registros.
>
> > > --
> > > Att,
> > > Thiago R. Fernandes
>
> > > On Nov 23, 2007 11:16 AM, Marcelo Moacir Florindo <
> > > [EMAIL PROTECTED]> wrote:
>
> > > > campos bindable tendem a diminuir a performace do sistema???
>
> > > > Marcelo
>
> > > > Em 23/11/07, Erko Bridee de Almeida Cabrera < [EMAIL PROTECTED]>
> > > > escreveu:
>
> > > > > Ele indica para oq tu define como bindable que seja observado...
>
> > > > > por exemplo vc tem um atributo e marca ele como observado [bindable]
>
> > > > > e este vc relaciona a um campo....
>
> > > > > quando você mudar o valor desse campo ele irá automaticamente
> > > > > atualizar
> > > > > o campo que está relacionado com este atributo...
>
> > > > > caso tu não utilize o bindable, a atualização do campo não ocorreria
> > > > > quando você alterar o valor do atributo...
>
> > > > > []´s
> > > > > --
> > > > > Att,
> > > > > Erko Bridee de Almeida Cabrera
> > > > >http://erkobridee.com/
> > > > >http://www.portaljava.com
>
> > > > --
> > > > Marcelo Moacir Florindo
> > > > Analista/Desenvolvedor
> > > >http://www.gestaotec.com.br
>
> > --
> > Att,
> > Erko Bridee de Almeida
> > Cabrerahttp://erkobridee.com/http://www.portaljava.com
--~--~---------~--~----~------------~-------~--~----~
Você recebeu esta mensagem porque está inscrito na lista "flexdev"
Para enviar uma mensagem, envie um e-mail para flexdev@googlegroups.com
Para sair da lista, envie um email em branco para [EMAIL PROTECTED]
Mais opções estão disponíveis em http://groups.google.com/group/flexdev
-~----------~----~----~----~------~----~------~--~---
