Este artigo foi traduzido por máquina.

Cutting Edge

Vinculação de dados ao vivo no ASP.NET AJAX 4.0

Dino Esposito

Recentemente eu movido para um novo escritório e passou pelo experiência extremamente gratifying e agradável de todos os livros programação que eu tinha coletados em mais de 10 anos de remessa.

Esses livros poderiam dizer muito claramente como programação Web evoluiu na última década e quais tecnologias seguido um outro, cada melhorando (e em muitos casos revolucionando) a outra.

Um livro em particular detectada minha atenção. Ele abordadas técnicas de programação de última geração (bem, para era) para Internet Explorer 4. Eu não pôde resistir à tentação de percorrer suas páginas.

No final dos anos 90, a grande maioria dos nomes na indústria de computador foram envolvidos no suas tentativas primeira para tornar a Web e o navegador um ambiente dinâmico e altamente programável.

Ligação de dados era apenas um dos muitos recursos populares sendo pesquisadas e desenvolveu. Enquanto a idéia básica de ligação de dados não foi alterado significativamente nos anos, uma transformação real aconteceram como longe como seu aplicativo para o mundo da Web. A abordagem comum para implementar a vinculação de dados pela Web é radicalmente diferente hoje no final dos anos 90 e muito a diferença é devido à Asynchronous JavaScript e AJAX (XML).

Esta coluna, abordarei vários formulários de ligação de dados do lado do cliente como eles são originados no AJAX ASP.NET 4.0. Em particular, falarei sobre alguns recursos avançados de ligação de dados e objetos observáveis.

Princípios básicos

Em geral, a ligação de dados é simplesmente a capacidade do programa para vincular alguns membros de um componente de destino para os membros de uma fonte de dados. Rápido ferramentas de desenvolvimento de aplicativo (RAD) como o Microsoft Access e Microsoft Visual Basic feita uma realidade bem-sucedida de ligação de dados.

Ferramentas RAD oferecida uma infra-estrutura eficiente e fácil para desenvolvedores vincular elementos visuais a membros de uma fonte de dados. Por um longo tempo, a fonte de dados foi identificada exclusivamente com um fluxo de dados do conjunto de registro originadas de uma consulta SQL.

Nesse aspecto, ligação de dados perfeitamente caiba em um cenário de cliente inteligente mas apresenta problemas adicionais se empregado em um cenário de cliente Web. Por exemplo, como seria você fluxo registros do servidor de banco de dados de origem para baixo para o navegador solicitante equipado JavaScript?

Entre muitas outras coisas, que catálogo antigo que abri depois de anos de oblivion discutidos os recursos de ligação de dados do IE4 baseado em alguns dos componentes ActiveX especiais, denominado controle RDS (Remote Data Services) e controle de dados tabular (TDC) adequadamente. Figura 1 ilustra a arquitetura geral de vinculação de dados do lado do cliente como foi desejava por arquitetos IE4 no início da era Web dinâmico.

Figura 1 do cliente Data Binding no Internet Explorer 4

Um controle ActiveX made-to-measure gerencia a conexão com uma fonte de dados remoto e leva dados cuidados de download (e opcionalmente cache). A fonte de dados é qualquer fonte de dados compatível com ODBC com RDS; é um arquivo de texto do lado do servidor com TDC.

A ligação entre elementos de origem e destino real é implementada por meio de atributos HTML específico de navegador, como datasrc, datafld e dataformatas. Aqui está um exemplo rápido:

<span id="Label1" datasrc="#rdsCustomers" datafld="CompanyName" />

O conteúdo do campo acoplado — CompanyName no exemplo — ocupará o espaço reservado para a marca SPAN no DOM (modelo de objeto de documento resultante).

O que faz o trabalho real de inserir dados no DOM?Como mencionado, é o navegador que nesse caso faz o truque.Quando o navegador encontra qualquer atributos de dataXXX, ele consulta o controle de fonte de dados para dados usando uma API interna, contratada.Quaisquer dados que ele obtém serão inseridos no final DOM e exibidos para o usuário.

Como você pode ver, a solução é altamente específicas do navegador e compreensivelmente capturada nunca o coração de desenvolvedores.

Ligação de dados do lado do cliente foi então reserve alguns anos como ASP.NET e seu modelo de programação do lado servidor obteve grande aceitação.

Nos últimos anos, o advento do AJAX gerada muito interesse em torno de ligação de dados do lado do cliente e engenheiros foram volta no trabalho localizando um eficiente (e navegadores este tempo) maneira para torná-lo acontecer.

