Qual a sacada do Bindable?

[Marcelo Moacir Florindo]

Qual a função do Bindable??? Estou vendo que tem algo a ver com ligação.......mas porque a necessidade de enfatizar isto no código??

Grato a todos...


--
Marcelo Moacir Florindo
Analista/Desenvolvedor
http://www.gestaotec.com.br

[Erko Bridee de Almeida Cabrera]

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]

campos bindable tendem a diminuir a performace do sistema???

Marcelo

Em 23/11/07, Erko Bridee de Almeida Cabrera < erko....@gmail.com> escreveu:

[Thiago Rodrigues Fernandes]

Eu nunca senti diferença usando bindable ou não...

Não sei no caso de muitos registros.


--
Att,
Thiago R. Fernandes

[Erko Bridee de Almeida Cabrera]

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 < thifer...@gmail.com> escreveu:

[Daniel Schmitz]

"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"

<erko.bri...@gmail.com> 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 <thifernan...@gmail.com> 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 <

> > marceloflori...@gmail.com> wrote:
>
> > > campos bindable tendem a diminuir a performace do sistema???
>
> > > Marcelo
>

> > > Em 23/11/07, Erko Bridee de Almeida Cabrera < erko.bri...@gmail.com>

[Beck Novaes]

######################################################
# 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

[Erko Bridee de Almeida Cabrera]

hehe excelente explicação ;)

quanto minha citação foi sobre algo assim como ocorre no java com o
garbarage collector, tem é bom, mas é sempre bom procurar uma forma otimizada de
utilizar \o/

com o bindable mesma coisa, é ótimo, quebra um galho
mas quanto mais otimizarmos o nosso código melhor ;)

[]´s

Em 27/11/07, Beck Novaes <beck....@gmail.com > escreveu:

_Test- binding-generated.as (Código gerado pelo compilador Flex)

http://erkobridee.com/
http://www.portaljava.com

[Marcelo Moacir Florindo]

Boa explanação....
Valeu!

hehehe

Em 27/11/07, Erko Bridee de Almeida Cabrera <erko....@gmail.com > escreveu:

[Daniel Reginatto]

Ae Galera to precisando de uma Luz ai...
To tentando criar janelas na minha aplicação de uma forma genérica. Porem estou tendo algum problema com ActionScript.

Desta forma consigo abrir a janela

click="openWindow()"

import modulos.*;
import mx.events.CloseEvent;
import mx.managers.PopUpManager;
 
// objeto JANELA
private var windowAtual:agendar;

// Nossa função que cria e abre a janela
private function openWindow():void{
    // Instância a JANELA
    this.windowAtual = new agendar();

Porém quando tento abrir uma janela X passando por parametro o nome do modulo ou objeto que quero que abra... retorna o seguinte erro

TypeError: Error #1007: Instantiation attempted on a non-constructor.

Estou tentando chamar assim: click="openWindow('agendar') // agendar seria o "modulo" que quero que abra

import modulos.*;
import mx.containers.TitleWindow;
import mx.events.CloseEvent;
import mx.managers.PopUpManager;
 
// Nossa JANELA
private var windowAtual:TitleWindow;
private var windowAtual:agendar; // antes estava assim (não encontrei uma forma de passar o meu modulo para a variavel)

// Nossa função que cria e abre a janela // modulo é o agendar que vem como parâmetro.
private function openWindow(modulo:Object):void{
    // Instância a JANELA
    this.windowAtual = new modulo();
   
    // Adiciona a JANELA na aplicação main
    // o this é o pai, ou seja, onde será adicionada a janela
    // o true é o tipo de janela modal = true ou não modal = false
    PopUpManager.addPopUp(windowAtual, this, true);
    PopUpManager.centerPopUp(windowAtual);
   
    // adiciona o evento na JANELA
    windowAtual.addEventListener(CloseEvent.CLOSE,function():void{
        PopUpManager.removePopUp(windowAtual);
    }
    );
}

[Daniel Reginatto]

Já consegui resolver...

Estou tentando chamar assim: click="openWindow(agendar)  // o problema esva aqui na chamada do objeto...

import modulos.*;
import mx.containers.TitleWindow;
import mx.events.CloseEvent;
import mx.managers.PopUpManager;
 
// Nossa JANELA
private var windowAtual:TitleWindow;

[Rogerio Gonzalez]

poxa Daniel,

Eu tenho um grid assim e nem é tão lento. Ele no máximo leva de 1 a 2
segundos pra processar.

Sim, é lento, mas para a quantidade de registros, eh uma lerdeza
aceitavel perto de uma paginação :)

Abraços!

Rogério

[Daniel Reginatto]

Só é possivel acessar o HTTPService dentro de uma Application?
Estou tentando executar ele dentro de um modulo que abre e da erro.
Tentei dar um             import     mx.rpc.http.mxml.HTTPService;  dentro do meu modulo
mas não resolveu, alguem tem mais informações sobre isto?

Todas as documentações que consegui ler até agora trabalham com ele dentro do Application...

Inclusive consegui rodar o código usando dentro do meu arquivo main, porem
quando abro um modulo popUp e tento rodar o HTTPService lá dentro da Parser Error.
Acredito que seja por que não tenho no modulo as classes que preciso pra ele trabalhar...

Se alguem puder ajudar...

Agradeço qualquer informação...


Abraços

Daniel Reginatto