Evolução no AJAX ASP.NET

Figura 2 mostra a arquitetura geral de vinculação de dados do lado do cliente como ele é implementado no AJAX ASP.NET 4.0.

Figura 2 do cliente Data Binding no AJAX ASP.NET 4.0

Embora as arquiteturas representado Figura 1 e do Figura 2 pode parecer semelhante a princípio, realmente diferem em um número de aspectos-chave.

Primeiro e foremost, com o ASP.NET AJAX 4.0, você pode criar soluções de ligação de dados do lado do cliente que funcionam com qualquer navegador moderno.O código de cola necessário realmente vincular dados de origem para destino elementos agora é parte da biblioteca Microsoft AJAX JavaScript.Como tal, pode ser hospedado em qualquer navegador.

Além disso, para ligação você não tem mais atributos HTML não padrão e proprietários, como datasrc e datafld o navegador deve resolver.Em vez disso, o informações de ligação é especificada usando compatível com XHTML, atributos personalizados namespaced resolvidos pelo código na biblioteca JavaScript.Ele também pode ser feito imperativa.

Estilo antigo versus novo estilo

Outra diferença significativa reside na estrutura do objeto de fonte de dados.Ligação de dados de estilo antigo, você usa uma classificação de proxy caixa-preta que gerencia a recuperação de dados para você.No AJAX ASP.NET 4.0, você não precisa tal ActiveX ou componentes binários.Tudo o que você precisa é um objeto JavaScript com os dados de origem.

Campos ligação interna infra-estrutura links juntos no objeto de origem JavaScript e elementos do DOM.

No AJAX ASP.NET 4.0, como uma infra estrutura de ligação está embutida no componente Sys.UI.DataView.Funcionalmente falando, o objeto DataView opera da mesma maneira como o controle RDS no estilo IE4 ligação de dados de cliente.Ele se conecta diretamente a um ponto de extremidade remoto para obter e expor dados.

No entanto, existem algumas diferenças.O objeto DataView é escrito inteiramente em JavaScript que não requer nenhum suporte especial do navegador para executar um controle de cliente.Como você pode ver, é bem diferente do controle RDS.

Além disso, o controle DataView não interface diretamente com uma fonte de dados relacionais.Em vez disso, ele se conecta para qualquer JavaScript Object Notation (JSON)- ou serviço habilitado JSON com JSONP enchimento, como um ponto de extremidade do Windows Communication Foundation e trocas de dados usando JSON.O serviço pode quebrar qualquer armazenamento de dados físicos (incluindo um banco de dados relacional) ou até mesmo ser um wrapper simples ao redor de um modelo do Entity Framework.Como ilustra a Figura 2, no AJAX ASP.NET 4.0 que pode até mesmo ter ligação de dados sem uma conexão de rede de saída para o servidor.Se, digamos, durante o carregamento, uma página baixa alguns dados na máquina cliente, você pode ter ligação de dados no trabalho em dados localmente em cache sem qualquer mais ida e volta ao servidor.

Um breve resumo

A edição de outubro de 2009 da coluna Cutting Edge ( msdn.microsoft.com/magazine/ee309508.aspx ), abordei as noções básicas de ligação de dados no ASP.NET AJAX 4.0 da perspectiva do desenvolvedor.Enquanto você ainda pode consultar esse artigo cobertura profunda, vou fornecer aqui um breve resumo os fatos de programação mais importantes para vinculação de dados do cliente.

No AJAX ASP.NET 4.0, ligação de dados do lado do cliente pode ocorrer dentro de um modelo HTML adequado.Um modelo é uma árvore DOM decorada com o atributo CSS sys modelo:

<div sys:attach="dataview1" class="sys-template">  
   ...
</div>

O modelo de sys é um nome convencional para um estilo CSS definido pelo usuário que, no mínimo, inclui o seguinte:

<style type="text/css">
   .sys-template { display:none; }
</style>

Decoração de uma determinada marca HTML com atributo modelo sys não é suficiente, entretanto. Você também deve adicionar algum comportamento para a marca que permite que ele processar quaisquer expressões de ligação dentro. Nesse contexto, um comportamento é apenas uma instância de um componente JavaScript made-to-measure ou controle.

Um comportamento pode ser anexado a uma marca HTML, instanciando o comportamento programaticamente ou usando uma abordagem declarativa (adicionando marcação para as marcas de modelo na página). Para a abordagem declarativa, o comportamento deve ser associado com um nome público (prefixo de namespace).

Aqui está um exemplo de atribuir um nome público para uma instância de componente DataView:

<body xmlns:sys="javascript:Sys" 
      xmlns:dataview1="javascript:Sys.UI.DataView">
...
</body>

O sys: anexar atributo obtém um nome público e cria uma instância do objeto referenciado comportamento. No primeiro exemplo de código nesta seção, a marca DIV é capacitada com comportamento expresso por objeto chamado dataview1. Como você pode imaginar, dataview1 é apenas o nome do objeto Sys.UI.DataView JavaScript público.

Depois que uma instância de DataView foi anexada a um modelo do AJAX ASP.NET 4.0, o DataView com êxito pode processar quaisquer expressões de ligação contidas nos modelos. Aqui está um modelo de exemplo com a sintaxe de ligação simples:

<ul id="imageListView" class="sys-template" 
     sys:attach="dataview1" 
    dataview1:data="{{ imageArray }}">
    <li>
        <span>{{ Name }}</span>
        <span>{{ Description }}</span>
    </li>
</ul>

O token {{expressão}} informa DataView para processar a expressão JavaScript incorporada e atribuir o resultado para o DOM ou a propriedade DataView especificada. Por exemplo, o código acima atribui o conteúdo de uma variável JavaScript chamada imageArray para uma propriedade de DataView chamada dados. Dessa forma, defina a fonte de dados da operação de ligação. Essa informação é usada para expandir quaisquer outras expressões de ligação dentro do modelo, como aqueles usados acima no corpo de duas marcas SPAN. Nome e descrição são esperados ser propriedades públicas no item de dados ou itens atribuídos à propriedade de dados do DataView.

Avaliação de expressão embutido

A sintaxe {{expressão}} indica o tipo mais simples de ligação suportado pelo AJAX ASP.NET 4.0. Qualquer ligações expressas dessa maneira são avaliadas somente quando o modelo é processado. Eles nunca são atualizados a menos que o modelo é atualizado programaticamente.

Uma expressão embutido é avaliada contra o estado atual da fonte de dados em tempo de processamento, mas não captura automaticamente outras alterações feitas na fonte de dados.

Um modelo de vinculação mais sofisticados, alternativo também é suportado que fornece a mesma programação energia de vinculação de dados XAML em aplicativos Windows Presentation Foundation e o Silverlight. Como um conjunto de recursos de ligação de dados avançados normalmente são chamados como live vinculação . Let’s saber mais.

Vinculação do Live

Ligação ao vivo garante que o valor exibido na interface do usuário é atualizado automaticamente sempre que alterações de valor ligado os dados de origem. Por exemplo, suponha que você estabelecer uma ligação entre uma marca SPAN e propriedade CompanyName em uma fonte de dados ao vivo. A marca SPAN exibe o valor atual da propriedade CompanyName em tempo de processamento. No entanto, o conteúdo da marca SPAN será automaticamente atualizado sempre que a propriedade de fonte de dados ligada é submetido a alterações. Ligação ao vivo pode ser aplicada a dois objetos, se elementos DOM ou objetos JavaScript.

Uma sintaxe diferente é necessária para expressões de vinculação ao vivo. Eis um exemplo:

<span>{binding CompanyName}</span>

Usar um único par de chaves para encapsular a expressão e prefixo com a ligação de palavra-chave. Como você pode ver, a sintaxe geral tem muito em comum com a sintaxe XAML equivalente, e não uma coincidência.

Deve ser observado que o conteúdo da marca SPAN mostrado anteriormente é atualizado sempre que uma alteração for detectado no item de dados atualmente ligados; o inverso não funcionará. Se o conteúdo de SPAN é atualizado, essa alteração não ser propagada para o objeto de origem.

Ligação ao vivo também pode ser descrita como uma ligação unidirecional que pode acontecer repetidamente como atualizações na fonte de dados são detectadas.

Mantenha a tecla! A estratégia empregada para detectar alterações nas ligações é um ponto chave e terei mais a dizer sobre ela em um momento, mas não antes de introduzir a ligação bidirecional.

Ligação de dados bidirecional

Vinculação de dados bidirecional é um formulário especial de ligação ao vivo que usa dois canais para detectar alterações na ligação. Quando a ligação bidirecional está no lugar entre dois objetos, acontece o seguinte:

• Se as alterações de fonte de dados, o objeto de destino é atualizado automaticamente.
• Se o objeto de destino for alterado, o novo estado é propagado para a fonte de dados subjacente.

Vinculação de dados bidirecional colocar outra maneira, garante que os objetos de origem e destino estão sempre em sincronia.

Nenhum Cruzando camada

A seguir pode talvez parecer uma conclusão foregone, mas deixe-me tornar desmarque assim mesmo. Imagine que você tenha a ligação bidirecional entre uma parte da interface do usuário e alguns dados recuperado de um serviço de um banco de dados.

Os dados baixados do servidor e vinculado elementos visuais da interface do usuário representam um instantâneo do modelo de domínio. Digamos, por exemplo, representa um objeto Customer. Se o objeto Customer exibido é modificado em uma página de ligação bidirecional, em seguida, todas as alterações detectadas são espelhadas para o objeto de Customer lado do cliente, mas nenhuma maneira serão eles propagadas para o servidor. Vinculação de dados bidirecional não cruzada qualquer camadas.

Em termos de sintaxe, a ligação bidirecional é quase a mesma ligação ao vivo unidirecional.

Uma vinculação de ASP.NET AJAX é expresso por meio de um objeto Sys.Binding JavaScript. Você pode controlar a direção do fluxo de dados por meio do atributo mode no objeto Sys.Binding o framework cria para você sempre que use a sintaxe de ligação ao vivo. (Observe que nenhum objeto Sys.Binding é criado quando você optar por simples {...} expressões embutido).

O trecho de código a seguir mostra como configurar usando o atributo mode de vinculação de dados bidirecional:

<span id="Label1">{binding CompanyName, mode=twoWay}></span>

Valores possíveis para o atributo mode são resumidos no do Figura 3.

Figura 3 da enumeração de Sys.BindingMode

Live Binding em ação

Figura 4 mostra o código de exemplo que demonstra a ligação de dados ao vivo, bidirecional.A página contém um modelo é processado usando um controle DataView.O objeto de fonte de dados é uma matriz de JavaScript denominada theCustomers.Não se deixe enganar pelo fato de que theCustomers é um objeto local definido estaticamente dentro do navegador cliente.O que é realmente importante é que theCustomers basicamente é atribuído à propriedade dados do objeto DataView.Objeto DataView tem uma interface de programação avançada que permite que você colocar em propriedade dados qualquer conteúdo, incluindo conteúdo baixado de um serviço da Web.

<asp:Content ID="Content2" runat="server" ContentPlaceHolderID="PH_Head">
  
    <link rel="stylesheet" type="text/css" 
      href="../../Css/lessantique.css" />
    <style type="text/css">
        .sys-template { display:none; }
    </style>
    
    <script type="text/javascript">
        var theCustomers = [
           { ID: "ALFKI", CompanyName: 
            "Alfred Futterkiste" },
           { ID: "CONTS", CompanyName: 
           "Contoso" }
        ];
    </script>
</asp:Content>    

<asp:Content ID="Content5" 
  ContentPlaceHolderID="PH_Body" 
  runat="server">

    <asp:ScriptManagerProxy  
    runat="server">
        <Scripts>
          <asp:ScriptReference Path=
"https://ajax.microsoft.com/ajax/beta/0910/MicrosoftAjaxTemplates.js" />
        </Scripts>
    </asp:ScriptManagerProxy>

    <div id="customerList">
       <ul class="sys-template" 
         sys:attach="dataview" dataview:data="{{ theCustomers }}">
         <li>
           <span><b>{binding ID}</b></span>
           <input type="text" id="TextBox1" 
             value="{binding CompanyName}" /> 
           <br />  
           <span>Currently displaying... 
<b>{binding CompanyName}</b></span>  
         </li>
       </ul>
    </div>
</asp:Content>

Figura 4 Live ligação bidirecional Sample

Para cada item de dados vinculado, o modelo emite uma marca LI inclui uma caixa de texto. A caixa de texto está ligada à propriedade CompanyName da origem. No mesmo modelo, uma marca SPAN também é acoplada a propriedade CompanyName da origem.

Observe que ao vivo ligações não são limitadas ao modelo que eles pertencem. Você pode ter a mesma expressão — digamos, {CompanyName a ligação} — em dois modelos diferentes. Como o mesmo objeto de fonte de dados (ou um objeto compatível) está anexado a ambos os modelos, a ligação sempre será resolvida corretamente. A Figura 5 mostra a página em ação.

Figura 5 Live ligação em ação

Inicialmente a caixa de texto e a marca SPAN contêm os mesmos dados. No entanto, em algum momento o usuário pode iniciar editando o nome da empresa na caixa de texto. Nada acontece até as guias de usuário da caixa de texto.

A fase de edição é considerada completa assim que a caixa de texto perde o foco. Neste ponto, o mecanismo de ligação de dados bidirecional dispara e atualiza o objeto de fonte de dados subjacente. Porque a marca SPAN também está vinculada à mesma propriedade de dados por meio de ligação do live, as alterações são propagadas.

Para impedir a atualização automática da fonte de dados quando um elemento INPUT é envolvido, você definir a propriedade modo explicitamente, como mostrado abaixo:

<input type="text" value="{binding CompanyName, mode=oneWay}" />

Insira essa alteração ao código na Figura 4 e ver a diferença.

Detectando alterações

Quando a propriedade modo de ligação não é definida explicitamente, pega o valor de automático conforme descrito em do Figura 3. Portanto, quando você anexa uma ligação para quaisquer elementos HTML que se referem a cenários (como INPUT, SELECT ou TEXTAREA) de entrada, o modo de propriedade padrão twoWay. Como resultado, todas as alterações para o destino feitas através da interface do usuário do navegador são transferidas automaticamente para a fonte.

Observe que há duas variações de uma ligação unidirecional. A ligação padrão unidirecional detecta alterações na fonte e reflete na interface do usuário. OneWayToSource alternativo faz o inverso: ele detecta alterações no destino e reflete no objeto de origem. Tente usar o seguinte código:

<input type="text" value="{binding CompanyName, mode=oneWayToSource}" />

A exibição inicial da página irá conter caixas de texto vazia. Conforme você digita, porém, o novo texto é detectado e processado como esperado.

A opção de ligação de dados bidirecional também é a opção padrão para qualquer objeto JavaScript acoplado que acontece implementar a interface Sys.INotifyPropertyChange. (A interface é parte da biblioteca Microsoft AJAX JavaScript).

Quando apresentei primeiro ligação ao vivo, disse que o destino é atualizado sempre que altera a fonte. A seguir explica quais alterações pode detectar o framework e como.

Elementos de entrada HTML acionam eventos padrão ao seu estado é alterado ou, no mínimo, notificar quando eles entrar ou sair uma fase de edição. Porque esses eventos são parte do padrão HTML, qualquer solução de ligação de dados com base no que padrão funcionará em qualquer navegadores.

Para obter uma atualização para um lado da ligação refletidas no outro, ele tem feito em uma forma que é possível detectar. Suponha que você tem uma ligação onde a fonte é uma matriz de JavaScript, como mostrado aqui:

<ul class="sys-template" sys:attach="dataview" 
    dataview:data="{{ theCustomers }}">
  <li>
     <span ><b>{binding CompanyName}</b></span>
  </li>
</ul>

Tente atualizar a propriedade CompanyName em um objeto dentro da matriz. A marcação mostra um botão que se clicou em execuções enterChanges JavaScript função, mostrado aqui:

<span>{binding CompanyName}</span>
<input type="button" value="Enter changes" 
onclick="enterChanges()" />
...
<script type="text/javascript">
    function enterChanges() {
        theCustomers[0].CompanyName = 
       "This is a new name";
    }
</script>

Função enterChanges atualiza a propriedade CompanyName no primeiro objeto na matriz. Como você pode ver, isso é claramente uma operação que atualiza o estado de um objeto acoplado.

No caso de ligação ao vivo, você deve esperar a marca SPAN para exibir o novo valor. Se você tentar que, no entanto, você verá que nada acontece.

Que é porque não há nenhuma maneira de navegadores para ser notificado das atualizações ocorrendo para um objeto JavaScript antigo sem formatação, como. Então acontecem alterações mas a ligação não estiver ciente delas e a interface do usuário não está atualizada.

Sondando o estado de um objeto JavaScript simples seria uma solução viável? Provavelmente não, e a equipe de desenvolvimento razoavelmente descartar a possibilidade de que opção essencialmente por motivos de escalabilidade.

No final, está usando elementos HTML input vinculados a dados a possibilidade de tornar os dados apenas altera de forma que dispararão outras ligações ao vivo com êxito? Bem, não exatamente. A biblioteca Microsoft AJAX JavaScript recursos uma API estática através do qual você pode "observar" alterações de qualquer objeto JavaScript. Essa API também está disponível em um tipo que transforma um objeto JavaScript simples em um objeto observável para maquinaria ligação detectar atualizações.

Objetos JavaScript observável

Um objeto JavaScript observável é alterar de um objeto endowed com funcionalidades adicionais que dispara notificações quando modificado. Funcionalidade adicional é materializada através da interface Sys.Observer. Observe que as alterações feitas diretamente, sem passar por interface, não irão gerar notificações de alteração e será ignorada pela infra-estrutura de ligação.

Objetos observáveis perfeitamente cabem em um cenário onde você deseja estabelecer ligações ao vivo entre elementos visuais e objetos JavaScript, como aqueles que pode obter de um serviço da Web remoto.

Há duas maneiras de trabalhar com objetos observáveis. Uma envolve fazer um determinado objeto observáveis adicionando alguns códigos dinâmicos — não o suficiente para tornar um objeto algo complexo mas suficiente para adicionar novos recursos de JavaScript simples. Veja um exemplo:

<script type="text/javascript">
    var theCustomers = [
            { ID: "ALFKI", CompanyName: 
            "Alfred Futterkiste" },
            { ID: "CONTS", CompanyName: 
            "Contoso" }
        ];    
    function pageLoad() {
        Sys.Observer.makeObservable(theCustomers);
    }
    
    function onInsert() {
        var newCustomer = { ID: "ANYNA", 
        CompanyName: "AnyNameThatWorks Inc" };
        theCustomers.add(newCustomer);
    }
</script>

Método Sys.Observer.makeObservable leva um objeto JavaScript (incluindo matrizes) e adiciona métodos que você pode usar para fazer alterações no objeto que podem detectar as ligações. Observe que ter uma matriz observável fornece métodos para alterar a matriz de maneira observável — portanto, você poderá detectar inserções e exclusões. Mas ele não fornecerá automaticamente os métodos correspondentes para modificar as propriedades de itens individuais na matriz de maneira observável. Para que, você pode chamar separadamente makeObservable em itens individuais, e eles também terá métodos adicionais adicionados.

 Como mencionei anteriormente, o seguinte código associado a um evento de clique não disparar a ligação:

<script type="text/javascript">
    function enterChanges() {
        theCustomers[0].CompanyName = 
        "This is a new name";
    }
</script>

No entanto, esse código irá disparar a ligação:

<script type="text/javascript">
    function enterChanges() {
       System.Observer.setValue(theCustomers[0], 
       "CompanyName", "New name");
    }
</script>

Se o objeto observado tem objetos filho? Nenhuma preocupação: método setValue sabe como manipular "pontilhada" sintaxe:

System.Observer.setValue(theCustomers[0], "Company.Address.City", "Rome");

Finalmente, observe que o observador padrão pode ser aplicado a qualquer objeto que você pode encontrar no contexto de uma página da Web, incluindo elementos DOM, comportamentos e até mesmo navegador objetos como janela.

Estático e dinâmico

A maioria das vezes quando você precisar de ligação de dados em um aplicativo, você também precisa que ele seja ao vivo, pelo menos unidirecional, se não bidirecional.No AJAX ASP.NET 4.0, ligação de dados pode ser tanto estático — isto é, uma avaliação embutida simples de valores de dados durante o processamento — e dinâmicos no sentido de que ele pode detectar alterações na origem ou destino e aplicar them.Not todas as atualizações podem ser detectadas e usadas para atualizar as ligações.AJAX ASP.NET 4.0 reconhece facilmente alterações inseridas em objetos vinculados por meio de elementos visuais.Mas para alterações programaticamente inseridas em matrizes ou objetos JavaScript, não há nenhuma maneira confiável de navegadores têm ao vivo detecção de alterações.O truque no ASP.NET AJAX consiste em fornecer uma maneira de fazer alterações para que eles estiver observáveis e portanto podem ser detectados pelo ligações ao vivo.Isso leva o formulário de acrescentar algumas operações observáveis para o objeto ou, como alternativa, usando o ad hoc Sys.Observer métodos estáticos para conduzir as atualizações.

Dino Esposito  é autor da futuros “ programação ASP.NET MVC 2 ” (Microsoft Press, 2010). Com base na Itália, Esposito é palestrante assíduo em eventos do setor no mundo inteiro. Você pode ingressar em seu blog em weblogs.asp.net/desposde .

Graças aos seguintes especialistas técnicos para revisão deste artigo: Dave Reed e Boris Rivers-Moore